]> 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
reSWIGged
[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_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPosition swig_types[96]
2563 #define SWIGTYPE_p_wxPropagateOnce swig_types[97]
2564 #define SWIGTYPE_p_wxPropagationDisabler swig_types[98]
2565 #define SWIGTYPE_p_wxPyApp swig_types[99]
2566 #define SWIGTYPE_p_wxPyCommandEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyDropTarget swig_types[101]
2568 #define SWIGTYPE_p_wxPyEvent swig_types[102]
2569 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyImageHandler swig_types[104]
2571 #define SWIGTYPE_p_wxPyInputStream swig_types[105]
2572 #define SWIGTYPE_p_wxPySizer swig_types[106]
2573 #define SWIGTYPE_p_wxPyValidator swig_types[107]
2574 #define SWIGTYPE_p_wxQuantize swig_types[108]
2575 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[109]
2576 #define SWIGTYPE_p_wxRealPoint swig_types[110]
2577 #define SWIGTYPE_p_wxRect swig_types[111]
2578 #define SWIGTYPE_p_wxRect2D swig_types[112]
2579 #define SWIGTYPE_p_wxRegion swig_types[113]
2580 #define SWIGTYPE_p_wxScrollEvent swig_types[114]
2581 #define SWIGTYPE_p_wxScrollWinEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSetCursorEvent swig_types[116]
2583 #define SWIGTYPE_p_wxShowEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSize swig_types[118]
2585 #define SWIGTYPE_p_wxSizeEvent swig_types[119]
2586 #define SWIGTYPE_p_wxSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSizerFlags swig_types[121]
2588 #define SWIGTYPE_p_wxSizerItem swig_types[122]
2589 #define SWIGTYPE_p_wxStaticBox swig_types[123]
2590 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[124]
2591 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[125]
2592 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[126]
2593 #define SWIGTYPE_p_wxTGAHandler swig_types[127]
2594 #define SWIGTYPE_p_wxTIFFHandler swig_types[128]
2595 #define SWIGTYPE_p_wxToolTip swig_types[129]
2596 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[130]
2597 #define SWIGTYPE_p_wxValidator swig_types[131]
2598 #define SWIGTYPE_p_wxVisualAttributes swig_types[132]
2599 #define SWIGTYPE_p_wxWindow swig_types[133]
2600 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[134]
2601 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[135]
2602 #define SWIGTYPE_p_wxXPMHandler swig_types[136]
2603 #define SWIGTYPE_p_wxZipFSHandler swig_types[137]
2604 static swig_type_info *swig_types[139];
2605 static swig_module_info swig_module = {swig_types, 138, 0, 0, 0, 0};
2606 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2607 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2608
2609 /* -------- TYPES TABLE (END) -------- */
2610
2611 #if (PY_VERSION_HEX <= 0x02000000)
2612 # if !defined(SWIG_PYTHON_CLASSIC)
2613 # error "This python version requires to use swig with the '-classic' option"
2614 # endif
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodern' option"
2618 #endif
2619 #if (PY_VERSION_HEX <= 0x02020000)
2620 # error "This python version requires to use swig with the '-nomodernargs' option"
2621 #endif
2622 #ifndef METH_O
2623 # error "This python version requires to use swig with the '-nofastunpack' option"
2624 #endif
2625
2626 /*-----------------------------------------------
2627 @(target):= _core_.so
2628 ------------------------------------------------*/
2629 #define SWIG_init init_core_
2630
2631 #define SWIG_name "_core_"
2632
2633 #define SWIGVERSION 0x010329
2634
2635
2636 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2637 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2638
2639
2640 #include <stdexcept>
2641
2642
2643 namespace swig {
2644 class PyObject_ptr {
2645 protected:
2646 PyObject *_obj;
2647
2648 public:
2649 PyObject_ptr() :_obj(0)
2650 {
2651 }
2652
2653 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2654 {
2655 Py_XINCREF(_obj);
2656 }
2657
2658 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2659 {
2660 if (initial_ref) Py_XINCREF(_obj);
2661 }
2662
2663 PyObject_ptr & operator=(const PyObject_ptr& item)
2664 {
2665 Py_XINCREF(item._obj);
2666 Py_XDECREF(_obj);
2667 _obj = item._obj;
2668 return *this;
2669 }
2670
2671 ~PyObject_ptr()
2672 {
2673 Py_XDECREF(_obj);
2674 }
2675
2676 operator PyObject *() const
2677 {
2678 return _obj;
2679 }
2680
2681 PyObject *operator->() const
2682 {
2683 return _obj;
2684 }
2685 };
2686 }
2687
2688
2689 namespace swig {
2690 struct PyObject_var : PyObject_ptr {
2691 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2692
2693 PyObject_var & operator = (PyObject* obj)
2694 {
2695 Py_XDECREF(_obj);
2696 _obj = obj;
2697 return *this;
2698 }
2699 };
2700 }
2701
2702
2703 #include "wx/wxPython/wxPython_int.h"
2704 #include "wx/wxPython/pyclasses.h"
2705 #include "wx/wxPython/twoitem.h"
2706
2707
2708 #ifndef wxPyUSE_EXPORT
2709 // Helper functions for dealing with SWIG objects and such. These are
2710 // located here so they know about the SWIG types and functions declared
2711 // in the wrapper code.
2712
2713 #include <wx/hashmap.h>
2714 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2715
2716
2717 // Maintains a hashmap of className to swig_type_info pointers. Given the
2718 // name of a class either looks up the type info in the cache, or scans the
2719 // SWIG tables for it.
2720 extern PyObject* wxPyPtrTypeMap;
2721 static
2722 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2723
2724 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2725
2726 if (typeInfoCache == NULL)
2727 typeInfoCache = new wxPyTypeInfoHashMap;
2728
2729 wxString name(className);
2730 swig_type_info* swigType = (*typeInfoCache)[name];
2731
2732 if (! swigType) {
2733 // it wasn't in the cache, so look it up from SWIG
2734 name.Append(wxT(" *"));
2735 swigType = SWIG_TypeQuery(name.mb_str());
2736
2737 // if it still wasn't found, try looking for a mapped name
2738 if (!swigType) {
2739 PyObject* item;
2740 name = className;
2741
2742 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2743 (char*)(const char*)name.mbc_str())) != NULL) {
2744 name = wxString(PyString_AsString(item), *wxConvCurrent);
2745 name.Append(wxT(" *"));
2746 swigType = SWIG_TypeQuery(name.mb_str());
2747 }
2748 }
2749 if (swigType) {
2750 // and add it to the map if found
2751 (*typeInfoCache)[className] = swigType;
2752 }
2753 }
2754 return swigType;
2755 }
2756
2757
2758 // Check if a class name is a type known to SWIG
2759 bool wxPyCheckSwigType(const wxChar* className) {
2760
2761 swig_type_info* swigType = wxPyFindSwigType(className);
2762 return swigType != NULL;
2763 }
2764
2765
2766 // Given a pointer to a C++ object and a class name, construct a Python proxy
2767 // object for it.
2768 PyObject* wxPyConstructObject(void* ptr,
2769 const wxChar* className,
2770 int setThisOwn) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2774
2775 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2776 }
2777
2778
2779 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2780 // Ensures that the proxy object is of the specified (or derived) type. If
2781 // not able to perform the conversion then a Python exception is set and the
2782 // error should be handled properly in the caller. Returns True on success.
2783 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2784 const wxChar* className) {
2785
2786 swig_type_info* swigType = wxPyFindSwigType(className);
2787 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2788
2789 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2790 }
2791
2792
2793
2794 // Make a SWIGified pointer object suitable for a .this attribute
2795 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2796
2797 PyObject* robj = NULL;
2798
2799 swig_type_info* swigType = wxPyFindSwigType(className);
2800 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2801
2802 robj = PySwigObject_New(ptr, swigType, 0);
2803 return robj;
2804 }
2805
2806
2807 // Python's PyInstance_Check does not return True for instances of new-style
2808 // classes. This should get close enough for both new and old classes but I
2809 // should re-evaluate the need for doing instance checks...
2810 bool wxPyInstance_Check(PyObject* obj) {
2811 return PyObject_HasAttrString(obj, "__class__") != 0;
2812 }
2813
2814
2815 // This one checks if the object is an instance of a SWIG proxy class (it has
2816 // a .this attribute, and the .this attribute is a PySwigObject.)
2817 bool wxPySwigInstance_Check(PyObject* obj) {
2818 static PyObject* this_str = NULL;
2819 if (this_str == NULL)
2820 this_str = PyString_FromString("this");
2821
2822 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2823 if (this_attr) {
2824 bool retval = (PySwigObject_Check(this_attr) != 0);
2825 Py_DECREF(this_attr);
2826 return retval;
2827 }
2828
2829 PyErr_Clear();
2830 return false;
2831 }
2832
2833
2834 // Export a C API in a struct. Other modules will be able to load this from
2835 // the wx._core_ module and will then have safe access to these functions,
2836 // even if they are located in another shared library.
2837 static wxPyCoreAPI API = {
2838
2839 wxPyCheckSwigType,
2840 wxPyConstructObject,
2841 wxPyConvertSwigPtr,
2842 wxPyMakeSwigPtr,
2843
2844 wxPyBeginAllowThreads,
2845 wxPyEndAllowThreads,
2846 wxPyBeginBlockThreads,
2847 wxPyEndBlockThreads,
2848
2849 wxPy_ConvertList,
2850
2851 wxString_in_helper,
2852 Py2wxString,
2853 wx2PyString,
2854
2855 byte_LIST_helper,
2856 int_LIST_helper,
2857 long_LIST_helper,
2858 string_LIST_helper,
2859 wxPoint_LIST_helper,
2860 wxBitmap_LIST_helper,
2861 wxString_LIST_helper,
2862 wxAcceleratorEntry_LIST_helper,
2863
2864 wxSize_helper,
2865 wxPoint_helper,
2866 wxRealPoint_helper,
2867 wxRect_helper,
2868 wxColour_helper,
2869 wxPoint2D_helper,
2870
2871 wxPySimple_typecheck,
2872 wxColour_typecheck,
2873
2874 wxPyCBH_setCallbackInfo,
2875 wxPyCBH_findCallback,
2876 wxPyCBH_callCallback,
2877 wxPyCBH_callCallbackObj,
2878 wxPyCBH_delete,
2879
2880 wxPyMake_wxObject,
2881 wxPyMake_wxSizer,
2882 wxPyPtrTypeMap_Add,
2883 wxPy2int_seq_helper,
2884 wxPy4int_seq_helper,
2885 wxArrayString2PyList_helper,
2886 wxArrayInt2PyList_helper,
2887
2888 wxPyClientData_dtor,
2889 wxPyUserData_dtor,
2890 wxPyOORClientData_dtor,
2891
2892 wxPyCBInputStream_create,
2893 wxPyCBInputStream_copy,
2894
2895 wxPyInstance_Check,
2896 wxPySwigInstance_Check,
2897
2898 wxPyCheckForApp,
2899
2900 wxArrayDouble2PyList_helper,
2901 wxPoint2D_LIST_helper,
2902 wxRect2D_helper,
2903 wxPosition_helper,
2904
2905 };
2906
2907 #endif
2908
2909
2910 #if !WXWIN_COMPATIBILITY_2_4
2911 #define wxHIDE_READONLY 0
2912 #endif
2913
2914
2915 #define SWIG_From_long PyInt_FromLong
2916
2917
2918 SWIGINTERNINLINE PyObject *
2919 SWIG_From_int (int value)
2920 {
2921 return SWIG_From_long (value);
2922 }
2923
2924 static const wxString wxPyEmptyString(wxEmptyString);
2925 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2926 return self->GetClassInfo()->GetClassName();
2927 }
2928 SWIGINTERN void wxObject_Destroy(wxObject *self){
2929 delete self;
2930 }
2931
2932 #ifndef __WXMAC__
2933 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2934 #endif
2935
2936
2937 #include <limits.h>
2938 #ifndef LLONG_MIN
2939 # define LLONG_MIN LONG_LONG_MIN
2940 #endif
2941 #ifndef LLONG_MAX
2942 # define LLONG_MAX LONG_LONG_MAX
2943 #endif
2944 #ifndef ULLONG_MAX
2945 # define ULLONG_MAX ULONG_LONG_MAX
2946 #endif
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_long (PyObject* obj, long* val)
2951 {
2952 if (PyNumber_Check(obj)) {
2953 if (val) *val = PyInt_AsLong(obj);
2954 return SWIG_OK;
2955 }
2956 return SWIG_TypeError;
2957 }
2958
2959
2960 SWIGINTERN int
2961 SWIG_AsVal_int (PyObject * obj, int *val)
2962 {
2963 long v;
2964 int res = SWIG_AsVal_long (obj, &v);
2965 if (SWIG_IsOK(res)) {
2966 if ((v < INT_MIN || v > INT_MAX)) {
2967 return SWIG_OverflowError;
2968 } else {
2969 if (val) *val = static_cast< int >(v);
2970 }
2971 }
2972 return res;
2973 }
2974
2975 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2976 wxSize temp, *obj = &temp;
2977 if ( other == Py_None ) return false;
2978 if ( ! wxSize_helper(other, &obj) ) {
2979 PyErr_Clear();
2980 return false;
2981 }
2982 return self->operator==(*obj);
2983 }
2984 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2985 wxSize temp, *obj = &temp;
2986 if ( other == Py_None ) return true;
2987 if ( ! wxSize_helper(other, &obj)) {
2988 PyErr_Clear();
2989 return true;
2990 }
2991 return self->operator!=(*obj);
2992 }
2993
2994 #include <float.h>
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_double (PyObject *obj, double* val)
2999 {
3000 if (PyNumber_Check(obj)) {
3001 if (val) *val = PyFloat_AsDouble(obj);
3002 return SWIG_OK;
3003 }
3004 return SWIG_TypeError;
3005 }
3006
3007
3008 SWIGINTERN int
3009 SWIG_AsVal_float (PyObject * obj, float *val)
3010 {
3011 double v;
3012 int res = SWIG_AsVal_double (obj, &v);
3013 if (SWIG_IsOK(res)) {
3014 if ((v < -FLT_MAX || v > FLT_MAX)) {
3015 return SWIG_OverflowError;
3016 } else {
3017 if (val) *val = static_cast< float >(v);
3018 }
3019 }
3020 return res;
3021 }
3022
3023 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3024 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3025 PyObject* tup = PyTuple_New(2);
3026 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3027 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3028 //wxPyEndBlockThreads(blocked);
3029 return tup;
3030 }
3031
3032 #define SWIG_From_double PyFloat_FromDouble
3033
3034 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3035 wxRealPoint temp, *obj = &temp;
3036 if ( other == Py_None ) return false;
3037 if ( ! wxRealPoint_helper(other, &obj) ) {
3038 PyErr_Clear();
3039 return false;
3040 }
3041 return self->operator==(*obj);
3042 }
3043 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3044 wxRealPoint temp, *obj = &temp;
3045 if ( other == Py_None ) return true;
3046 if ( ! wxRealPoint_helper(other, &obj)) {
3047 PyErr_Clear();
3048 return true;
3049 }
3050 return self->operator!=(*obj);
3051 }
3052 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3053 self->x = x;
3054 self->y = y;
3055 }
3056 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3057 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3058 PyObject* tup = PyTuple_New(2);
3059 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3060 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3061 //PyEndBlockThreads(blocked);
3062 return tup;
3063 }
3064 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3065 wxPoint temp, *obj = &temp;
3066 if ( other == Py_None ) return false;
3067 if ( ! wxPoint_helper(other, &obj) ) {
3068 PyErr_Clear();
3069 return false;
3070 }
3071 return self->operator==(*obj);
3072 }
3073 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3074 wxPoint temp, *obj = &temp;
3075 if ( other == Py_None ) return true;
3076 if ( ! wxPoint_helper(other, &obj)) {
3077 PyErr_Clear();
3078 return true;
3079 }
3080 return self->operator!=(*obj);
3081 }
3082 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3083 self->x = x;
3084 self->y = y;
3085 }
3086 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3087 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3088 PyObject* tup = PyTuple_New(2);
3089 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3090 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3091 //wxPyEndBlockThreads(blocked);
3092 return tup;
3093 }
3094 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3095 wxRect temp, *obj = &temp;
3096 if ( other == Py_None ) return false;
3097 if ( ! wxRect_helper(other, &obj) ) {
3098 PyErr_Clear();
3099 return false;
3100 }
3101 return self->operator==(*obj);
3102 }
3103 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3104 wxRect temp, *obj = &temp;
3105 if ( other == Py_None ) return true;
3106 if ( ! wxRect_helper(other, &obj)) {
3107 PyErr_Clear();
3108 return true;
3109 }
3110 return self->operator!=(*obj);
3111 }
3112 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3113 self->x = x;
3114 self->y = y;
3115 self->width = width;
3116 self->height = height;
3117 }
3118 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3119 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3120 PyObject* tup = PyTuple_New(4);
3121 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3122 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3123 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3124 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3125 //wxPyEndBlockThreads(blocked);
3126 return tup;
3127 }
3128
3129 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3130 wxRegion reg1(*r1);
3131 wxRegion reg2(*r2);
3132 wxRect dest(0,0,0,0);
3133 PyObject* obj;
3134
3135 reg1.Intersect(reg2);
3136 dest = reg1.GetBox();
3137
3138 if (dest != wxRect(0,0,0,0)) {
3139 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3140 wxRect* newRect = new wxRect(dest);
3141 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3142 //wxPyEndBlockThreads(blocked);
3143 return obj;
3144 }
3145 Py_INCREF(Py_None);
3146 return Py_None;
3147 }
3148
3149 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3150 wxPoint2D temp, *obj = &temp;
3151 if ( other == Py_None ) return false;
3152 if ( ! wxPoint2D_helper(other, &obj) ) {
3153 PyErr_Clear();
3154 return false;
3155 }
3156 return self->operator==(*obj);
3157 }
3158 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3159 wxPoint2D temp, *obj = &temp;
3160 if ( other == Py_None ) return true;
3161 if ( ! wxPoint2D_helper(other, &obj)) {
3162 PyErr_Clear();
3163 return true;
3164 }
3165 return self->operator!=(*obj);
3166 }
3167 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3168 self->m_x = x;
3169 self->m_y = y;
3170 }
3171 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3172 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3173 PyObject* tup = PyTuple_New(2);
3174 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3175 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3176 //wxPyEndBlockThreads(blocked);
3177 return tup;
3178 }
3179 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3180 wxRect2D temp, *obj = &temp;
3181 if ( other == Py_None ) return false;
3182 if ( ! wxRect2D_helper(other, &obj) ) {
3183 PyErr_Clear();
3184 return false;
3185 }
3186 return self->operator==(*obj);
3187 }
3188 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3189 wxRect2D temp, *obj = &temp;
3190 if ( other == Py_None ) return true;
3191 if ( ! wxRect2D_helper(other, &obj)) {
3192 PyErr_Clear();
3193 return true;
3194 }
3195 return self->operator!=(*obj);
3196 }
3197 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3198 self->m_x = x;
3199 self->m_y = y;
3200 self->m_width = width;
3201 self->m_height = height;
3202 }
3203 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3204 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3205 PyObject* tup = PyTuple_New(4);
3206 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3207 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3208 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3209 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3210 //wxPyEndBlockThreads(blocked);
3211 return tup;
3212 }
3213 SWIGINTERN bool wxPosition___eq__(wxPosition *self,PyObject *other){
3214 wxPosition temp, *obj = &temp;
3215 if ( other == Py_None ) return false;
3216 if ( ! wxPosition_helper(other, &obj) ) {
3217 PyErr_Clear();
3218 return false;
3219 }
3220 return self->operator==(*obj);
3221 }
3222 SWIGINTERN bool wxPosition___ne__(wxPosition *self,PyObject *other){
3223 wxPosition temp, *obj = &temp;
3224 if ( other == Py_None ) return true;
3225 if ( ! wxPosition_helper(other, &obj)) {
3226 PyErr_Clear();
3227 return true;
3228 }
3229 return self->operator!=(*obj);
3230 }
3231
3232 #include "wx/wxPython/pyistream.h"
3233
3234 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3235 wxInputStream* wxis = wxPyCBInputStream::create(p);
3236 if (wxis)
3237 return new wxPyInputStream(wxis);
3238 else
3239 return NULL;
3240 }
3241
3242 SWIGINTERN swig_type_info*
3243 SWIG_pchar_descriptor()
3244 {
3245 static int init = 0;
3246 static swig_type_info* info = 0;
3247 if (!init) {
3248 info = SWIG_TypeQuery("_p_char");
3249 init = 1;
3250 }
3251 return info;
3252 }
3253
3254
3255 SWIGINTERNINLINE PyObject *
3256 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3257 {
3258 if (carray) {
3259 if (size > INT_MAX) {
3260 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3261 return pchar_descriptor ?
3262 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3263 } else {
3264 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3265 }
3266 } else {
3267 return SWIG_Py_Void();
3268 }
3269 }
3270
3271
3272 SWIGINTERNINLINE PyObject *
3273 SWIG_From_char (char c)
3274 {
3275 return SWIG_FromCharPtrAndSize(&c,1);
3276 }
3277
3278
3279 SWIGINTERNINLINE PyObject*
3280 SWIG_From_unsigned_SS_long (unsigned long value)
3281 {
3282 return (value > LONG_MAX) ?
3283 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3284 }
3285
3286
3287 SWIGINTERNINLINE PyObject *
3288 SWIG_From_size_t (size_t value)
3289 {
3290 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3291 }
3292
3293
3294 SWIGINTERN int
3295 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3296 {
3297 if (PyString_Check(obj)) {
3298 char *cstr; Py_ssize_t len;
3299 PyString_AsStringAndSize(obj, &cstr, &len);
3300 if (cptr) {
3301 if (alloc) {
3302 /*
3303 In python the user should not be able to modify the inner
3304 string representation. To warranty that, if you define
3305 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3306 buffer is always returned.
3307
3308 The default behavior is just to return the pointer value,
3309 so, be careful.
3310 */
3311 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3312 if (*alloc != SWIG_OLDOBJ)
3313 #else
3314 if (*alloc == SWIG_NEWOBJ)
3315 #endif
3316 {
3317 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3318 *alloc = SWIG_NEWOBJ;
3319 }
3320 else {
3321 *cptr = cstr;
3322 *alloc = SWIG_OLDOBJ;
3323 }
3324 } else {
3325 *cptr = PyString_AsString(obj);
3326 }
3327 }
3328 if (psize) *psize = len + 1;
3329 return SWIG_OK;
3330 } else {
3331 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3332 if (pchar_descriptor) {
3333 void* vptr = 0;
3334 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3335 if (cptr) *cptr = (char *) vptr;
3336 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3337 if (alloc) *alloc = SWIG_OLDOBJ;
3338 return SWIG_OK;
3339 }
3340 }
3341 }
3342 return SWIG_TypeError;
3343 }
3344
3345
3346 SWIGINTERN int
3347 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3348 {
3349 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3350 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3351 if (SWIG_IsOK(res)) {
3352 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3353 if (csize <= size) {
3354 if (val) {
3355 if (csize) memcpy(val, cptr, csize*sizeof(char));
3356 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3357 }
3358 if (alloc == SWIG_NEWOBJ) {
3359 delete[] cptr;
3360 res = SWIG_DelNewMask(res);
3361 }
3362 return res;
3363 }
3364 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3365 }
3366 return SWIG_TypeError;
3367 }
3368
3369
3370 SWIGINTERN int
3371 SWIG_AsVal_char (PyObject * obj, char *val)
3372 {
3373 int res = SWIG_AsCharArray(obj, val, 1);
3374 if (!SWIG_IsOK(res)) {
3375 long v;
3376 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3377 if (SWIG_IsOK(res)) {
3378 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3379 if (val) *val = static_cast< char >(v);
3380 } else {
3381 res = SWIG_OverflowError;
3382 }
3383 }
3384 }
3385 return res;
3386 }
3387
3388 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3389 // We use only strings for the streams, not unicode
3390 PyObject* str = PyObject_Str(obj);
3391 if (! str) {
3392 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3393 return;
3394 }
3395 self->Write(PyString_AS_STRING(str),
3396 PyString_GET_SIZE(str));
3397 Py_DECREF(str);
3398 }
3399
3400 #include "wx/wxPython/pyistream.h"
3401
3402
3403 class wxPyFileSystemHandler : public wxFileSystemHandler
3404 {
3405 public:
3406 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3407
3408 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3409 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3410 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3411 DEC_PYCALLBACK_STRING__pure(FindNext);
3412
3413 wxString GetProtocol(const wxString& location) {
3414 return wxFileSystemHandler::GetProtocol(location);
3415 }
3416
3417 wxString GetLeftLocation(const wxString& location) {
3418 return wxFileSystemHandler::GetLeftLocation(location);
3419 }
3420
3421 wxString GetAnchor(const wxString& location) {
3422 return wxFileSystemHandler::GetAnchor(location);
3423 }
3424
3425 wxString GetRightLocation(const wxString& location) {
3426 return wxFileSystemHandler::GetRightLocation(location);
3427 }
3428
3429 wxString GetMimeTypeFromExt(const wxString& location) {
3430 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3431 }
3432
3433 PYPRIVATE;
3434 };
3435
3436
3437 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3438 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3439 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3440 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3441
3442
3443 SWIGINTERN int
3444 SWIG_AsVal_bool (PyObject *obj, bool *val)
3445 {
3446 if (obj == Py_True) {
3447 if (val) *val = true;
3448 return SWIG_OK;
3449 } else if (obj == Py_False) {
3450 if (val) *val = false;
3451 return SWIG_OK;
3452 } else {
3453 long v = 0;
3454 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3455 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3456 return res;
3457 }
3458 }
3459
3460 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3461 wxFileName fname = wxFileSystem::URLToFileName(url);
3462 return fname.GetFullPath();
3463 }
3464
3465 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3466 wxImage& image,
3467 long type) {
3468 wxMemoryFSHandler::AddFile(filename, image, type);
3469 }
3470
3471 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3472 const wxBitmap& bitmap,
3473 long type) {
3474 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3475 }
3476
3477 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3478 PyObject* data) {
3479 if (! PyString_Check(data)) {
3480 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3481 "Expected string object"));
3482 return;
3483 }
3484
3485 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3486 void* ptr = (void*)PyString_AsString(data);
3487 size_t size = PyString_Size(data);
3488 wxPyEndBlockThreads(blocked);
3489
3490 wxMemoryFSHandler::AddFile(filename, ptr, size);
3491 }
3492
3493
3494 #include "wx/wxPython/pyistream.h"
3495
3496
3497 SWIGINTERN int
3498 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3499 {
3500 long v = 0;
3501 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3502 return SWIG_TypeError;
3503 }
3504 else if (val)
3505 *val = (unsigned long)v;
3506 return SWIG_OK;
3507 }
3508
3509
3510 SWIGINTERN int
3511 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3512 {
3513 unsigned long v;
3514 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3515 if (SWIG_IsOK(res)) {
3516 if ((v > UCHAR_MAX)) {
3517 return SWIG_OverflowError;
3518 } else {
3519 if (val) *val = static_cast< unsigned char >(v);
3520 }
3521 }
3522 return res;
3523 }
3524
3525
3526 SWIGINTERNINLINE PyObject *
3527 SWIG_From_unsigned_SS_char (unsigned char value)
3528 {
3529 return SWIG_From_unsigned_SS_long (value);
3530 }
3531
3532 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3533 wxImageHistogramEntry e = (*self)[key];
3534 return e.value;
3535 }
3536 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3537 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3538 wxImageHistogramEntry e = (*self)[key];
3539 return e.value;
3540 }
3541 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3542 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3543 colour.Green(),
3544 colour.Blue());
3545 wxImageHistogramEntry e = (*self)[key];
3546 return e.value;
3547 }
3548
3549 // Pull the nested class out to the top level for SWIG's sake
3550 #define wxImage_RGBValue wxImage::RGBValue
3551 #define wxImage_HSVValue wxImage::HSVValue
3552
3553 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3554 if (width > 0 && height > 0)
3555 return new wxImage(width, height, clear);
3556 else
3557 return new wxImage;
3558 }
3559 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3560 return new wxImage(bitmap.ConvertToImage());
3561 }
3562 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3563 if (DATASIZE != width*height*3) {
3564 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3565 return NULL;
3566 }
3567
3568 // Copy the source data so the wxImage can clean it up later
3569 buffer copy = (buffer)malloc(DATASIZE);
3570 if (copy == NULL) {
3571 wxPyBLOCK_THREADS(PyErr_NoMemory());
3572 return NULL;
3573 }
3574 memcpy(copy, data, DATASIZE);
3575 return new wxImage(width, height, copy, false);
3576 }
3577 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3578 if (DATASIZE != width*height*3) {
3579 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3580 return NULL;
3581 }
3582 if (ALPHASIZE != width*height) {
3583 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3584 return NULL;
3585 }
3586
3587 // Copy the source data so the wxImage can clean it up later
3588 buffer dcopy = (buffer)malloc(DATASIZE);
3589 if (dcopy == NULL) {
3590 wxPyBLOCK_THREADS(PyErr_NoMemory());
3591 return NULL;
3592 }
3593 memcpy(dcopy, data, DATASIZE);
3594
3595 buffer acopy = (buffer)malloc(ALPHASIZE);
3596 if (acopy == NULL) {
3597 wxPyBLOCK_THREADS(PyErr_NoMemory());
3598 return NULL;
3599 }
3600 memcpy(acopy, alpha, ALPHASIZE);
3601
3602 return new wxImage(width, height, dcopy, acopy, false);
3603 }
3604 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3605 wxSize size(self->GetWidth(), self->GetHeight());
3606 return size;
3607 }
3608 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3609 buffer data = self->GetData();
3610 int len = self->GetWidth() * self->GetHeight() * 3;
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3616 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3618 return;
3619 }
3620 buffer copy = (buffer)malloc(DATASIZE);
3621 if (copy == NULL) {
3622 wxPyBLOCK_THREADS(PyErr_NoMemory());
3623 return;
3624 }
3625 memcpy(copy, data, DATASIZE);
3626 self->SetData(copy, false);
3627 // wxImage takes ownership of copy...
3628 }
3629 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3630 buffer data = self->GetData();
3631 int len = self->GetWidth() * self->GetHeight() * 3;
3632 PyObject* rv;
3633 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3634 return rv;
3635 }
3636 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3637 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3638 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3639 return;
3640 }
3641 self->SetData(data, true);
3642 }
3643 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3644 buffer data = self->GetAlpha();
3645 if (! data) {
3646 RETURN_NONE();
3647 } else {
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3651 return rv;
3652 }
3653 }
3654 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3655 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3656 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3657 return;
3658 }
3659 buffer acopy = (buffer)malloc(ALPHASIZE);
3660 if (acopy == NULL) {
3661 wxPyBLOCK_THREADS(PyErr_NoMemory());
3662 return;
3663 }
3664 memcpy(acopy, alpha, ALPHASIZE);
3665 self->SetAlpha(acopy, false);
3666 // wxImage takes ownership of acopy...
3667 }
3668 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3669 buffer data = self->GetAlpha();
3670 int len = self->GetWidth() * self->GetHeight();
3671 PyObject* rv;
3672 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3673 return rv;
3674 }
3675 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3676 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3677 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3678 return;
3679 }
3680 self->SetAlpha(alpha, true);
3681 }
3682 SWIGINTERN PyObject *wxImage_GetHandlers(){
3683 wxList& list = wxImage::GetHandlers();
3684 return wxPy_ConvertList(&list);
3685 }
3686 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3687 wxBitmap bitmap(*self, depth);
3688 return bitmap;
3689 }
3690 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3691 wxImage mono = self->ConvertToMono( red, green, blue );
3692 wxBitmap bitmap( mono, 1 );
3693 return bitmap;
3694 }
3695
3696 wxImage* _ImageFromBuffer(int width, int height,
3697 buffer data, int DATASIZE,
3698 buffer alpha=NULL, int ALPHASIZE=0)
3699 {
3700 if (DATASIZE != width*height*3) {
3701 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3702 return NULL;
3703 }
3704 if (alpha != NULL) {
3705 if (ALPHASIZE != width*height) {
3706 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3707 return NULL;
3708 }
3709 return new wxImage(width, height, data, alpha, true);
3710 }
3711 return new wxImage(width, height, data, true);
3712 }
3713
3714 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3715 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3716 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3717 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3718 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3719 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3720 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3721 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3722 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3723 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3724 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3725 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3726 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3727 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3728 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3729
3730 #include <wx/imagtga.h>
3731
3732
3733 #include <wx/quantize.h>
3734
3735 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3736 return wxQuantize::Quantize(src, dest,
3737 //NULL, // palette
3738 desiredNoColours,
3739 NULL, // eightBitData
3740 flags);
3741 }
3742 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3743 if (PyCallable_Check(func)) {
3744 self->Connect(id, lastId, eventType,
3745 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3746 new wxPyCallback(func));
3747 }
3748 else if (func == Py_None) {
3749 self->Disconnect(id, lastId, eventType,
3750 (wxObjectEventFunction)
3751 &wxPyCallback::EventThunker);
3752 }
3753 else {
3754 wxPyBLOCK_THREADS(
3755 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3756 }
3757 }
3758 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3759 return self->Disconnect(id, lastId, eventType,
3760 (wxObjectEventFunction)
3761 &wxPyCallback::EventThunker);
3762 }
3763 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3764 if (_self && _self != Py_None) {
3765 self->SetClientObject(new wxPyOORClientData(_self, incref));
3766 }
3767 else {
3768 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3769 if (data) {
3770 self->SetClientObject(NULL); // This will delete it too
3771 }
3772 }
3773 }
3774
3775 #if ! wxUSE_HOTKEY
3776 #define wxEVT_HOTKEY -9999
3777 #endif
3778
3779 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3780 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3781 if (data) {
3782 Py_INCREF(data->m_obj);
3783 return data->m_obj;
3784 } else {
3785 Py_INCREF(Py_None);
3786 return Py_None;
3787 }
3788 }
3789 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3790 wxPyClientData* data = new wxPyClientData(clientData);
3791 self->SetClientObject(data);
3792 }
3793 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3794 #if wxUSE_UNICODE
3795 return self->GetUnicodeKey();
3796 #else
3797 return 0;
3798 #endif
3799 }
3800 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3801 #if wxUSE_UNICODE
3802 self->m_uniChar = uniChar;
3803 #endif
3804 }
3805
3806 SWIGINTERNINLINE PyObject *
3807 SWIG_From_unsigned_SS_int (unsigned int value)
3808 {
3809 return SWIG_From_unsigned_SS_long (value);
3810 }
3811
3812
3813 SWIGINTERN int
3814 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3815 {
3816 unsigned long v;
3817 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3818 if (SWIG_IsOK(res)) {
3819 if ((v > UINT_MAX)) {
3820 return SWIG_OverflowError;
3821 } else {
3822 if (val) *val = static_cast< unsigned int >(v);
3823 }
3824 }
3825 return res;
3826 }
3827
3828 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3829 self->m_size = size;
3830 }
3831 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3832 int count = self->GetNumberOfFiles();
3833 wxString* files = self->GetFiles();
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 PyObject* list = PyList_New(count);
3836
3837 if (!list) {
3838 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3839 wxPyEndBlockThreads(blocked);
3840 return NULL;
3841 }
3842
3843 for (int i=0; i<count; i++) {
3844 PyList_SetItem(list, i, wx2PyString(files[i]));
3845 }
3846 wxPyEndBlockThreads(blocked);
3847 return list;
3848 }
3849
3850
3851 SWIGINTERN wxPyApp *new_wxPyApp(){
3852 wxPythonApp = new wxPyApp();
3853 return wxPythonApp;
3854 }
3855 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3856 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3857 return wxPyTestDisplayAvailable();
3858 }
3859
3860 void wxApp_CleanUp() {
3861 __wxPyCleanup();
3862 }
3863
3864
3865 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3866
3867
3868
3869
3870
3871 SWIGINTERNINLINE PyObject *
3872 SWIG_FromCharPtr(const char *cptr)
3873 {
3874 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3875 }
3876
3877
3878 #if 0 // #ifdef __WXMAC__
3879
3880 // A dummy class that raises an exception if used...
3881 class wxEventLoop
3882 {
3883 public:
3884 wxEventLoop() { wxPyRaiseNotImplemented(); }
3885 int Run() { return 0; }
3886 void Exit(int rc = 0) {}
3887 bool Pending() const { return false; }
3888 bool Dispatch() { return false; }
3889 bool IsRunning() const { return false; }
3890 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3891 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3892 };
3893
3894 #else
3895
3896 #include <wx/evtloop.h>
3897
3898 #endif
3899
3900
3901
3902 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3903 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3904 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3905 SWIGINTERN wxFont wxVisualAttributes__get_font(wxVisualAttributes *self){ return self->font; }
3906 SWIGINTERN wxColour wxVisualAttributes__get_colFg(wxVisualAttributes *self){ return self->colFg; }
3907 SWIGINTERN wxColour wxVisualAttributes__get_colBg(wxVisualAttributes *self){ return self->colBg; }
3908 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3909 wxWindowList& list = self->GetChildren();
3910 return wxPy_ConvertList(&list);
3911 }
3912 SWIGINTERN wxWindow *wxWindow_GetTopLevelParent(wxWindow *self){
3913 return wxGetTopLevelParent(self);
3914 }
3915 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3916 #if wxUSE_HOTKEY
3917 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3918 #else
3919 return false;
3920 #endif
3921 }
3922 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3923
3924
3925
3926 return false;
3927
3928 }
3929 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3930 return wxPyGetWinHandle(self);
3931 }
3932 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3933 self->AssociateHandle((WXWidget)handle);
3934 }
3935 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3936
3937 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3938 return wxWindow::FindWindowById(id, parent);
3939 }
3940
3941 wxWindow* wxFindWindowByName( const wxString& name,
3942 const wxWindow *parent = NULL ) {
3943 return wxWindow::FindWindowByName(name, parent);
3944 }
3945
3946 wxWindow* wxFindWindowByLabel( const wxString& label,
3947 const wxWindow *parent = NULL ) {
3948 return wxWindow::FindWindowByLabel(label, parent);
3949 }
3950
3951
3952 #ifdef __WXMSW__
3953 #include <wx/msw/private.h> // to get wxGetWindowId
3954 #endif
3955
3956
3957 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3958 #ifdef __WXMSW__
3959 WXHWND hWnd = (WXHWND)_hWnd;
3960 long id = wxGetWindowId(hWnd);
3961 wxWindow* win = new wxWindow;
3962 if (parent)
3963 parent->AddChild(win);
3964 win->SetEventHandler(win);
3965 win->SetHWND(hWnd);
3966 win->SetId(id);
3967 win->SubclassWin(hWnd);
3968 win->AdoptAttributesFromHWND();
3969 win->SetupColours();
3970 return win;
3971 #else
3972 wxPyRaiseNotImplemented();
3973 return NULL;
3974 #endif
3975 }
3976
3977
3978 PyObject* GetTopLevelWindows() {
3979 return wxPy_ConvertList(&wxTopLevelWindows);
3980 }
3981
3982
3983 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3984 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3985 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3986
3987 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3988
3989
3990 SWIGINTERNINLINE int
3991 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3992 {
3993 unsigned long v;
3994 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3995 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3996 return res;
3997 }
3998
3999 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
4000 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
4001 wxMenuItemList& list = self->GetMenuItems();
4002 return wxPy_ConvertList(&list);
4003 }
4004 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
4005 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
4006 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
4007 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
4008 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
4009 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
4010 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
4011 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
4012 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
4013 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
4014 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
4015 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
4016 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
4017 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
4018 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
4019 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
4020 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
4021 static const wxString wxPyControlNameStr(wxControlNameStr);
4022 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
4023 if (clientData) {
4024 wxPyClientData* data = new wxPyClientData(clientData);
4025 return self->Append(item, data);
4026 } else
4027 return self->Append(item);
4028 }
4029 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4030 if (clientData) {
4031 wxPyClientData* data = new wxPyClientData(clientData);
4032 return self->Insert(item, pos, data);
4033 } else
4034 return self->Insert(item, pos);
4035 }
4036 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4037 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4038 if (data) {
4039 Py_INCREF(data->m_obj);
4040 return data->m_obj;
4041 } else {
4042 Py_INCREF(Py_None);
4043 return Py_None;
4044 }
4045 }
4046 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4047 wxPyClientData* data = new wxPyClientData(clientData);
4048 self->SetClientObject(n, data);
4049 }
4050
4051
4052 SWIGINTERN wxSizerFlags &wxSizerFlags_Border(wxSizerFlags *self,int direction=wxALL,int borderInPixels=-1){
4053 if (borderInPixels == -1)
4054 return self->Border(direction);
4055 else
4056 return self->Border(direction, borderInPixels);
4057 }
4058 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4059 wxPyUserData* data = NULL;
4060 if ( userData ) {
4061 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4062 data = new wxPyUserData(userData);
4063 wxPyEndBlockThreads(blocked);
4064 }
4065 return new wxSizerItem(window, proportion, flag, border, data);
4066 }
4067 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4068 wxPyUserData* data = NULL;
4069 if ( userData ) {
4070 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4071 data = new wxPyUserData(userData);
4072 wxPyEndBlockThreads(blocked);
4073 }
4074 return new wxSizerItem(width, height, proportion, flag, border, data);
4075 }
4076 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4077 wxPyUserData* data = NULL;
4078 if ( userData ) {
4079 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4080 data = new wxPyUserData(userData);
4081 wxPyEndBlockThreads(blocked);
4082 }
4083 return new wxSizerItem(sizer, proportion, flag, border, data);
4084 }
4085
4086 SWIGINTERNINLINE PyObject *
4087 SWIG_From_float (float value)
4088 {
4089 return SWIG_From_double (value);
4090 }
4091
4092 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4093 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4094 if (data) {
4095 Py_INCREF(data->m_obj);
4096 return data->m_obj;
4097 } else {
4098 Py_INCREF(Py_None);
4099 return Py_None;
4100 }
4101 }
4102 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4103 wxPyUserData* data = NULL;
4104 if ( userData ) {
4105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4106 data = new wxPyUserData(userData);
4107 wxPyEndBlockThreads(blocked);
4108 }
4109 self->SetUserData(data);
4110 }
4111
4112 // Figure out the type of the sizer item
4113
4114 struct wxPySizerItemInfo {
4115 wxPySizerItemInfo()
4116 : window(NULL), sizer(NULL), gotSize(false),
4117 size(wxDefaultSize), gotPos(false), pos(-1)
4118 {}
4119
4120 wxWindow* window;
4121 wxSizer* sizer;
4122 bool gotSize;
4123 wxSize size;
4124 bool gotPos;
4125 int pos;
4126 };
4127
4128 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4129
4130 wxPySizerItemInfo info;
4131 wxSize size;
4132 wxSize* sizePtr = &size;
4133
4134 // Find out what the type of the item is
4135 // try wxWindow
4136 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4137 PyErr_Clear();
4138 info.window = NULL;
4139
4140 // try wxSizer
4141 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4142 PyErr_Clear();
4143 info.sizer = NULL;
4144
4145 // try wxSize or (w,h)
4146 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4147 info.size = *sizePtr;
4148 info.gotSize = true;
4149 }
4150
4151 // or a single int
4152 if (checkIdx && PyInt_Check(item)) {
4153 info.pos = PyInt_AsLong(item);
4154 info.gotPos = true;
4155 }
4156 }
4157 }
4158
4159 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4160 // no expected type, figure out what kind of error message to generate
4161 if ( !checkSize && !checkIdx )
4162 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4163 else if ( checkSize && !checkIdx )
4164 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4165 else if ( !checkSize && checkIdx)
4166 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4167 else
4168 // can this one happen?
4169 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4170 }
4171
4172 return info;
4173 }
4174
4175 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4176 if (!self->GetClientObject())
4177 self->SetClientObject(new wxPyOORClientData(_self));
4178 }
4179 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4180
4181 wxPyUserData* data = NULL;
4182 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4183 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4184 if ( userData && (info.window || info.sizer || info.gotSize) )
4185 data = new wxPyUserData(userData);
4186 if ( info.sizer )
4187 PyObject_SetAttrString(item,"thisown",Py_False);
4188 wxPyEndBlockThreads(blocked);
4189
4190 // Now call the real Add method if a valid item type was found
4191 if ( info.window )
4192 return self->Add(info.window, proportion, flag, border, data);
4193 else if ( info.sizer )
4194 return self->Add(info.sizer, proportion, flag, border, data);
4195 else if (info.gotSize)
4196 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4197 proportion, flag, border, data);
4198 else
4199 return NULL;
4200 }
4201 SWIGINTERN wxSizerItem *wxSizer_AddF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4202
4203 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4204 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4205 if ( info.sizer )
4206 PyObject_SetAttrString(item,"thisown",Py_False);
4207 wxPyEndBlockThreads(blocked);
4208
4209 // Now call the real Add method if a valid item type was found
4210 if ( info.window )
4211 return self->Add(info.window, flags);
4212 else if ( info.sizer )
4213 return self->Add(info.sizer, flags);
4214 else if (info.gotSize)
4215 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4216 flags.GetProportion(),
4217 flags.GetFlags(),
4218 flags.GetBorderInPixels());
4219 else
4220 return NULL;
4221 }
4222 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4223
4224 wxPyUserData* data = NULL;
4225 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4226 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4227 if ( userData && (info.window || info.sizer || info.gotSize) )
4228 data = new wxPyUserData(userData);
4229 if ( info.sizer )
4230 PyObject_SetAttrString(item,"thisown",Py_False);
4231 wxPyEndBlockThreads(blocked);
4232
4233 // Now call the real Insert method if a valid item type was found
4234 if ( info.window )
4235 return self->Insert(before, info.window, proportion, flag, border, data);
4236 else if ( info.sizer )
4237 return self->Insert(before, info.sizer, proportion, flag, border, data);
4238 else if (info.gotSize)
4239 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4240 proportion, flag, border, data);
4241 else
4242 return NULL;
4243 }
4244 SWIGINTERN wxSizerItem *wxSizer_InsertF(wxSizer *self,int before,PyObject *item,wxSizerFlags &flags){
4245
4246 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4247 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4248 if ( info.sizer )
4249 PyObject_SetAttrString(item,"thisown",Py_False);
4250 wxPyEndBlockThreads(blocked);
4251
4252 // Now call the real Insert method if a valid item type was found
4253 if ( info.window )
4254 return self->Insert(before, info.window, flags);
4255 else if ( info.sizer )
4256 return self->Insert(before, info.sizer, flags);
4257 else if (info.gotSize)
4258 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4259 flags.GetProportion(),
4260 flags.GetFlags(),
4261 flags.GetBorderInPixels());
4262 else
4263 return NULL;
4264 }
4265 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4266
4267 wxPyUserData* data = NULL;
4268 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4269 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4270 if ( userData && (info.window || info.sizer || info.gotSize) )
4271 data = new wxPyUserData(userData);
4272 if ( info.sizer )
4273 PyObject_SetAttrString(item,"thisown",Py_False);
4274 wxPyEndBlockThreads(blocked);
4275
4276 // Now call the real Prepend method if a valid item type was found
4277 if ( info.window )
4278 return self->Prepend(info.window, proportion, flag, border, data);
4279 else if ( info.sizer )
4280 return self->Prepend(info.sizer, proportion, flag, border, data);
4281 else if (info.gotSize)
4282 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4283 proportion, flag, border, data);
4284 else
4285 return NULL;
4286 }
4287 SWIGINTERN wxSizerItem *wxSizer_PrependF(wxSizer *self,PyObject *item,wxSizerFlags &flags){
4288
4289 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4290 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4291 if ( info.sizer )
4292 PyObject_SetAttrString(item,"thisown",Py_False);
4293 wxPyEndBlockThreads(blocked);
4294
4295 // Now call the real Add method if a valid item type was found
4296 if ( info.window )
4297 return self->Prepend(info.window, flags);
4298 else if ( info.sizer )
4299 return self->Prepend(info.sizer, flags);
4300 else if (info.gotSize)
4301 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4302 flags.GetProportion(),
4303 flags.GetFlags(),
4304 flags.GetBorderInPixels());
4305 else
4306 return NULL;
4307 }
4308 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4309 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4310 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4311 wxPyEndBlockThreads(blocked);
4312 if ( info.window )
4313 return false; //self->Remove(info.window);
4314 else if ( info.sizer )
4315 return self->Remove(info.sizer);
4316 else if ( info.gotPos )
4317 return self->Remove(info.pos);
4318 else
4319 return false;
4320 }
4321 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4322 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4323 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4324 wxPyEndBlockThreads(blocked);
4325 if ( info.window )
4326 return self->Detach(info.window);
4327 else if ( info.sizer )
4328 return self->Detach(info.sizer);
4329 else if ( info.gotPos )
4330 return self->Detach(info.pos);
4331 else
4332 return false;
4333 }
4334 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item,bool recursive=false){
4335 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4336 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4337 wxPyEndBlockThreads(blocked);
4338 if ( info.window )
4339 return self->GetItem(info.window, recursive);
4340 else if ( info.sizer )
4341 return self->GetItem(info.sizer, recursive);
4342 else if ( info.gotPos )
4343 return self->GetItem(info.pos);
4344 else
4345 return NULL;
4346 }
4347 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4348 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4349 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4350 wxPyEndBlockThreads(blocked);
4351 if ( info.window )
4352 self->SetItemMinSize(info.window, size);
4353 else if ( info.sizer )
4354 self->SetItemMinSize(info.sizer, size);
4355 else if ( info.gotPos )
4356 self->SetItemMinSize(info.pos, size);
4357 }
4358 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4359 wxSizerItemList& list = self->GetChildren();
4360 return wxPy_ConvertList(&list);
4361 }
4362 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4363 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4364 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4365 wxPyEndBlockThreads(blocked);
4366 if ( info.window )
4367 return self->Show(info.window, show, recursive);
4368 else if ( info.sizer )
4369 return self->Show(info.sizer, show, recursive);
4370 else if ( info.gotPos )
4371 return self->Show(info.pos, show);
4372 else
4373 return false;
4374 }
4375 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4376 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4377 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4378 wxPyEndBlockThreads(blocked);
4379 if ( info.window )
4380 return self->IsShown(info.window);
4381 else if ( info.sizer )
4382 return self->IsShown(info.sizer);
4383 else if ( info.gotPos )
4384 return self->IsShown(info.pos);
4385 else
4386 return false;
4387 }
4388
4389 // See pyclasses.h
4390 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4391 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4392 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4393
4394
4395
4396
4397 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4398 {
4399 if (source == Py_None) {
4400 **obj = wxGBPosition(-1,-1);
4401 return true;
4402 }
4403 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4404 }
4405
4406 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4407 {
4408 if (source == Py_None) {
4409 **obj = wxGBSpan(-1,-1);
4410 return true;
4411 }
4412 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4413 }
4414
4415
4416 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4417 wxGBPosition temp, *obj = &temp;
4418 if ( other == Py_None ) return false;
4419 if ( ! wxGBPosition_helper(other, &obj) ) {
4420 PyErr_Clear();
4421 return false;
4422 }
4423 return self->operator==(*obj);
4424 }
4425 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4426 wxGBPosition temp, *obj = &temp;
4427 if ( other == Py_None ) return true;
4428 if ( ! wxGBPosition_helper(other, &obj)) {
4429 PyErr_Clear();
4430 return true;
4431 }
4432 return self->operator!=(*obj);
4433 }
4434 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4435 self->SetRow(row);
4436 self->SetCol(col);
4437 }
4438 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4439 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4440 PyObject* tup = PyTuple_New(2);
4441 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4442 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4443 wxPyEndBlockThreads(blocked);
4444 return tup;
4445 }
4446 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4447 wxGBSpan temp, *obj = &temp;
4448 if ( other == Py_None ) return false;
4449 if ( ! wxGBSpan_helper(other, &obj) ) {
4450 PyErr_Clear();
4451 return false;
4452 }
4453 return self->operator==(*obj);
4454 }
4455 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4456 wxGBSpan temp, *obj = &temp;
4457 if ( other == Py_None ) return true;
4458 if ( ! wxGBSpan_helper(other, &obj)) {
4459 PyErr_Clear();
4460 return true;
4461 }
4462 return self->operator!=(*obj);
4463 }
4464 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4465 self->SetRowspan(rowspan);
4466 self->SetColspan(colspan);
4467 }
4468 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4469 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4470 PyObject* tup = PyTuple_New(2);
4471 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4472 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4473 wxPyEndBlockThreads(blocked);
4474 return tup;
4475 }
4476 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4477 wxPyUserData* data = NULL;
4478 if ( userData ) {
4479 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4480 data = new wxPyUserData(userData);
4481 wxPyEndBlockThreads(blocked);
4482 }
4483 return new wxGBSizerItem(window, pos, span, flag, border, data);
4484 }
4485 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4486 wxPyUserData* data = NULL;
4487 if ( userData ) {
4488 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4489 data = new wxPyUserData(userData);
4490 wxPyEndBlockThreads(blocked);
4491 }
4492 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4493 }
4494 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4495 wxPyUserData* data = NULL;
4496 if ( userData ) {
4497 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4498 data = new wxPyUserData(userData);
4499 wxPyEndBlockThreads(blocked);
4500 }
4501 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4502 }
4503 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4504 int row, col;
4505 self->GetEndPos(row, col);
4506 return wxGBPosition(row, col);
4507 }
4508 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4509
4510 wxPyUserData* data = NULL;
4511 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4512 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4513 if ( userData && (info.window || info.sizer || info.gotSize) )
4514 data = new wxPyUserData(userData);
4515 if ( info.sizer )
4516 PyObject_SetAttrString(item,"thisown",Py_False);
4517 wxPyEndBlockThreads(blocked);
4518
4519 // Now call the real Add method if a valid item type was found
4520 if ( info.window )
4521 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4522 else if ( info.sizer )
4523 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4524 else if (info.gotSize)
4525 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4526 pos, span, flag, border, data);
4527 return NULL;
4528 }
4529
4530
4531 #ifdef __cplusplus
4532 extern "C" {
4533 #endif
4534 SWIGINTERN int EmptyString_set(PyObject *) {
4535 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4536 return 1;
4537 }
4538
4539
4540 SWIGINTERN PyObject *EmptyString_get(void) {
4541 PyObject *pyobj = 0;
4542
4543 {
4544 #if wxUSE_UNICODE
4545 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4546 #else
4547 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4548 #endif
4549 }
4550 return pyobj;
4551 }
4552
4553
4554 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4555 PyObject *resultobj = 0;
4556 wxObject *arg1 = (wxObject *) 0 ;
4557 wxString result;
4558 void *argp1 = 0 ;
4559 int res1 = 0 ;
4560 PyObject *swig_obj[1] ;
4561
4562 if (!args) SWIG_fail;
4563 swig_obj[0] = args;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4567 }
4568 arg1 = reinterpret_cast< wxObject * >(argp1);
4569 {
4570 PyThreadState* __tstate = wxPyBeginAllowThreads();
4571 result = wxObject_GetClassName(arg1);
4572 wxPyEndAllowThreads(__tstate);
4573 if (PyErr_Occurred()) SWIG_fail;
4574 }
4575 {
4576 #if wxUSE_UNICODE
4577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4578 #else
4579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4580 #endif
4581 }
4582 return resultobj;
4583 fail:
4584 return NULL;
4585 }
4586
4587
4588 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4589 PyObject *resultobj = 0;
4590 wxObject *arg1 = (wxObject *) 0 ;
4591 void *argp1 = 0 ;
4592 int res1 = 0 ;
4593 PyObject *swig_obj[1] ;
4594
4595 if (!args) SWIG_fail;
4596 swig_obj[0] = args;
4597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4598 if (!SWIG_IsOK(res1)) {
4599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4600 }
4601 arg1 = reinterpret_cast< wxObject * >(argp1);
4602 {
4603 PyThreadState* __tstate = wxPyBeginAllowThreads();
4604 wxObject_Destroy(arg1);
4605 wxPyEndAllowThreads(__tstate);
4606 if (PyErr_Occurred()) SWIG_fail;
4607 }
4608 resultobj = SWIG_Py_Void();
4609 return resultobj;
4610 fail:
4611 return NULL;
4612 }
4613
4614
4615 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4616 PyObject *resultobj = 0;
4617 wxObject *arg1 = (wxObject *) 0 ;
4618 wxObject *arg2 = 0 ;
4619 bool result;
4620 void *argp1 = 0 ;
4621 int res1 = 0 ;
4622 void *argp2 = 0 ;
4623 int res2 = 0 ;
4624 PyObject * obj0 = 0 ;
4625 PyObject * obj1 = 0 ;
4626 char * kwnames[] = {
4627 (char *) "self",(char *) "p", NULL
4628 };
4629
4630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4632 if (!SWIG_IsOK(res1)) {
4633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4634 }
4635 arg1 = reinterpret_cast< wxObject * >(argp1);
4636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4637 if (!SWIG_IsOK(res2)) {
4638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4639 }
4640 if (!argp2) {
4641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4642 }
4643 arg2 = reinterpret_cast< wxObject * >(argp2);
4644 {
4645 PyThreadState* __tstate = wxPyBeginAllowThreads();
4646 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4647 wxPyEndAllowThreads(__tstate);
4648 if (PyErr_Occurred()) SWIG_fail;
4649 }
4650 {
4651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4652 }
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4660 PyObject *obj;
4661 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4662 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4663 return SWIG_Py_Void();
4664 }
4665
4666 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4667 PyObject *resultobj = 0;
4668 wxSize *arg1 = (wxSize *) 0 ;
4669 int arg2 ;
4670 void *argp1 = 0 ;
4671 int res1 = 0 ;
4672 int val2 ;
4673 int ecode2 = 0 ;
4674 PyObject *swig_obj[2] ;
4675
4676 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4678 if (!SWIG_IsOK(res1)) {
4679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4680 }
4681 arg1 = reinterpret_cast< wxSize * >(argp1);
4682 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4683 if (!SWIG_IsOK(ecode2)) {
4684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4685 }
4686 arg2 = static_cast< int >(val2);
4687 if (arg1) (arg1)->x = arg2;
4688
4689 resultobj = SWIG_Py_Void();
4690 return resultobj;
4691 fail:
4692 return NULL;
4693 }
4694
4695
4696 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4697 PyObject *resultobj = 0;
4698 wxSize *arg1 = (wxSize *) 0 ;
4699 int result;
4700 void *argp1 = 0 ;
4701 int res1 = 0 ;
4702 PyObject *swig_obj[1] ;
4703
4704 if (!args) SWIG_fail;
4705 swig_obj[0] = args;
4706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4707 if (!SWIG_IsOK(res1)) {
4708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4709 }
4710 arg1 = reinterpret_cast< wxSize * >(argp1);
4711 result = (int) ((arg1)->x);
4712 resultobj = SWIG_From_int(static_cast< int >(result));
4713 return resultobj;
4714 fail:
4715 return NULL;
4716 }
4717
4718
4719 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4720 PyObject *resultobj = 0;
4721 wxSize *arg1 = (wxSize *) 0 ;
4722 int arg2 ;
4723 void *argp1 = 0 ;
4724 int res1 = 0 ;
4725 int val2 ;
4726 int ecode2 = 0 ;
4727 PyObject *swig_obj[2] ;
4728
4729 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4731 if (!SWIG_IsOK(res1)) {
4732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4733 }
4734 arg1 = reinterpret_cast< wxSize * >(argp1);
4735 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4736 if (!SWIG_IsOK(ecode2)) {
4737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4738 }
4739 arg2 = static_cast< int >(val2);
4740 if (arg1) (arg1)->y = arg2;
4741
4742 resultobj = SWIG_Py_Void();
4743 return resultobj;
4744 fail:
4745 return NULL;
4746 }
4747
4748
4749 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4750 PyObject *resultobj = 0;
4751 wxSize *arg1 = (wxSize *) 0 ;
4752 int result;
4753 void *argp1 = 0 ;
4754 int res1 = 0 ;
4755 PyObject *swig_obj[1] ;
4756
4757 if (!args) SWIG_fail;
4758 swig_obj[0] = args;
4759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4760 if (!SWIG_IsOK(res1)) {
4761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4762 }
4763 arg1 = reinterpret_cast< wxSize * >(argp1);
4764 result = (int) ((arg1)->y);
4765 resultobj = SWIG_From_int(static_cast< int >(result));
4766 return resultobj;
4767 fail:
4768 return NULL;
4769 }
4770
4771
4772 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4773 PyObject *resultobj = 0;
4774 int arg1 = (int) 0 ;
4775 int arg2 = (int) 0 ;
4776 wxSize *result = 0 ;
4777 int val1 ;
4778 int ecode1 = 0 ;
4779 int val2 ;
4780 int ecode2 = 0 ;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 char * kwnames[] = {
4784 (char *) "w",(char *) "h", NULL
4785 };
4786
4787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4788 if (obj0) {
4789 ecode1 = SWIG_AsVal_int(obj0, &val1);
4790 if (!SWIG_IsOK(ecode1)) {
4791 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4792 }
4793 arg1 = static_cast< int >(val1);
4794 }
4795 if (obj1) {
4796 ecode2 = SWIG_AsVal_int(obj1, &val2);
4797 if (!SWIG_IsOK(ecode2)) {
4798 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4799 }
4800 arg2 = static_cast< int >(val2);
4801 }
4802 {
4803 result = (wxSize *)new wxSize(arg1,arg2);
4804 if (PyErr_Occurred()) SWIG_fail;
4805 }
4806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4807 return resultobj;
4808 fail:
4809 return NULL;
4810 }
4811
4812
4813 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4814 PyObject *resultobj = 0;
4815 wxSize *arg1 = (wxSize *) 0 ;
4816 void *argp1 = 0 ;
4817 int res1 = 0 ;
4818 PyObject *swig_obj[1] ;
4819
4820 if (!args) SWIG_fail;
4821 swig_obj[0] = args;
4822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4823 if (!SWIG_IsOK(res1)) {
4824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4825 }
4826 arg1 = reinterpret_cast< wxSize * >(argp1);
4827 {
4828 delete arg1;
4829
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 resultobj = SWIG_Py_Void();
4833 return resultobj;
4834 fail:
4835 return NULL;
4836 }
4837
4838
4839 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4840 PyObject *resultobj = 0;
4841 wxSize *arg1 = (wxSize *) 0 ;
4842 PyObject *arg2 = (PyObject *) 0 ;
4843 bool result;
4844 void *argp1 = 0 ;
4845 int res1 = 0 ;
4846 PyObject * obj0 = 0 ;
4847 PyObject * obj1 = 0 ;
4848 char * kwnames[] = {
4849 (char *) "self",(char *) "other", NULL
4850 };
4851
4852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4854 if (!SWIG_IsOK(res1)) {
4855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4856 }
4857 arg1 = reinterpret_cast< wxSize * >(argp1);
4858 arg2 = obj1;
4859 {
4860 result = (bool)wxSize___eq__(arg1,arg2);
4861 if (PyErr_Occurred()) SWIG_fail;
4862 }
4863 {
4864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4865 }
4866 return resultobj;
4867 fail:
4868 return NULL;
4869 }
4870
4871
4872 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4873 PyObject *resultobj = 0;
4874 wxSize *arg1 = (wxSize *) 0 ;
4875 PyObject *arg2 = (PyObject *) 0 ;
4876 bool result;
4877 void *argp1 = 0 ;
4878 int res1 = 0 ;
4879 PyObject * obj0 = 0 ;
4880 PyObject * obj1 = 0 ;
4881 char * kwnames[] = {
4882 (char *) "self",(char *) "other", NULL
4883 };
4884
4885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4887 if (!SWIG_IsOK(res1)) {
4888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4889 }
4890 arg1 = reinterpret_cast< wxSize * >(argp1);
4891 arg2 = obj1;
4892 {
4893 result = (bool)wxSize___ne__(arg1,arg2);
4894 if (PyErr_Occurred()) SWIG_fail;
4895 }
4896 {
4897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4898 }
4899 return resultobj;
4900 fail:
4901 return NULL;
4902 }
4903
4904
4905 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4906 PyObject *resultobj = 0;
4907 wxSize *arg1 = (wxSize *) 0 ;
4908 wxSize *arg2 = 0 ;
4909 wxSize result;
4910 void *argp1 = 0 ;
4911 int res1 = 0 ;
4912 wxSize temp2 ;
4913 PyObject * obj0 = 0 ;
4914 PyObject * obj1 = 0 ;
4915 char * kwnames[] = {
4916 (char *) "self",(char *) "sz", NULL
4917 };
4918
4919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4921 if (!SWIG_IsOK(res1)) {
4922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4923 }
4924 arg1 = reinterpret_cast< wxSize * >(argp1);
4925 {
4926 arg2 = &temp2;
4927 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4928 }
4929 {
4930 result = (arg1)->operator +((wxSize const &)*arg2);
4931 if (PyErr_Occurred()) SWIG_fail;
4932 }
4933 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4934 return resultobj;
4935 fail:
4936 return NULL;
4937 }
4938
4939
4940 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4941 PyObject *resultobj = 0;
4942 wxSize *arg1 = (wxSize *) 0 ;
4943 wxSize *arg2 = 0 ;
4944 wxSize result;
4945 void *argp1 = 0 ;
4946 int res1 = 0 ;
4947 wxSize temp2 ;
4948 PyObject * obj0 = 0 ;
4949 PyObject * obj1 = 0 ;
4950 char * kwnames[] = {
4951 (char *) "self",(char *) "sz", NULL
4952 };
4953
4954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4956 if (!SWIG_IsOK(res1)) {
4957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4958 }
4959 arg1 = reinterpret_cast< wxSize * >(argp1);
4960 {
4961 arg2 = &temp2;
4962 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4963 }
4964 {
4965 result = (arg1)->operator -((wxSize const &)*arg2);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj = 0;
4977 wxSize *arg1 = (wxSize *) 0 ;
4978 wxSize *arg2 = 0 ;
4979 void *argp1 = 0 ;
4980 int res1 = 0 ;
4981 wxSize temp2 ;
4982 PyObject * obj0 = 0 ;
4983 PyObject * obj1 = 0 ;
4984 char * kwnames[] = {
4985 (char *) "self",(char *) "sz", NULL
4986 };
4987
4988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4990 if (!SWIG_IsOK(res1)) {
4991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4992 }
4993 arg1 = reinterpret_cast< wxSize * >(argp1);
4994 {
4995 arg2 = &temp2;
4996 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4997 }
4998 {
4999 (arg1)->IncTo((wxSize const &)*arg2);
5000 if (PyErr_Occurred()) SWIG_fail;
5001 }
5002 resultobj = SWIG_Py_Void();
5003 return resultobj;
5004 fail:
5005 return NULL;
5006 }
5007
5008
5009 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5010 PyObject *resultobj = 0;
5011 wxSize *arg1 = (wxSize *) 0 ;
5012 wxSize *arg2 = 0 ;
5013 void *argp1 = 0 ;
5014 int res1 = 0 ;
5015 wxSize temp2 ;
5016 PyObject * obj0 = 0 ;
5017 PyObject * obj1 = 0 ;
5018 char * kwnames[] = {
5019 (char *) "self",(char *) "sz", NULL
5020 };
5021
5022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
5023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5024 if (!SWIG_IsOK(res1)) {
5025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
5026 }
5027 arg1 = reinterpret_cast< wxSize * >(argp1);
5028 {
5029 arg2 = &temp2;
5030 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5031 }
5032 {
5033 (arg1)->DecTo((wxSize const &)*arg2);
5034 if (PyErr_Occurred()) SWIG_fail;
5035 }
5036 resultobj = SWIG_Py_Void();
5037 return resultobj;
5038 fail:
5039 return NULL;
5040 }
5041
5042
5043 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj = 0;
5045 wxSize *arg1 = (wxSize *) 0 ;
5046 int arg2 ;
5047 int arg3 ;
5048 void *argp1 = 0 ;
5049 int res1 = 0 ;
5050 int val2 ;
5051 int ecode2 = 0 ;
5052 int val3 ;
5053 int ecode3 = 0 ;
5054 PyObject * obj0 = 0 ;
5055 PyObject * obj1 = 0 ;
5056 PyObject * obj2 = 0 ;
5057 char * kwnames[] = {
5058 (char *) "self",(char *) "dx",(char *) "dy", NULL
5059 };
5060
5061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 ecode2 = SWIG_AsVal_int(obj1, &val2);
5068 if (!SWIG_IsOK(ecode2)) {
5069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
5070 }
5071 arg2 = static_cast< int >(val2);
5072 ecode3 = SWIG_AsVal_int(obj2, &val3);
5073 if (!SWIG_IsOK(ecode3)) {
5074 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
5075 }
5076 arg3 = static_cast< int >(val3);
5077 {
5078 (arg1)->IncBy(arg2,arg3);
5079 if (PyErr_Occurred()) SWIG_fail;
5080 }
5081 resultobj = SWIG_Py_Void();
5082 return resultobj;
5083 fail:
5084 return NULL;
5085 }
5086
5087
5088 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5089 PyObject *resultobj = 0;
5090 wxSize *arg1 = (wxSize *) 0 ;
5091 int arg2 ;
5092 int arg3 ;
5093 void *argp1 = 0 ;
5094 int res1 = 0 ;
5095 int val2 ;
5096 int ecode2 = 0 ;
5097 int val3 ;
5098 int ecode3 = 0 ;
5099 PyObject * obj0 = 0 ;
5100 PyObject * obj1 = 0 ;
5101 PyObject * obj2 = 0 ;
5102 char * kwnames[] = {
5103 (char *) "self",(char *) "dx",(char *) "dy", NULL
5104 };
5105
5106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5108 if (!SWIG_IsOK(res1)) {
5109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5110 }
5111 arg1 = reinterpret_cast< wxSize * >(argp1);
5112 ecode2 = SWIG_AsVal_int(obj1, &val2);
5113 if (!SWIG_IsOK(ecode2)) {
5114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5115 }
5116 arg2 = static_cast< int >(val2);
5117 ecode3 = SWIG_AsVal_int(obj2, &val3);
5118 if (!SWIG_IsOK(ecode3)) {
5119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5120 }
5121 arg3 = static_cast< int >(val3);
5122 {
5123 (arg1)->DecBy(arg2,arg3);
5124 if (PyErr_Occurred()) SWIG_fail;
5125 }
5126 resultobj = SWIG_Py_Void();
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
5133 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5134 PyObject *resultobj = 0;
5135 wxSize *arg1 = (wxSize *) 0 ;
5136 float arg2 ;
5137 float arg3 ;
5138 void *argp1 = 0 ;
5139 int res1 = 0 ;
5140 float val2 ;
5141 int ecode2 = 0 ;
5142 float val3 ;
5143 int ecode3 = 0 ;
5144 PyObject * obj0 = 0 ;
5145 PyObject * obj1 = 0 ;
5146 PyObject * obj2 = 0 ;
5147 char * kwnames[] = {
5148 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5149 };
5150
5151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5153 if (!SWIG_IsOK(res1)) {
5154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5155 }
5156 arg1 = reinterpret_cast< wxSize * >(argp1);
5157 ecode2 = SWIG_AsVal_float(obj1, &val2);
5158 if (!SWIG_IsOK(ecode2)) {
5159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5160 }
5161 arg2 = static_cast< float >(val2);
5162 ecode3 = SWIG_AsVal_float(obj2, &val3);
5163 if (!SWIG_IsOK(ecode3)) {
5164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5165 }
5166 arg3 = static_cast< float >(val3);
5167 {
5168 (arg1)->Scale(arg2,arg3);
5169 if (PyErr_Occurred()) SWIG_fail;
5170 }
5171 resultobj = SWIG_Py_Void();
5172 return resultobj;
5173 fail:
5174 return NULL;
5175 }
5176
5177
5178 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5179 PyObject *resultobj = 0;
5180 wxSize *arg1 = (wxSize *) 0 ;
5181 int arg2 ;
5182 int arg3 ;
5183 void *argp1 = 0 ;
5184 int res1 = 0 ;
5185 int val2 ;
5186 int ecode2 = 0 ;
5187 int val3 ;
5188 int ecode3 = 0 ;
5189 PyObject * obj0 = 0 ;
5190 PyObject * obj1 = 0 ;
5191 PyObject * obj2 = 0 ;
5192 char * kwnames[] = {
5193 (char *) "self",(char *) "w",(char *) "h", NULL
5194 };
5195
5196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5198 if (!SWIG_IsOK(res1)) {
5199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5200 }
5201 arg1 = reinterpret_cast< wxSize * >(argp1);
5202 ecode2 = SWIG_AsVal_int(obj1, &val2);
5203 if (!SWIG_IsOK(ecode2)) {
5204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5205 }
5206 arg2 = static_cast< int >(val2);
5207 ecode3 = SWIG_AsVal_int(obj2, &val3);
5208 if (!SWIG_IsOK(ecode3)) {
5209 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5210 }
5211 arg3 = static_cast< int >(val3);
5212 {
5213 (arg1)->Set(arg2,arg3);
5214 if (PyErr_Occurred()) SWIG_fail;
5215 }
5216 resultobj = SWIG_Py_Void();
5217 return resultobj;
5218 fail:
5219 return NULL;
5220 }
5221
5222
5223 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5224 PyObject *resultobj = 0;
5225 wxSize *arg1 = (wxSize *) 0 ;
5226 int arg2 ;
5227 void *argp1 = 0 ;
5228 int res1 = 0 ;
5229 int val2 ;
5230 int ecode2 = 0 ;
5231 PyObject * obj0 = 0 ;
5232 PyObject * obj1 = 0 ;
5233 char * kwnames[] = {
5234 (char *) "self",(char *) "w", NULL
5235 };
5236
5237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5239 if (!SWIG_IsOK(res1)) {
5240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5241 }
5242 arg1 = reinterpret_cast< wxSize * >(argp1);
5243 ecode2 = SWIG_AsVal_int(obj1, &val2);
5244 if (!SWIG_IsOK(ecode2)) {
5245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5246 }
5247 arg2 = static_cast< int >(val2);
5248 {
5249 (arg1)->SetWidth(arg2);
5250 if (PyErr_Occurred()) SWIG_fail;
5251 }
5252 resultobj = SWIG_Py_Void();
5253 return resultobj;
5254 fail:
5255 return NULL;
5256 }
5257
5258
5259 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5260 PyObject *resultobj = 0;
5261 wxSize *arg1 = (wxSize *) 0 ;
5262 int arg2 ;
5263 void *argp1 = 0 ;
5264 int res1 = 0 ;
5265 int val2 ;
5266 int ecode2 = 0 ;
5267 PyObject * obj0 = 0 ;
5268 PyObject * obj1 = 0 ;
5269 char * kwnames[] = {
5270 (char *) "self",(char *) "h", NULL
5271 };
5272
5273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5277 }
5278 arg1 = reinterpret_cast< wxSize * >(argp1);
5279 ecode2 = SWIG_AsVal_int(obj1, &val2);
5280 if (!SWIG_IsOK(ecode2)) {
5281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5282 }
5283 arg2 = static_cast< int >(val2);
5284 {
5285 (arg1)->SetHeight(arg2);
5286 if (PyErr_Occurred()) SWIG_fail;
5287 }
5288 resultobj = SWIG_Py_Void();
5289 return resultobj;
5290 fail:
5291 return NULL;
5292 }
5293
5294
5295 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5296 PyObject *resultobj = 0;
5297 wxSize *arg1 = (wxSize *) 0 ;
5298 int result;
5299 void *argp1 = 0 ;
5300 int res1 = 0 ;
5301 PyObject *swig_obj[1] ;
5302
5303 if (!args) SWIG_fail;
5304 swig_obj[0] = args;
5305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5306 if (!SWIG_IsOK(res1)) {
5307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5308 }
5309 arg1 = reinterpret_cast< wxSize * >(argp1);
5310 {
5311 result = (int)((wxSize const *)arg1)->GetWidth();
5312 if (PyErr_Occurred()) SWIG_fail;
5313 }
5314 resultobj = SWIG_From_int(static_cast< int >(result));
5315 return resultobj;
5316 fail:
5317 return NULL;
5318 }
5319
5320
5321 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5322 PyObject *resultobj = 0;
5323 wxSize *arg1 = (wxSize *) 0 ;
5324 int result;
5325 void *argp1 = 0 ;
5326 int res1 = 0 ;
5327 PyObject *swig_obj[1] ;
5328
5329 if (!args) SWIG_fail;
5330 swig_obj[0] = args;
5331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5332 if (!SWIG_IsOK(res1)) {
5333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5334 }
5335 arg1 = reinterpret_cast< wxSize * >(argp1);
5336 {
5337 result = (int)((wxSize const *)arg1)->GetHeight();
5338 if (PyErr_Occurred()) SWIG_fail;
5339 }
5340 resultobj = SWIG_From_int(static_cast< int >(result));
5341 return resultobj;
5342 fail:
5343 return NULL;
5344 }
5345
5346
5347 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5348 PyObject *resultobj = 0;
5349 wxSize *arg1 = (wxSize *) 0 ;
5350 bool result;
5351 void *argp1 = 0 ;
5352 int res1 = 0 ;
5353 PyObject *swig_obj[1] ;
5354
5355 if (!args) SWIG_fail;
5356 swig_obj[0] = args;
5357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5358 if (!SWIG_IsOK(res1)) {
5359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5360 }
5361 arg1 = reinterpret_cast< wxSize * >(argp1);
5362 {
5363 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5364 if (PyErr_Occurred()) SWIG_fail;
5365 }
5366 {
5367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5368 }
5369 return resultobj;
5370 fail:
5371 return NULL;
5372 }
5373
5374
5375 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5376 PyObject *resultobj = 0;
5377 wxSize *arg1 = (wxSize *) 0 ;
5378 wxSize *arg2 = 0 ;
5379 void *argp1 = 0 ;
5380 int res1 = 0 ;
5381 wxSize temp2 ;
5382 PyObject * obj0 = 0 ;
5383 PyObject * obj1 = 0 ;
5384 char * kwnames[] = {
5385 (char *) "self",(char *) "size", NULL
5386 };
5387
5388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5392 }
5393 arg1 = reinterpret_cast< wxSize * >(argp1);
5394 {
5395 arg2 = &temp2;
5396 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5397 }
5398 {
5399 (arg1)->SetDefaults((wxSize const &)*arg2);
5400 if (PyErr_Occurred()) SWIG_fail;
5401 }
5402 resultobj = SWIG_Py_Void();
5403 return resultobj;
5404 fail:
5405 return NULL;
5406 }
5407
5408
5409 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5410 PyObject *resultobj = 0;
5411 wxSize *arg1 = (wxSize *) 0 ;
5412 PyObject *result = 0 ;
5413 void *argp1 = 0 ;
5414 int res1 = 0 ;
5415 PyObject *swig_obj[1] ;
5416
5417 if (!args) SWIG_fail;
5418 swig_obj[0] = args;
5419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5420 if (!SWIG_IsOK(res1)) {
5421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5422 }
5423 arg1 = reinterpret_cast< wxSize * >(argp1);
5424 {
5425 result = (PyObject *)wxSize_Get(arg1);
5426 if (PyErr_Occurred()) SWIG_fail;
5427 }
5428 resultobj = result;
5429 return resultobj;
5430 fail:
5431 return NULL;
5432 }
5433
5434
5435 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5436 PyObject *obj;
5437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5438 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5439 return SWIG_Py_Void();
5440 }
5441
5442 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5443 return SWIG_Python_InitShadowInstance(args);
5444 }
5445
5446 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5447 PyObject *resultobj = 0;
5448 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5449 double arg2 ;
5450 void *argp1 = 0 ;
5451 int res1 = 0 ;
5452 double val2 ;
5453 int ecode2 = 0 ;
5454 PyObject *swig_obj[2] ;
5455
5456 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5458 if (!SWIG_IsOK(res1)) {
5459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5460 }
5461 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5462 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5463 if (!SWIG_IsOK(ecode2)) {
5464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5465 }
5466 arg2 = static_cast< double >(val2);
5467 if (arg1) (arg1)->x = arg2;
5468
5469 resultobj = SWIG_Py_Void();
5470 return resultobj;
5471 fail:
5472 return NULL;
5473 }
5474
5475
5476 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5477 PyObject *resultobj = 0;
5478 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5479 double result;
5480 void *argp1 = 0 ;
5481 int res1 = 0 ;
5482 PyObject *swig_obj[1] ;
5483
5484 if (!args) SWIG_fail;
5485 swig_obj[0] = args;
5486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5487 if (!SWIG_IsOK(res1)) {
5488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5489 }
5490 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5491 result = (double) ((arg1)->x);
5492 resultobj = SWIG_From_double(static_cast< double >(result));
5493 return resultobj;
5494 fail:
5495 return NULL;
5496 }
5497
5498
5499 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5500 PyObject *resultobj = 0;
5501 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5502 double arg2 ;
5503 void *argp1 = 0 ;
5504 int res1 = 0 ;
5505 double val2 ;
5506 int ecode2 = 0 ;
5507 PyObject *swig_obj[2] ;
5508
5509 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5511 if (!SWIG_IsOK(res1)) {
5512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5513 }
5514 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5515 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5516 if (!SWIG_IsOK(ecode2)) {
5517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5518 }
5519 arg2 = static_cast< double >(val2);
5520 if (arg1) (arg1)->y = arg2;
5521
5522 resultobj = SWIG_Py_Void();
5523 return resultobj;
5524 fail:
5525 return NULL;
5526 }
5527
5528
5529 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5530 PyObject *resultobj = 0;
5531 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5532 double result;
5533 void *argp1 = 0 ;
5534 int res1 = 0 ;
5535 PyObject *swig_obj[1] ;
5536
5537 if (!args) SWIG_fail;
5538 swig_obj[0] = args;
5539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5540 if (!SWIG_IsOK(res1)) {
5541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5542 }
5543 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5544 result = (double) ((arg1)->y);
5545 resultobj = SWIG_From_double(static_cast< double >(result));
5546 return resultobj;
5547 fail:
5548 return NULL;
5549 }
5550
5551
5552 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5553 PyObject *resultobj = 0;
5554 double arg1 = (double) 0.0 ;
5555 double arg2 = (double) 0.0 ;
5556 wxRealPoint *result = 0 ;
5557 double val1 ;
5558 int ecode1 = 0 ;
5559 double val2 ;
5560 int ecode2 = 0 ;
5561 PyObject * obj0 = 0 ;
5562 PyObject * obj1 = 0 ;
5563 char * kwnames[] = {
5564 (char *) "x",(char *) "y", NULL
5565 };
5566
5567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5568 if (obj0) {
5569 ecode1 = SWIG_AsVal_double(obj0, &val1);
5570 if (!SWIG_IsOK(ecode1)) {
5571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5572 }
5573 arg1 = static_cast< double >(val1);
5574 }
5575 if (obj1) {
5576 ecode2 = SWIG_AsVal_double(obj1, &val2);
5577 if (!SWIG_IsOK(ecode2)) {
5578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5579 }
5580 arg2 = static_cast< double >(val2);
5581 }
5582 {
5583 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594 PyObject *resultobj = 0;
5595 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5596 void *argp1 = 0 ;
5597 int res1 = 0 ;
5598 PyObject *swig_obj[1] ;
5599
5600 if (!args) SWIG_fail;
5601 swig_obj[0] = args;
5602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5603 if (!SWIG_IsOK(res1)) {
5604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5605 }
5606 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5607 {
5608 delete arg1;
5609
5610 if (PyErr_Occurred()) SWIG_fail;
5611 }
5612 resultobj = SWIG_Py_Void();
5613 return resultobj;
5614 fail:
5615 return NULL;
5616 }
5617
5618
5619 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5620 PyObject *resultobj = 0;
5621 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5622 PyObject *arg2 = (PyObject *) 0 ;
5623 bool result;
5624 void *argp1 = 0 ;
5625 int res1 = 0 ;
5626 PyObject * obj0 = 0 ;
5627 PyObject * obj1 = 0 ;
5628 char * kwnames[] = {
5629 (char *) "self",(char *) "other", NULL
5630 };
5631
5632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5634 if (!SWIG_IsOK(res1)) {
5635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5636 }
5637 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5638 arg2 = obj1;
5639 {
5640 result = (bool)wxRealPoint___eq__(arg1,arg2);
5641 if (PyErr_Occurred()) SWIG_fail;
5642 }
5643 {
5644 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5645 }
5646 return resultobj;
5647 fail:
5648 return NULL;
5649 }
5650
5651
5652 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5653 PyObject *resultobj = 0;
5654 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5655 PyObject *arg2 = (PyObject *) 0 ;
5656 bool result;
5657 void *argp1 = 0 ;
5658 int res1 = 0 ;
5659 PyObject * obj0 = 0 ;
5660 PyObject * obj1 = 0 ;
5661 char * kwnames[] = {
5662 (char *) "self",(char *) "other", NULL
5663 };
5664
5665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5667 if (!SWIG_IsOK(res1)) {
5668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5669 }
5670 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5671 arg2 = obj1;
5672 {
5673 result = (bool)wxRealPoint___ne__(arg1,arg2);
5674 if (PyErr_Occurred()) SWIG_fail;
5675 }
5676 {
5677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5678 }
5679 return resultobj;
5680 fail:
5681 return NULL;
5682 }
5683
5684
5685 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5686 PyObject *resultobj = 0;
5687 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5688 wxRealPoint *arg2 = 0 ;
5689 wxRealPoint result;
5690 void *argp1 = 0 ;
5691 int res1 = 0 ;
5692 wxRealPoint temp2 ;
5693 PyObject * obj0 = 0 ;
5694 PyObject * obj1 = 0 ;
5695 char * kwnames[] = {
5696 (char *) "self",(char *) "pt", NULL
5697 };
5698
5699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5701 if (!SWIG_IsOK(res1)) {
5702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5703 }
5704 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5705 {
5706 arg2 = &temp2;
5707 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5708 }
5709 {
5710 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5711 if (PyErr_Occurred()) SWIG_fail;
5712 }
5713 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5714 return resultobj;
5715 fail:
5716 return NULL;
5717 }
5718
5719
5720 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5721 PyObject *resultobj = 0;
5722 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5723 wxRealPoint *arg2 = 0 ;
5724 wxRealPoint result;
5725 void *argp1 = 0 ;
5726 int res1 = 0 ;
5727 wxRealPoint temp2 ;
5728 PyObject * obj0 = 0 ;
5729 PyObject * obj1 = 0 ;
5730 char * kwnames[] = {
5731 (char *) "self",(char *) "pt", NULL
5732 };
5733
5734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5740 {
5741 arg2 = &temp2;
5742 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5743 }
5744 {
5745 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5746 if (PyErr_Occurred()) SWIG_fail;
5747 }
5748 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5749 return resultobj;
5750 fail:
5751 return NULL;
5752 }
5753
5754
5755 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5756 PyObject *resultobj = 0;
5757 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5758 double arg2 ;
5759 double arg3 ;
5760 void *argp1 = 0 ;
5761 int res1 = 0 ;
5762 double val2 ;
5763 int ecode2 = 0 ;
5764 double val3 ;
5765 int ecode3 = 0 ;
5766 PyObject * obj0 = 0 ;
5767 PyObject * obj1 = 0 ;
5768 PyObject * obj2 = 0 ;
5769 char * kwnames[] = {
5770 (char *) "self",(char *) "x",(char *) "y", NULL
5771 };
5772
5773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5775 if (!SWIG_IsOK(res1)) {
5776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5777 }
5778 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5779 ecode2 = SWIG_AsVal_double(obj1, &val2);
5780 if (!SWIG_IsOK(ecode2)) {
5781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5782 }
5783 arg2 = static_cast< double >(val2);
5784 ecode3 = SWIG_AsVal_double(obj2, &val3);
5785 if (!SWIG_IsOK(ecode3)) {
5786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5787 }
5788 arg3 = static_cast< double >(val3);
5789 {
5790 wxRealPoint_Set(arg1,arg2,arg3);
5791 if (PyErr_Occurred()) SWIG_fail;
5792 }
5793 resultobj = SWIG_Py_Void();
5794 return resultobj;
5795 fail:
5796 return NULL;
5797 }
5798
5799
5800 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5801 PyObject *resultobj = 0;
5802 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5803 PyObject *result = 0 ;
5804 void *argp1 = 0 ;
5805 int res1 = 0 ;
5806 PyObject *swig_obj[1] ;
5807
5808 if (!args) SWIG_fail;
5809 swig_obj[0] = args;
5810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5811 if (!SWIG_IsOK(res1)) {
5812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5813 }
5814 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5815 {
5816 result = (PyObject *)wxRealPoint_Get(arg1);
5817 if (PyErr_Occurred()) SWIG_fail;
5818 }
5819 resultobj = result;
5820 return resultobj;
5821 fail:
5822 return NULL;
5823 }
5824
5825
5826 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5827 PyObject *obj;
5828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5829 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5830 return SWIG_Py_Void();
5831 }
5832
5833 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5834 return SWIG_Python_InitShadowInstance(args);
5835 }
5836
5837 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5838 PyObject *resultobj = 0;
5839 wxPoint *arg1 = (wxPoint *) 0 ;
5840 int arg2 ;
5841 void *argp1 = 0 ;
5842 int res1 = 0 ;
5843 int val2 ;
5844 int ecode2 = 0 ;
5845 PyObject *swig_obj[2] ;
5846
5847 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5849 if (!SWIG_IsOK(res1)) {
5850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5851 }
5852 arg1 = reinterpret_cast< wxPoint * >(argp1);
5853 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5854 if (!SWIG_IsOK(ecode2)) {
5855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5856 }
5857 arg2 = static_cast< int >(val2);
5858 if (arg1) (arg1)->x = arg2;
5859
5860 resultobj = SWIG_Py_Void();
5861 return resultobj;
5862 fail:
5863 return NULL;
5864 }
5865
5866
5867 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5868 PyObject *resultobj = 0;
5869 wxPoint *arg1 = (wxPoint *) 0 ;
5870 int result;
5871 void *argp1 = 0 ;
5872 int res1 = 0 ;
5873 PyObject *swig_obj[1] ;
5874
5875 if (!args) SWIG_fail;
5876 swig_obj[0] = args;
5877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5878 if (!SWIG_IsOK(res1)) {
5879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5880 }
5881 arg1 = reinterpret_cast< wxPoint * >(argp1);
5882 result = (int) ((arg1)->x);
5883 resultobj = SWIG_From_int(static_cast< int >(result));
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5891 PyObject *resultobj = 0;
5892 wxPoint *arg1 = (wxPoint *) 0 ;
5893 int arg2 ;
5894 void *argp1 = 0 ;
5895 int res1 = 0 ;
5896 int val2 ;
5897 int ecode2 = 0 ;
5898 PyObject *swig_obj[2] ;
5899
5900 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5902 if (!SWIG_IsOK(res1)) {
5903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5904 }
5905 arg1 = reinterpret_cast< wxPoint * >(argp1);
5906 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5907 if (!SWIG_IsOK(ecode2)) {
5908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5909 }
5910 arg2 = static_cast< int >(val2);
5911 if (arg1) (arg1)->y = arg2;
5912
5913 resultobj = SWIG_Py_Void();
5914 return resultobj;
5915 fail:
5916 return NULL;
5917 }
5918
5919
5920 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5921 PyObject *resultobj = 0;
5922 wxPoint *arg1 = (wxPoint *) 0 ;
5923 int result;
5924 void *argp1 = 0 ;
5925 int res1 = 0 ;
5926 PyObject *swig_obj[1] ;
5927
5928 if (!args) SWIG_fail;
5929 swig_obj[0] = args;
5930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5931 if (!SWIG_IsOK(res1)) {
5932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5933 }
5934 arg1 = reinterpret_cast< wxPoint * >(argp1);
5935 result = (int) ((arg1)->y);
5936 resultobj = SWIG_From_int(static_cast< int >(result));
5937 return resultobj;
5938 fail:
5939 return NULL;
5940 }
5941
5942
5943 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5944 PyObject *resultobj = 0;
5945 int arg1 = (int) 0 ;
5946 int arg2 = (int) 0 ;
5947 wxPoint *result = 0 ;
5948 int val1 ;
5949 int ecode1 = 0 ;
5950 int val2 ;
5951 int ecode2 = 0 ;
5952 PyObject * obj0 = 0 ;
5953 PyObject * obj1 = 0 ;
5954 char * kwnames[] = {
5955 (char *) "x",(char *) "y", NULL
5956 };
5957
5958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5959 if (obj0) {
5960 ecode1 = SWIG_AsVal_int(obj0, &val1);
5961 if (!SWIG_IsOK(ecode1)) {
5962 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5963 }
5964 arg1 = static_cast< int >(val1);
5965 }
5966 if (obj1) {
5967 ecode2 = SWIG_AsVal_int(obj1, &val2);
5968 if (!SWIG_IsOK(ecode2)) {
5969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5970 }
5971 arg2 = static_cast< int >(val2);
5972 }
5973 {
5974 result = (wxPoint *)new wxPoint(arg1,arg2);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5985 PyObject *resultobj = 0;
5986 wxPoint *arg1 = (wxPoint *) 0 ;
5987 void *argp1 = 0 ;
5988 int res1 = 0 ;
5989 PyObject *swig_obj[1] ;
5990
5991 if (!args) SWIG_fail;
5992 swig_obj[0] = args;
5993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5994 if (!SWIG_IsOK(res1)) {
5995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5996 }
5997 arg1 = reinterpret_cast< wxPoint * >(argp1);
5998 {
5999 delete arg1;
6000
6001 if (PyErr_Occurred()) SWIG_fail;
6002 }
6003 resultobj = SWIG_Py_Void();
6004 return resultobj;
6005 fail:
6006 return NULL;
6007 }
6008
6009
6010 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6011 PyObject *resultobj = 0;
6012 wxPoint *arg1 = (wxPoint *) 0 ;
6013 PyObject *arg2 = (PyObject *) 0 ;
6014 bool result;
6015 void *argp1 = 0 ;
6016 int res1 = 0 ;
6017 PyObject * obj0 = 0 ;
6018 PyObject * obj1 = 0 ;
6019 char * kwnames[] = {
6020 (char *) "self",(char *) "other", NULL
6021 };
6022
6023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
6024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6025 if (!SWIG_IsOK(res1)) {
6026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
6027 }
6028 arg1 = reinterpret_cast< wxPoint * >(argp1);
6029 arg2 = obj1;
6030 {
6031 result = (bool)wxPoint___eq__(arg1,arg2);
6032 if (PyErr_Occurred()) SWIG_fail;
6033 }
6034 {
6035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6036 }
6037 return resultobj;
6038 fail:
6039 return NULL;
6040 }
6041
6042
6043 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6044 PyObject *resultobj = 0;
6045 wxPoint *arg1 = (wxPoint *) 0 ;
6046 PyObject *arg2 = (PyObject *) 0 ;
6047 bool result;
6048 void *argp1 = 0 ;
6049 int res1 = 0 ;
6050 PyObject * obj0 = 0 ;
6051 PyObject * obj1 = 0 ;
6052 char * kwnames[] = {
6053 (char *) "self",(char *) "other", NULL
6054 };
6055
6056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
6057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6058 if (!SWIG_IsOK(res1)) {
6059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
6060 }
6061 arg1 = reinterpret_cast< wxPoint * >(argp1);
6062 arg2 = obj1;
6063 {
6064 result = (bool)wxPoint___ne__(arg1,arg2);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 {
6068 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6069 }
6070 return resultobj;
6071 fail:
6072 return NULL;
6073 }
6074
6075
6076 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6077 PyObject *resultobj = 0;
6078 wxPoint *arg1 = (wxPoint *) 0 ;
6079 wxPoint *arg2 = 0 ;
6080 wxPoint result;
6081 void *argp1 = 0 ;
6082 int res1 = 0 ;
6083 wxPoint temp2 ;
6084 PyObject * obj0 = 0 ;
6085 PyObject * obj1 = 0 ;
6086 char * kwnames[] = {
6087 (char *) "self",(char *) "pt", NULL
6088 };
6089
6090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
6091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6092 if (!SWIG_IsOK(res1)) {
6093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
6094 }
6095 arg1 = reinterpret_cast< wxPoint * >(argp1);
6096 {
6097 arg2 = &temp2;
6098 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6099 }
6100 {
6101 result = (arg1)->operator +((wxPoint const &)*arg2);
6102 if (PyErr_Occurred()) SWIG_fail;
6103 }
6104 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6105 return resultobj;
6106 fail:
6107 return NULL;
6108 }
6109
6110
6111 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6112 PyObject *resultobj = 0;
6113 wxPoint *arg1 = (wxPoint *) 0 ;
6114 wxPoint *arg2 = 0 ;
6115 wxPoint result;
6116 void *argp1 = 0 ;
6117 int res1 = 0 ;
6118 wxPoint temp2 ;
6119 PyObject * obj0 = 0 ;
6120 PyObject * obj1 = 0 ;
6121 char * kwnames[] = {
6122 (char *) "self",(char *) "pt", NULL
6123 };
6124
6125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6127 if (!SWIG_IsOK(res1)) {
6128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6129 }
6130 arg1 = reinterpret_cast< wxPoint * >(argp1);
6131 {
6132 arg2 = &temp2;
6133 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6134 }
6135 {
6136 result = (arg1)->operator -((wxPoint const &)*arg2);
6137 if (PyErr_Occurred()) SWIG_fail;
6138 }
6139 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6140 return resultobj;
6141 fail:
6142 return NULL;
6143 }
6144
6145
6146 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6147 PyObject *resultobj = 0;
6148 wxPoint *arg1 = (wxPoint *) 0 ;
6149 wxPoint *arg2 = 0 ;
6150 wxPoint *result = 0 ;
6151 void *argp1 = 0 ;
6152 int res1 = 0 ;
6153 wxPoint temp2 ;
6154 PyObject * obj0 = 0 ;
6155 PyObject * obj1 = 0 ;
6156 char * kwnames[] = {
6157 (char *) "self",(char *) "pt", NULL
6158 };
6159
6160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6162 if (!SWIG_IsOK(res1)) {
6163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6164 }
6165 arg1 = reinterpret_cast< wxPoint * >(argp1);
6166 {
6167 arg2 = &temp2;
6168 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6169 }
6170 {
6171 {
6172 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6173 result = (wxPoint *) &_result_ref;
6174 }
6175 if (PyErr_Occurred()) SWIG_fail;
6176 }
6177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6178 return resultobj;
6179 fail:
6180 return NULL;
6181 }
6182
6183
6184 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6185 PyObject *resultobj = 0;
6186 wxPoint *arg1 = (wxPoint *) 0 ;
6187 wxPoint *arg2 = 0 ;
6188 wxPoint *result = 0 ;
6189 void *argp1 = 0 ;
6190 int res1 = 0 ;
6191 wxPoint temp2 ;
6192 PyObject * obj0 = 0 ;
6193 PyObject * obj1 = 0 ;
6194 char * kwnames[] = {
6195 (char *) "self",(char *) "pt", NULL
6196 };
6197
6198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6200 if (!SWIG_IsOK(res1)) {
6201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6202 }
6203 arg1 = reinterpret_cast< wxPoint * >(argp1);
6204 {
6205 arg2 = &temp2;
6206 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6207 }
6208 {
6209 {
6210 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6211 result = (wxPoint *) &_result_ref;
6212 }
6213 if (PyErr_Occurred()) SWIG_fail;
6214 }
6215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6216 return resultobj;
6217 fail:
6218 return NULL;
6219 }
6220
6221
6222 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6223 PyObject *resultobj = 0;
6224 wxPoint *arg1 = (wxPoint *) 0 ;
6225 long arg2 ;
6226 long arg3 ;
6227 void *argp1 = 0 ;
6228 int res1 = 0 ;
6229 long val2 ;
6230 int ecode2 = 0 ;
6231 long val3 ;
6232 int ecode3 = 0 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 PyObject * obj2 = 0 ;
6236 char * kwnames[] = {
6237 (char *) "self",(char *) "x",(char *) "y", NULL
6238 };
6239
6240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6242 if (!SWIG_IsOK(res1)) {
6243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6244 }
6245 arg1 = reinterpret_cast< wxPoint * >(argp1);
6246 ecode2 = SWIG_AsVal_long(obj1, &val2);
6247 if (!SWIG_IsOK(ecode2)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6249 }
6250 arg2 = static_cast< long >(val2);
6251 ecode3 = SWIG_AsVal_long(obj2, &val3);
6252 if (!SWIG_IsOK(ecode3)) {
6253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6254 }
6255 arg3 = static_cast< long >(val3);
6256 {
6257 wxPoint_Set(arg1,arg2,arg3);
6258 if (PyErr_Occurred()) SWIG_fail;
6259 }
6260 resultobj = SWIG_Py_Void();
6261 return resultobj;
6262 fail:
6263 return NULL;
6264 }
6265
6266
6267 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6268 PyObject *resultobj = 0;
6269 wxPoint *arg1 = (wxPoint *) 0 ;
6270 PyObject *result = 0 ;
6271 void *argp1 = 0 ;
6272 int res1 = 0 ;
6273 PyObject *swig_obj[1] ;
6274
6275 if (!args) SWIG_fail;
6276 swig_obj[0] = args;
6277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6278 if (!SWIG_IsOK(res1)) {
6279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6280 }
6281 arg1 = reinterpret_cast< wxPoint * >(argp1);
6282 {
6283 result = (PyObject *)wxPoint_Get(arg1);
6284 if (PyErr_Occurred()) SWIG_fail;
6285 }
6286 resultobj = result;
6287 return resultobj;
6288 fail:
6289 return NULL;
6290 }
6291
6292
6293 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6294 PyObject *obj;
6295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6296 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6297 return SWIG_Py_Void();
6298 }
6299
6300 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6301 return SWIG_Python_InitShadowInstance(args);
6302 }
6303
6304 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj = 0;
6306 int arg1 = (int) 0 ;
6307 int arg2 = (int) 0 ;
6308 int arg3 = (int) 0 ;
6309 int arg4 = (int) 0 ;
6310 wxRect *result = 0 ;
6311 int val1 ;
6312 int ecode1 = 0 ;
6313 int val2 ;
6314 int ecode2 = 0 ;
6315 int val3 ;
6316 int ecode3 = 0 ;
6317 int val4 ;
6318 int ecode4 = 0 ;
6319 PyObject * obj0 = 0 ;
6320 PyObject * obj1 = 0 ;
6321 PyObject * obj2 = 0 ;
6322 PyObject * obj3 = 0 ;
6323 char * kwnames[] = {
6324 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6325 };
6326
6327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6328 if (obj0) {
6329 ecode1 = SWIG_AsVal_int(obj0, &val1);
6330 if (!SWIG_IsOK(ecode1)) {
6331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6332 }
6333 arg1 = static_cast< int >(val1);
6334 }
6335 if (obj1) {
6336 ecode2 = SWIG_AsVal_int(obj1, &val2);
6337 if (!SWIG_IsOK(ecode2)) {
6338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6339 }
6340 arg2 = static_cast< int >(val2);
6341 }
6342 if (obj2) {
6343 ecode3 = SWIG_AsVal_int(obj2, &val3);
6344 if (!SWIG_IsOK(ecode3)) {
6345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6346 }
6347 arg3 = static_cast< int >(val3);
6348 }
6349 if (obj3) {
6350 ecode4 = SWIG_AsVal_int(obj3, &val4);
6351 if (!SWIG_IsOK(ecode4)) {
6352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6353 }
6354 arg4 = static_cast< int >(val4);
6355 }
6356 {
6357 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6358 if (PyErr_Occurred()) SWIG_fail;
6359 }
6360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6361 return resultobj;
6362 fail:
6363 return NULL;
6364 }
6365
6366
6367 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6368 PyObject *resultobj = 0;
6369 wxPoint *arg1 = 0 ;
6370 wxPoint *arg2 = 0 ;
6371 wxRect *result = 0 ;
6372 wxPoint temp1 ;
6373 wxPoint temp2 ;
6374 PyObject * obj0 = 0 ;
6375 PyObject * obj1 = 0 ;
6376 char * kwnames[] = {
6377 (char *) "topLeft",(char *) "bottomRight", NULL
6378 };
6379
6380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6381 {
6382 arg1 = &temp1;
6383 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6384 }
6385 {
6386 arg2 = &temp2;
6387 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6388 }
6389 {
6390 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6391 if (PyErr_Occurred()) SWIG_fail;
6392 }
6393 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6394 return resultobj;
6395 fail:
6396 return NULL;
6397 }
6398
6399
6400 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6401 PyObject *resultobj = 0;
6402 wxPoint *arg1 = 0 ;
6403 wxSize *arg2 = 0 ;
6404 wxRect *result = 0 ;
6405 wxPoint temp1 ;
6406 wxSize temp2 ;
6407 PyObject * obj0 = 0 ;
6408 PyObject * obj1 = 0 ;
6409 char * kwnames[] = {
6410 (char *) "pos",(char *) "size", NULL
6411 };
6412
6413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6414 {
6415 arg1 = &temp1;
6416 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6417 }
6418 {
6419 arg2 = &temp2;
6420 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6421 }
6422 {
6423 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj = 0;
6435 wxSize *arg1 = 0 ;
6436 wxRect *result = 0 ;
6437 wxSize temp1 ;
6438 PyObject * obj0 = 0 ;
6439 char * kwnames[] = {
6440 (char *) "size", NULL
6441 };
6442
6443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6444 {
6445 arg1 = &temp1;
6446 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6447 }
6448 {
6449 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6460 PyObject *resultobj = 0;
6461 wxRect *arg1 = (wxRect *) 0 ;
6462 void *argp1 = 0 ;
6463 int res1 = 0 ;
6464 PyObject *swig_obj[1] ;
6465
6466 if (!args) SWIG_fail;
6467 swig_obj[0] = args;
6468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6469 if (!SWIG_IsOK(res1)) {
6470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6471 }
6472 arg1 = reinterpret_cast< wxRect * >(argp1);
6473 {
6474 delete arg1;
6475
6476 if (PyErr_Occurred()) SWIG_fail;
6477 }
6478 resultobj = SWIG_Py_Void();
6479 return resultobj;
6480 fail:
6481 return NULL;
6482 }
6483
6484
6485 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6486 PyObject *resultobj = 0;
6487 wxRect *arg1 = (wxRect *) 0 ;
6488 int result;
6489 void *argp1 = 0 ;
6490 int res1 = 0 ;
6491 PyObject *swig_obj[1] ;
6492
6493 if (!args) SWIG_fail;
6494 swig_obj[0] = args;
6495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6496 if (!SWIG_IsOK(res1)) {
6497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6498 }
6499 arg1 = reinterpret_cast< wxRect * >(argp1);
6500 {
6501 result = (int)((wxRect const *)arg1)->GetX();
6502 if (PyErr_Occurred()) SWIG_fail;
6503 }
6504 resultobj = SWIG_From_int(static_cast< int >(result));
6505 return resultobj;
6506 fail:
6507 return NULL;
6508 }
6509
6510
6511 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6512 PyObject *resultobj = 0;
6513 wxRect *arg1 = (wxRect *) 0 ;
6514 int arg2 ;
6515 void *argp1 = 0 ;
6516 int res1 = 0 ;
6517 int val2 ;
6518 int ecode2 = 0 ;
6519 PyObject * obj0 = 0 ;
6520 PyObject * obj1 = 0 ;
6521 char * kwnames[] = {
6522 (char *) "self",(char *) "x", NULL
6523 };
6524
6525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6527 if (!SWIG_IsOK(res1)) {
6528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6529 }
6530 arg1 = reinterpret_cast< wxRect * >(argp1);
6531 ecode2 = SWIG_AsVal_int(obj1, &val2);
6532 if (!SWIG_IsOK(ecode2)) {
6533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6534 }
6535 arg2 = static_cast< int >(val2);
6536 {
6537 (arg1)->SetX(arg2);
6538 if (PyErr_Occurred()) SWIG_fail;
6539 }
6540 resultobj = SWIG_Py_Void();
6541 return resultobj;
6542 fail:
6543 return NULL;
6544 }
6545
6546
6547 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6548 PyObject *resultobj = 0;
6549 wxRect *arg1 = (wxRect *) 0 ;
6550 int result;
6551 void *argp1 = 0 ;
6552 int res1 = 0 ;
6553 PyObject *swig_obj[1] ;
6554
6555 if (!args) SWIG_fail;
6556 swig_obj[0] = args;
6557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6558 if (!SWIG_IsOK(res1)) {
6559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6560 }
6561 arg1 = reinterpret_cast< wxRect * >(argp1);
6562 {
6563 result = (int)(arg1)->GetY();
6564 if (PyErr_Occurred()) SWIG_fail;
6565 }
6566 resultobj = SWIG_From_int(static_cast< int >(result));
6567 return resultobj;
6568 fail:
6569 return NULL;
6570 }
6571
6572
6573 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6574 PyObject *resultobj = 0;
6575 wxRect *arg1 = (wxRect *) 0 ;
6576 int arg2 ;
6577 void *argp1 = 0 ;
6578 int res1 = 0 ;
6579 int val2 ;
6580 int ecode2 = 0 ;
6581 PyObject * obj0 = 0 ;
6582 PyObject * obj1 = 0 ;
6583 char * kwnames[] = {
6584 (char *) "self",(char *) "y", NULL
6585 };
6586
6587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6589 if (!SWIG_IsOK(res1)) {
6590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6591 }
6592 arg1 = reinterpret_cast< wxRect * >(argp1);
6593 ecode2 = SWIG_AsVal_int(obj1, &val2);
6594 if (!SWIG_IsOK(ecode2)) {
6595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6596 }
6597 arg2 = static_cast< int >(val2);
6598 {
6599 (arg1)->SetY(arg2);
6600 if (PyErr_Occurred()) SWIG_fail;
6601 }
6602 resultobj = SWIG_Py_Void();
6603 return resultobj;
6604 fail:
6605 return NULL;
6606 }
6607
6608
6609 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6610 PyObject *resultobj = 0;
6611 wxRect *arg1 = (wxRect *) 0 ;
6612 int result;
6613 void *argp1 = 0 ;
6614 int res1 = 0 ;
6615 PyObject *swig_obj[1] ;
6616
6617 if (!args) SWIG_fail;
6618 swig_obj[0] = args;
6619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6620 if (!SWIG_IsOK(res1)) {
6621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6622 }
6623 arg1 = reinterpret_cast< wxRect * >(argp1);
6624 {
6625 result = (int)((wxRect const *)arg1)->GetWidth();
6626 if (PyErr_Occurred()) SWIG_fail;
6627 }
6628 resultobj = SWIG_From_int(static_cast< int >(result));
6629 return resultobj;
6630 fail:
6631 return NULL;
6632 }
6633
6634
6635 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6636 PyObject *resultobj = 0;
6637 wxRect *arg1 = (wxRect *) 0 ;
6638 int arg2 ;
6639 void *argp1 = 0 ;
6640 int res1 = 0 ;
6641 int val2 ;
6642 int ecode2 = 0 ;
6643 PyObject * obj0 = 0 ;
6644 PyObject * obj1 = 0 ;
6645 char * kwnames[] = {
6646 (char *) "self",(char *) "w", NULL
6647 };
6648
6649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6651 if (!SWIG_IsOK(res1)) {
6652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6653 }
6654 arg1 = reinterpret_cast< wxRect * >(argp1);
6655 ecode2 = SWIG_AsVal_int(obj1, &val2);
6656 if (!SWIG_IsOK(ecode2)) {
6657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6658 }
6659 arg2 = static_cast< int >(val2);
6660 {
6661 (arg1)->SetWidth(arg2);
6662 if (PyErr_Occurred()) SWIG_fail;
6663 }
6664 resultobj = SWIG_Py_Void();
6665 return resultobj;
6666 fail:
6667 return NULL;
6668 }
6669
6670
6671 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6672 PyObject *resultobj = 0;
6673 wxRect *arg1 = (wxRect *) 0 ;
6674 int result;
6675 void *argp1 = 0 ;
6676 int res1 = 0 ;
6677 PyObject *swig_obj[1] ;
6678
6679 if (!args) SWIG_fail;
6680 swig_obj[0] = args;
6681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6682 if (!SWIG_IsOK(res1)) {
6683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6684 }
6685 arg1 = reinterpret_cast< wxRect * >(argp1);
6686 {
6687 result = (int)((wxRect const *)arg1)->GetHeight();
6688 if (PyErr_Occurred()) SWIG_fail;
6689 }
6690 resultobj = SWIG_From_int(static_cast< int >(result));
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6698 PyObject *resultobj = 0;
6699 wxRect *arg1 = (wxRect *) 0 ;
6700 int arg2 ;
6701 void *argp1 = 0 ;
6702 int res1 = 0 ;
6703 int val2 ;
6704 int ecode2 = 0 ;
6705 PyObject * obj0 = 0 ;
6706 PyObject * obj1 = 0 ;
6707 char * kwnames[] = {
6708 (char *) "self",(char *) "h", NULL
6709 };
6710
6711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6713 if (!SWIG_IsOK(res1)) {
6714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6715 }
6716 arg1 = reinterpret_cast< wxRect * >(argp1);
6717 ecode2 = SWIG_AsVal_int(obj1, &val2);
6718 if (!SWIG_IsOK(ecode2)) {
6719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6720 }
6721 arg2 = static_cast< int >(val2);
6722 {
6723 (arg1)->SetHeight(arg2);
6724 if (PyErr_Occurred()) SWIG_fail;
6725 }
6726 resultobj = SWIG_Py_Void();
6727 return resultobj;
6728 fail:
6729 return NULL;
6730 }
6731
6732
6733 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6734 PyObject *resultobj = 0;
6735 wxRect *arg1 = (wxRect *) 0 ;
6736 wxPoint result;
6737 void *argp1 = 0 ;
6738 int res1 = 0 ;
6739 PyObject *swig_obj[1] ;
6740
6741 if (!args) SWIG_fail;
6742 swig_obj[0] = args;
6743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6744 if (!SWIG_IsOK(res1)) {
6745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6746 }
6747 arg1 = reinterpret_cast< wxRect * >(argp1);
6748 {
6749 result = ((wxRect const *)arg1)->GetPosition();
6750 if (PyErr_Occurred()) SWIG_fail;
6751 }
6752 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6753 return resultobj;
6754 fail:
6755 return NULL;
6756 }
6757
6758
6759 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6760 PyObject *resultobj = 0;
6761 wxRect *arg1 = (wxRect *) 0 ;
6762 wxPoint *arg2 = 0 ;
6763 void *argp1 = 0 ;
6764 int res1 = 0 ;
6765 wxPoint temp2 ;
6766 PyObject * obj0 = 0 ;
6767 PyObject * obj1 = 0 ;
6768 char * kwnames[] = {
6769 (char *) "self",(char *) "p", NULL
6770 };
6771
6772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6774 if (!SWIG_IsOK(res1)) {
6775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6776 }
6777 arg1 = reinterpret_cast< wxRect * >(argp1);
6778 {
6779 arg2 = &temp2;
6780 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6781 }
6782 {
6783 (arg1)->SetPosition((wxPoint const &)*arg2);
6784 if (PyErr_Occurred()) SWIG_fail;
6785 }
6786 resultobj = SWIG_Py_Void();
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6794 PyObject *resultobj = 0;
6795 wxRect *arg1 = (wxRect *) 0 ;
6796 wxSize result;
6797 void *argp1 = 0 ;
6798 int res1 = 0 ;
6799 PyObject *swig_obj[1] ;
6800
6801 if (!args) SWIG_fail;
6802 swig_obj[0] = args;
6803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6804 if (!SWIG_IsOK(res1)) {
6805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6806 }
6807 arg1 = reinterpret_cast< wxRect * >(argp1);
6808 {
6809 result = ((wxRect const *)arg1)->GetSize();
6810 if (PyErr_Occurred()) SWIG_fail;
6811 }
6812 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6813 return resultobj;
6814 fail:
6815 return NULL;
6816 }
6817
6818
6819 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6820 PyObject *resultobj = 0;
6821 wxRect *arg1 = (wxRect *) 0 ;
6822 wxSize *arg2 = 0 ;
6823 void *argp1 = 0 ;
6824 int res1 = 0 ;
6825 wxSize temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char * kwnames[] = {
6829 (char *) "self",(char *) "s", NULL
6830 };
6831
6832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6834 if (!SWIG_IsOK(res1)) {
6835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6836 }
6837 arg1 = reinterpret_cast< wxRect * >(argp1);
6838 {
6839 arg2 = &temp2;
6840 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6841 }
6842 {
6843 (arg1)->SetSize((wxSize const &)*arg2);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 resultobj = SWIG_Py_Void();
6847 return resultobj;
6848 fail:
6849 return NULL;
6850 }
6851
6852
6853 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6854 PyObject *resultobj = 0;
6855 wxRect *arg1 = (wxRect *) 0 ;
6856 bool result;
6857 void *argp1 = 0 ;
6858 int res1 = 0 ;
6859 PyObject *swig_obj[1] ;
6860
6861 if (!args) SWIG_fail;
6862 swig_obj[0] = args;
6863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6864 if (!SWIG_IsOK(res1)) {
6865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6866 }
6867 arg1 = reinterpret_cast< wxRect * >(argp1);
6868 {
6869 result = (bool)((wxRect const *)arg1)->IsEmpty();
6870 if (PyErr_Occurred()) SWIG_fail;
6871 }
6872 {
6873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6874 }
6875 return resultobj;
6876 fail:
6877 return NULL;
6878 }
6879
6880
6881 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6882 PyObject *resultobj = 0;
6883 wxRect *arg1 = (wxRect *) 0 ;
6884 wxPoint result;
6885 void *argp1 = 0 ;
6886 int res1 = 0 ;
6887 PyObject *swig_obj[1] ;
6888
6889 if (!args) SWIG_fail;
6890 swig_obj[0] = args;
6891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6892 if (!SWIG_IsOK(res1)) {
6893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6894 }
6895 arg1 = reinterpret_cast< wxRect * >(argp1);
6896 {
6897 result = ((wxRect const *)arg1)->GetTopLeft();
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6901 return resultobj;
6902 fail:
6903 return NULL;
6904 }
6905
6906
6907 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6908 PyObject *resultobj = 0;
6909 wxRect *arg1 = (wxRect *) 0 ;
6910 wxPoint *arg2 = 0 ;
6911 void *argp1 = 0 ;
6912 int res1 = 0 ;
6913 wxPoint temp2 ;
6914 PyObject * obj0 = 0 ;
6915 PyObject * obj1 = 0 ;
6916 char * kwnames[] = {
6917 (char *) "self",(char *) "p", NULL
6918 };
6919
6920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6922 if (!SWIG_IsOK(res1)) {
6923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6924 }
6925 arg1 = reinterpret_cast< wxRect * >(argp1);
6926 {
6927 arg2 = &temp2;
6928 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6929 }
6930 {
6931 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6932 if (PyErr_Occurred()) SWIG_fail;
6933 }
6934 resultobj = SWIG_Py_Void();
6935 return resultobj;
6936 fail:
6937 return NULL;
6938 }
6939
6940
6941 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6942 PyObject *resultobj = 0;
6943 wxRect *arg1 = (wxRect *) 0 ;
6944 wxPoint result;
6945 void *argp1 = 0 ;
6946 int res1 = 0 ;
6947 PyObject *swig_obj[1] ;
6948
6949 if (!args) SWIG_fail;
6950 swig_obj[0] = args;
6951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6952 if (!SWIG_IsOK(res1)) {
6953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6954 }
6955 arg1 = reinterpret_cast< wxRect * >(argp1);
6956 {
6957 result = ((wxRect const *)arg1)->GetBottomRight();
6958 if (PyErr_Occurred()) SWIG_fail;
6959 }
6960 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6961 return resultobj;
6962 fail:
6963 return NULL;
6964 }
6965
6966
6967 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6968 PyObject *resultobj = 0;
6969 wxRect *arg1 = (wxRect *) 0 ;
6970 wxPoint *arg2 = 0 ;
6971 void *argp1 = 0 ;
6972 int res1 = 0 ;
6973 wxPoint temp2 ;
6974 PyObject * obj0 = 0 ;
6975 PyObject * obj1 = 0 ;
6976 char * kwnames[] = {
6977 (char *) "self",(char *) "p", NULL
6978 };
6979
6980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6982 if (!SWIG_IsOK(res1)) {
6983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6984 }
6985 arg1 = reinterpret_cast< wxRect * >(argp1);
6986 {
6987 arg2 = &temp2;
6988 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6989 }
6990 {
6991 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_Py_Void();
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7002 PyObject *resultobj = 0;
7003 wxRect *arg1 = (wxRect *) 0 ;
7004 wxPoint result;
7005 void *argp1 = 0 ;
7006 int res1 = 0 ;
7007 PyObject *swig_obj[1] ;
7008
7009 if (!args) SWIG_fail;
7010 swig_obj[0] = args;
7011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7012 if (!SWIG_IsOK(res1)) {
7013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7014 }
7015 arg1 = reinterpret_cast< wxRect * >(argp1);
7016 {
7017 result = ((wxRect const *)arg1)->GetTopRight();
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj = 0;
7029 wxRect *arg1 = (wxRect *) 0 ;
7030 wxPoint *arg2 = 0 ;
7031 void *argp1 = 0 ;
7032 int res1 = 0 ;
7033 wxPoint temp2 ;
7034 PyObject * obj0 = 0 ;
7035 PyObject * obj1 = 0 ;
7036 char * kwnames[] = {
7037 (char *) "self",(char *) "p", NULL
7038 };
7039
7040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
7041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7042 if (!SWIG_IsOK(res1)) {
7043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
7044 }
7045 arg1 = reinterpret_cast< wxRect * >(argp1);
7046 {
7047 arg2 = &temp2;
7048 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7049 }
7050 {
7051 (arg1)->SetTopRight((wxPoint const &)*arg2);
7052 if (PyErr_Occurred()) SWIG_fail;
7053 }
7054 resultobj = SWIG_Py_Void();
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 wxRect *arg1 = (wxRect *) 0 ;
7064 wxPoint result;
7065 void *argp1 = 0 ;
7066 int res1 = 0 ;
7067 PyObject *swig_obj[1] ;
7068
7069 if (!args) SWIG_fail;
7070 swig_obj[0] = args;
7071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7072 if (!SWIG_IsOK(res1)) {
7073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7074 }
7075 arg1 = reinterpret_cast< wxRect * >(argp1);
7076 {
7077 result = ((wxRect const *)arg1)->GetBottomLeft();
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
7081 return resultobj;
7082 fail:
7083 return NULL;
7084 }
7085
7086
7087 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7088 PyObject *resultobj = 0;
7089 wxRect *arg1 = (wxRect *) 0 ;
7090 wxPoint *arg2 = 0 ;
7091 void *argp1 = 0 ;
7092 int res1 = 0 ;
7093 wxPoint temp2 ;
7094 PyObject * obj0 = 0 ;
7095 PyObject * obj1 = 0 ;
7096 char * kwnames[] = {
7097 (char *) "self",(char *) "p", NULL
7098 };
7099
7100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7102 if (!SWIG_IsOK(res1)) {
7103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7104 }
7105 arg1 = reinterpret_cast< wxRect * >(argp1);
7106 {
7107 arg2 = &temp2;
7108 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7109 }
7110 {
7111 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7112 if (PyErr_Occurred()) SWIG_fail;
7113 }
7114 resultobj = SWIG_Py_Void();
7115 return resultobj;
7116 fail:
7117 return NULL;
7118 }
7119
7120
7121 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7122 PyObject *resultobj = 0;
7123 wxRect *arg1 = (wxRect *) 0 ;
7124 int result;
7125 void *argp1 = 0 ;
7126 int res1 = 0 ;
7127 PyObject *swig_obj[1] ;
7128
7129 if (!args) SWIG_fail;
7130 swig_obj[0] = args;
7131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7132 if (!SWIG_IsOK(res1)) {
7133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7134 }
7135 arg1 = reinterpret_cast< wxRect * >(argp1);
7136 {
7137 result = (int)((wxRect const *)arg1)->GetLeft();
7138 if (PyErr_Occurred()) SWIG_fail;
7139 }
7140 resultobj = SWIG_From_int(static_cast< int >(result));
7141 return resultobj;
7142 fail:
7143 return NULL;
7144 }
7145
7146
7147 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7148 PyObject *resultobj = 0;
7149 wxRect *arg1 = (wxRect *) 0 ;
7150 int result;
7151 void *argp1 = 0 ;
7152 int res1 = 0 ;
7153 PyObject *swig_obj[1] ;
7154
7155 if (!args) SWIG_fail;
7156 swig_obj[0] = args;
7157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7158 if (!SWIG_IsOK(res1)) {
7159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7160 }
7161 arg1 = reinterpret_cast< wxRect * >(argp1);
7162 {
7163 result = (int)((wxRect const *)arg1)->GetTop();
7164 if (PyErr_Occurred()) SWIG_fail;
7165 }
7166 resultobj = SWIG_From_int(static_cast< int >(result));
7167 return resultobj;
7168 fail:
7169 return NULL;
7170 }
7171
7172
7173 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7174 PyObject *resultobj = 0;
7175 wxRect *arg1 = (wxRect *) 0 ;
7176 int result;
7177 void *argp1 = 0 ;
7178 int res1 = 0 ;
7179 PyObject *swig_obj[1] ;
7180
7181 if (!args) SWIG_fail;
7182 swig_obj[0] = args;
7183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7184 if (!SWIG_IsOK(res1)) {
7185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7186 }
7187 arg1 = reinterpret_cast< wxRect * >(argp1);
7188 {
7189 result = (int)((wxRect const *)arg1)->GetBottom();
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_From_int(static_cast< int >(result));
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 int result;
7203 void *argp1 = 0 ;
7204 int res1 = 0 ;
7205 PyObject *swig_obj[1] ;
7206
7207 if (!args) SWIG_fail;
7208 swig_obj[0] = args;
7209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7210 if (!SWIG_IsOK(res1)) {
7211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7212 }
7213 arg1 = reinterpret_cast< wxRect * >(argp1);
7214 {
7215 result = (int)((wxRect const *)arg1)->GetRight();
7216 if (PyErr_Occurred()) SWIG_fail;
7217 }
7218 resultobj = SWIG_From_int(static_cast< int >(result));
7219 return resultobj;
7220 fail:
7221 return NULL;
7222 }
7223
7224
7225 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7226 PyObject *resultobj = 0;
7227 wxRect *arg1 = (wxRect *) 0 ;
7228 int arg2 ;
7229 void *argp1 = 0 ;
7230 int res1 = 0 ;
7231 int val2 ;
7232 int ecode2 = 0 ;
7233 PyObject * obj0 = 0 ;
7234 PyObject * obj1 = 0 ;
7235 char * kwnames[] = {
7236 (char *) "self",(char *) "left", NULL
7237 };
7238
7239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7241 if (!SWIG_IsOK(res1)) {
7242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7243 }
7244 arg1 = reinterpret_cast< wxRect * >(argp1);
7245 ecode2 = SWIG_AsVal_int(obj1, &val2);
7246 if (!SWIG_IsOK(ecode2)) {
7247 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7248 }
7249 arg2 = static_cast< int >(val2);
7250 {
7251 (arg1)->SetLeft(arg2);
7252 if (PyErr_Occurred()) SWIG_fail;
7253 }
7254 resultobj = SWIG_Py_Void();
7255 return resultobj;
7256 fail:
7257 return NULL;
7258 }
7259
7260
7261 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7262 PyObject *resultobj = 0;
7263 wxRect *arg1 = (wxRect *) 0 ;
7264 int arg2 ;
7265 void *argp1 = 0 ;
7266 int res1 = 0 ;
7267 int val2 ;
7268 int ecode2 = 0 ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "right", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7277 if (!SWIG_IsOK(res1)) {
7278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7279 }
7280 arg1 = reinterpret_cast< wxRect * >(argp1);
7281 ecode2 = SWIG_AsVal_int(obj1, &val2);
7282 if (!SWIG_IsOK(ecode2)) {
7283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7284 }
7285 arg2 = static_cast< int >(val2);
7286 {
7287 (arg1)->SetRight(arg2);
7288 if (PyErr_Occurred()) SWIG_fail;
7289 }
7290 resultobj = SWIG_Py_Void();
7291 return resultobj;
7292 fail:
7293 return NULL;
7294 }
7295
7296
7297 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7298 PyObject *resultobj = 0;
7299 wxRect *arg1 = (wxRect *) 0 ;
7300 int arg2 ;
7301 void *argp1 = 0 ;
7302 int res1 = 0 ;
7303 int val2 ;
7304 int ecode2 = 0 ;
7305 PyObject * obj0 = 0 ;
7306 PyObject * obj1 = 0 ;
7307 char * kwnames[] = {
7308 (char *) "self",(char *) "top", NULL
7309 };
7310
7311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7313 if (!SWIG_IsOK(res1)) {
7314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7315 }
7316 arg1 = reinterpret_cast< wxRect * >(argp1);
7317 ecode2 = SWIG_AsVal_int(obj1, &val2);
7318 if (!SWIG_IsOK(ecode2)) {
7319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7320 }
7321 arg2 = static_cast< int >(val2);
7322 {
7323 (arg1)->SetTop(arg2);
7324 if (PyErr_Occurred()) SWIG_fail;
7325 }
7326 resultobj = SWIG_Py_Void();
7327 return resultobj;
7328 fail:
7329 return NULL;
7330 }
7331
7332
7333 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7334 PyObject *resultobj = 0;
7335 wxRect *arg1 = (wxRect *) 0 ;
7336 int arg2 ;
7337 void *argp1 = 0 ;
7338 int res1 = 0 ;
7339 int val2 ;
7340 int ecode2 = 0 ;
7341 PyObject * obj0 = 0 ;
7342 PyObject * obj1 = 0 ;
7343 char * kwnames[] = {
7344 (char *) "self",(char *) "bottom", NULL
7345 };
7346
7347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7349 if (!SWIG_IsOK(res1)) {
7350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7351 }
7352 arg1 = reinterpret_cast< wxRect * >(argp1);
7353 ecode2 = SWIG_AsVal_int(obj1, &val2);
7354 if (!SWIG_IsOK(ecode2)) {
7355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7356 }
7357 arg2 = static_cast< int >(val2);
7358 {
7359 (arg1)->SetBottom(arg2);
7360 if (PyErr_Occurred()) SWIG_fail;
7361 }
7362 resultobj = SWIG_Py_Void();
7363 return resultobj;
7364 fail:
7365 return NULL;
7366 }
7367
7368
7369 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj = 0;
7371 wxRect *arg1 = (wxRect *) 0 ;
7372 int arg2 ;
7373 int arg3 ;
7374 wxRect result;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 int val2 ;
7378 int ecode2 = 0 ;
7379 int val3 ;
7380 int ecode3 = 0 ;
7381 PyObject * obj0 = 0 ;
7382 PyObject * obj1 = 0 ;
7383 PyObject * obj2 = 0 ;
7384 char * kwnames[] = {
7385 (char *) "self",(char *) "dx",(char *) "dy", NULL
7386 };
7387
7388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7390 if (!SWIG_IsOK(res1)) {
7391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7392 }
7393 arg1 = reinterpret_cast< wxRect * >(argp1);
7394 ecode2 = SWIG_AsVal_int(obj1, &val2);
7395 if (!SWIG_IsOK(ecode2)) {
7396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7397 }
7398 arg2 = static_cast< int >(val2);
7399 ecode3 = SWIG_AsVal_int(obj2, &val3);
7400 if (!SWIG_IsOK(ecode3)) {
7401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7402 }
7403 arg3 = static_cast< int >(val3);
7404 {
7405 result = (arg1)->Inflate(arg2,arg3);
7406 if (PyErr_Occurred()) SWIG_fail;
7407 }
7408 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7409 return resultobj;
7410 fail:
7411 return NULL;
7412 }
7413
7414
7415 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7416 PyObject *resultobj = 0;
7417 wxRect *arg1 = (wxRect *) 0 ;
7418 int arg2 ;
7419 int arg3 ;
7420 wxRect *result = 0 ;
7421 void *argp1 = 0 ;
7422 int res1 = 0 ;
7423 int val2 ;
7424 int ecode2 = 0 ;
7425 int val3 ;
7426 int ecode3 = 0 ;
7427 PyObject * obj0 = 0 ;
7428 PyObject * obj1 = 0 ;
7429 PyObject * obj2 = 0 ;
7430 char * kwnames[] = {
7431 (char *) "self",(char *) "dx",(char *) "dy", NULL
7432 };
7433
7434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7436 if (!SWIG_IsOK(res1)) {
7437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7438 }
7439 arg1 = reinterpret_cast< wxRect * >(argp1);
7440 ecode2 = SWIG_AsVal_int(obj1, &val2);
7441 if (!SWIG_IsOK(ecode2)) {
7442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7443 }
7444 arg2 = static_cast< int >(val2);
7445 ecode3 = SWIG_AsVal_int(obj2, &val3);
7446 if (!SWIG_IsOK(ecode3)) {
7447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7448 }
7449 arg3 = static_cast< int >(val3);
7450 {
7451 {
7452 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7453 result = (wxRect *) &_result_ref;
7454 }
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7458 return resultobj;
7459 fail:
7460 return NULL;
7461 }
7462
7463
7464 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7465 PyObject *resultobj = 0;
7466 wxRect *arg1 = (wxRect *) 0 ;
7467 int arg2 ;
7468 int arg3 ;
7469 void *argp1 = 0 ;
7470 int res1 = 0 ;
7471 int val2 ;
7472 int ecode2 = 0 ;
7473 int val3 ;
7474 int ecode3 = 0 ;
7475 PyObject * obj0 = 0 ;
7476 PyObject * obj1 = 0 ;
7477 PyObject * obj2 = 0 ;
7478 char * kwnames[] = {
7479 (char *) "self",(char *) "dx",(char *) "dy", NULL
7480 };
7481
7482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7484 if (!SWIG_IsOK(res1)) {
7485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7486 }
7487 arg1 = reinterpret_cast< wxRect * >(argp1);
7488 ecode2 = SWIG_AsVal_int(obj1, &val2);
7489 if (!SWIG_IsOK(ecode2)) {
7490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7491 }
7492 arg2 = static_cast< int >(val2);
7493 ecode3 = SWIG_AsVal_int(obj2, &val3);
7494 if (!SWIG_IsOK(ecode3)) {
7495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7496 }
7497 arg3 = static_cast< int >(val3);
7498 {
7499 (arg1)->Offset(arg2,arg3);
7500 if (PyErr_Occurred()) SWIG_fail;
7501 }
7502 resultobj = SWIG_Py_Void();
7503 return resultobj;
7504 fail:
7505 return NULL;
7506 }
7507
7508
7509 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7510 PyObject *resultobj = 0;
7511 wxRect *arg1 = (wxRect *) 0 ;
7512 wxPoint *arg2 = 0 ;
7513 void *argp1 = 0 ;
7514 int res1 = 0 ;
7515 wxPoint temp2 ;
7516 PyObject * obj0 = 0 ;
7517 PyObject * obj1 = 0 ;
7518 char * kwnames[] = {
7519 (char *) "self",(char *) "pt", NULL
7520 };
7521
7522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7524 if (!SWIG_IsOK(res1)) {
7525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7526 }
7527 arg1 = reinterpret_cast< wxRect * >(argp1);
7528 {
7529 arg2 = &temp2;
7530 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7531 }
7532 {
7533 (arg1)->Offset((wxPoint const &)*arg2);
7534 if (PyErr_Occurred()) SWIG_fail;
7535 }
7536 resultobj = SWIG_Py_Void();
7537 return resultobj;
7538 fail:
7539 return NULL;
7540 }
7541
7542
7543 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7544 PyObject *resultobj = 0;
7545 wxRect *arg1 = (wxRect *) 0 ;
7546 wxRect *arg2 = 0 ;
7547 wxRect result;
7548 void *argp1 = 0 ;
7549 int res1 = 0 ;
7550 wxRect temp2 ;
7551 PyObject * obj0 = 0 ;
7552 PyObject * obj1 = 0 ;
7553 char * kwnames[] = {
7554 (char *) "self",(char *) "rect", NULL
7555 };
7556
7557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7559 if (!SWIG_IsOK(res1)) {
7560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7561 }
7562 arg1 = reinterpret_cast< wxRect * >(argp1);
7563 {
7564 arg2 = &temp2;
7565 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7566 }
7567 {
7568 result = (arg1)->Intersect((wxRect const &)*arg2);
7569 if (PyErr_Occurred()) SWIG_fail;
7570 }
7571 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7572 return resultobj;
7573 fail:
7574 return NULL;
7575 }
7576
7577
7578 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7579 PyObject *resultobj = 0;
7580 wxRect *arg1 = (wxRect *) 0 ;
7581 wxRect *arg2 = 0 ;
7582 wxRect result;
7583 void *argp1 = 0 ;
7584 int res1 = 0 ;
7585 wxRect temp2 ;
7586 PyObject * obj0 = 0 ;
7587 PyObject * obj1 = 0 ;
7588 char * kwnames[] = {
7589 (char *) "self",(char *) "rect", NULL
7590 };
7591
7592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7594 if (!SWIG_IsOK(res1)) {
7595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7596 }
7597 arg1 = reinterpret_cast< wxRect * >(argp1);
7598 {
7599 arg2 = &temp2;
7600 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7601 }
7602 {
7603 result = (arg1)->Union((wxRect const &)*arg2);
7604 if (PyErr_Occurred()) SWIG_fail;
7605 }
7606 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7607 return resultobj;
7608 fail:
7609 return NULL;
7610 }
7611
7612
7613 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7614 PyObject *resultobj = 0;
7615 wxRect *arg1 = (wxRect *) 0 ;
7616 wxRect *arg2 = 0 ;
7617 wxRect result;
7618 void *argp1 = 0 ;
7619 int res1 = 0 ;
7620 wxRect temp2 ;
7621 PyObject * obj0 = 0 ;
7622 PyObject * obj1 = 0 ;
7623 char * kwnames[] = {
7624 (char *) "self",(char *) "rect", NULL
7625 };
7626
7627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7629 if (!SWIG_IsOK(res1)) {
7630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7631 }
7632 arg1 = reinterpret_cast< wxRect * >(argp1);
7633 {
7634 arg2 = &temp2;
7635 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7636 }
7637 {
7638 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7642 return resultobj;
7643 fail:
7644 return NULL;
7645 }
7646
7647
7648 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7649 PyObject *resultobj = 0;
7650 wxRect *arg1 = (wxRect *) 0 ;
7651 wxRect *arg2 = 0 ;
7652 wxRect *result = 0 ;
7653 void *argp1 = 0 ;
7654 int res1 = 0 ;
7655 wxRect temp2 ;
7656 PyObject * obj0 = 0 ;
7657 PyObject * obj1 = 0 ;
7658 char * kwnames[] = {
7659 (char *) "self",(char *) "rect", NULL
7660 };
7661
7662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7664 if (!SWIG_IsOK(res1)) {
7665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7666 }
7667 arg1 = reinterpret_cast< wxRect * >(argp1);
7668 {
7669 arg2 = &temp2;
7670 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7671 }
7672 {
7673 {
7674 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7675 result = (wxRect *) &_result_ref;
7676 }
7677 if (PyErr_Occurred()) SWIG_fail;
7678 }
7679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7680 return resultobj;
7681 fail:
7682 return NULL;
7683 }
7684
7685
7686 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7687 PyObject *resultobj = 0;
7688 wxRect *arg1 = (wxRect *) 0 ;
7689 PyObject *arg2 = (PyObject *) 0 ;
7690 bool result;
7691 void *argp1 = 0 ;
7692 int res1 = 0 ;
7693 PyObject * obj0 = 0 ;
7694 PyObject * obj1 = 0 ;
7695 char * kwnames[] = {
7696 (char *) "self",(char *) "other", NULL
7697 };
7698
7699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7701 if (!SWIG_IsOK(res1)) {
7702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7703 }
7704 arg1 = reinterpret_cast< wxRect * >(argp1);
7705 arg2 = obj1;
7706 {
7707 result = (bool)wxRect___eq__(arg1,arg2);
7708 if (PyErr_Occurred()) SWIG_fail;
7709 }
7710 {
7711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7712 }
7713 return resultobj;
7714 fail:
7715 return NULL;
7716 }
7717
7718
7719 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7720 PyObject *resultobj = 0;
7721 wxRect *arg1 = (wxRect *) 0 ;
7722 PyObject *arg2 = (PyObject *) 0 ;
7723 bool result;
7724 void *argp1 = 0 ;
7725 int res1 = 0 ;
7726 PyObject * obj0 = 0 ;
7727 PyObject * obj1 = 0 ;
7728 char * kwnames[] = {
7729 (char *) "self",(char *) "other", NULL
7730 };
7731
7732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7734 if (!SWIG_IsOK(res1)) {
7735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7736 }
7737 arg1 = reinterpret_cast< wxRect * >(argp1);
7738 arg2 = obj1;
7739 {
7740 result = (bool)wxRect___ne__(arg1,arg2);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 {
7744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7745 }
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7753 PyObject *resultobj = 0;
7754 wxRect *arg1 = (wxRect *) 0 ;
7755 int arg2 ;
7756 int arg3 ;
7757 bool result;
7758 void *argp1 = 0 ;
7759 int res1 = 0 ;
7760 int val2 ;
7761 int ecode2 = 0 ;
7762 int val3 ;
7763 int ecode3 = 0 ;
7764 PyObject * obj0 = 0 ;
7765 PyObject * obj1 = 0 ;
7766 PyObject * obj2 = 0 ;
7767 char * kwnames[] = {
7768 (char *) "self",(char *) "x",(char *) "y", NULL
7769 };
7770
7771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7773 if (!SWIG_IsOK(res1)) {
7774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7775 }
7776 arg1 = reinterpret_cast< wxRect * >(argp1);
7777 ecode2 = SWIG_AsVal_int(obj1, &val2);
7778 if (!SWIG_IsOK(ecode2)) {
7779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7780 }
7781 arg2 = static_cast< int >(val2);
7782 ecode3 = SWIG_AsVal_int(obj2, &val3);
7783 if (!SWIG_IsOK(ecode3)) {
7784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7785 }
7786 arg3 = static_cast< int >(val3);
7787 {
7788 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7789 if (PyErr_Occurred()) SWIG_fail;
7790 }
7791 {
7792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7793 }
7794 return resultobj;
7795 fail:
7796 return NULL;
7797 }
7798
7799
7800 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7801 PyObject *resultobj = 0;
7802 wxRect *arg1 = (wxRect *) 0 ;
7803 wxPoint *arg2 = 0 ;
7804 bool result;
7805 void *argp1 = 0 ;
7806 int res1 = 0 ;
7807 wxPoint temp2 ;
7808 PyObject * obj0 = 0 ;
7809 PyObject * obj1 = 0 ;
7810 char * kwnames[] = {
7811 (char *) "self",(char *) "pt", NULL
7812 };
7813
7814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7816 if (!SWIG_IsOK(res1)) {
7817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7818 }
7819 arg1 = reinterpret_cast< wxRect * >(argp1);
7820 {
7821 arg2 = &temp2;
7822 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7823 }
7824 {
7825 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7826 if (PyErr_Occurred()) SWIG_fail;
7827 }
7828 {
7829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7830 }
7831 return resultobj;
7832 fail:
7833 return NULL;
7834 }
7835
7836
7837 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7838 PyObject *resultobj = 0;
7839 wxRect *arg1 = (wxRect *) 0 ;
7840 wxRect *arg2 = 0 ;
7841 bool result;
7842 void *argp1 = 0 ;
7843 int res1 = 0 ;
7844 wxRect temp2 ;
7845 PyObject * obj0 = 0 ;
7846 PyObject * obj1 = 0 ;
7847 char * kwnames[] = {
7848 (char *) "self",(char *) "rect", NULL
7849 };
7850
7851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7853 if (!SWIG_IsOK(res1)) {
7854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7855 }
7856 arg1 = reinterpret_cast< wxRect * >(argp1);
7857 {
7858 arg2 = &temp2;
7859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7860 }
7861 {
7862 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7863 if (PyErr_Occurred()) SWIG_fail;
7864 }
7865 {
7866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7867 }
7868 return resultobj;
7869 fail:
7870 return NULL;
7871 }
7872
7873
7874 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7875 PyObject *resultobj = 0;
7876 wxRect *arg1 = (wxRect *) 0 ;
7877 wxRect *arg2 = 0 ;
7878 bool result;
7879 void *argp1 = 0 ;
7880 int res1 = 0 ;
7881 wxRect temp2 ;
7882 PyObject * obj0 = 0 ;
7883 PyObject * obj1 = 0 ;
7884 char * kwnames[] = {
7885 (char *) "self",(char *) "rect", NULL
7886 };
7887
7888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7890 if (!SWIG_IsOK(res1)) {
7891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7892 }
7893 arg1 = reinterpret_cast< wxRect * >(argp1);
7894 {
7895 arg2 = &temp2;
7896 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7897 }
7898 {
7899 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7900 if (PyErr_Occurred()) SWIG_fail;
7901 }
7902 {
7903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7904 }
7905 return resultobj;
7906 fail:
7907 return NULL;
7908 }
7909
7910
7911 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7912 PyObject *resultobj = 0;
7913 wxRect *arg1 = (wxRect *) 0 ;
7914 wxRect *arg2 = 0 ;
7915 int arg3 = (int) wxBOTH ;
7916 wxRect result;
7917 void *argp1 = 0 ;
7918 int res1 = 0 ;
7919 wxRect temp2 ;
7920 int val3 ;
7921 int ecode3 = 0 ;
7922 PyObject * obj0 = 0 ;
7923 PyObject * obj1 = 0 ;
7924 PyObject * obj2 = 0 ;
7925 char * kwnames[] = {
7926 (char *) "self",(char *) "r",(char *) "dir", NULL
7927 };
7928
7929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7931 if (!SWIG_IsOK(res1)) {
7932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7933 }
7934 arg1 = reinterpret_cast< wxRect * >(argp1);
7935 {
7936 arg2 = &temp2;
7937 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7938 }
7939 if (obj2) {
7940 ecode3 = SWIG_AsVal_int(obj2, &val3);
7941 if (!SWIG_IsOK(ecode3)) {
7942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7943 }
7944 arg3 = static_cast< int >(val3);
7945 }
7946 {
7947 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7948 if (PyErr_Occurred()) SWIG_fail;
7949 }
7950 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7951 return resultobj;
7952 fail:
7953 return NULL;
7954 }
7955
7956
7957 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7958 PyObject *resultobj = 0;
7959 wxRect *arg1 = (wxRect *) 0 ;
7960 int arg2 ;
7961 void *argp1 = 0 ;
7962 int res1 = 0 ;
7963 int val2 ;
7964 int ecode2 = 0 ;
7965 PyObject *swig_obj[2] ;
7966
7967 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7969 if (!SWIG_IsOK(res1)) {
7970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7971 }
7972 arg1 = reinterpret_cast< wxRect * >(argp1);
7973 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7974 if (!SWIG_IsOK(ecode2)) {
7975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7976 }
7977 arg2 = static_cast< int >(val2);
7978 if (arg1) (arg1)->x = arg2;
7979
7980 resultobj = SWIG_Py_Void();
7981 return resultobj;
7982 fail:
7983 return NULL;
7984 }
7985
7986
7987 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7988 PyObject *resultobj = 0;
7989 wxRect *arg1 = (wxRect *) 0 ;
7990 int result;
7991 void *argp1 = 0 ;
7992 int res1 = 0 ;
7993 PyObject *swig_obj[1] ;
7994
7995 if (!args) SWIG_fail;
7996 swig_obj[0] = args;
7997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7998 if (!SWIG_IsOK(res1)) {
7999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
8000 }
8001 arg1 = reinterpret_cast< wxRect * >(argp1);
8002 result = (int) ((arg1)->x);
8003 resultobj = SWIG_From_int(static_cast< int >(result));
8004 return resultobj;
8005 fail:
8006 return NULL;
8007 }
8008
8009
8010 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8011 PyObject *resultobj = 0;
8012 wxRect *arg1 = (wxRect *) 0 ;
8013 int arg2 ;
8014 void *argp1 = 0 ;
8015 int res1 = 0 ;
8016 int val2 ;
8017 int ecode2 = 0 ;
8018 PyObject *swig_obj[2] ;
8019
8020 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
8021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8022 if (!SWIG_IsOK(res1)) {
8023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
8024 }
8025 arg1 = reinterpret_cast< wxRect * >(argp1);
8026 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8027 if (!SWIG_IsOK(ecode2)) {
8028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
8029 }
8030 arg2 = static_cast< int >(val2);
8031 if (arg1) (arg1)->y = arg2;
8032
8033 resultobj = SWIG_Py_Void();
8034 return resultobj;
8035 fail:
8036 return NULL;
8037 }
8038
8039
8040 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8041 PyObject *resultobj = 0;
8042 wxRect *arg1 = (wxRect *) 0 ;
8043 int result;
8044 void *argp1 = 0 ;
8045 int res1 = 0 ;
8046 PyObject *swig_obj[1] ;
8047
8048 if (!args) SWIG_fail;
8049 swig_obj[0] = args;
8050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8051 if (!SWIG_IsOK(res1)) {
8052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
8053 }
8054 arg1 = reinterpret_cast< wxRect * >(argp1);
8055 result = (int) ((arg1)->y);
8056 resultobj = SWIG_From_int(static_cast< int >(result));
8057 return resultobj;
8058 fail:
8059 return NULL;
8060 }
8061
8062
8063 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8064 PyObject *resultobj = 0;
8065 wxRect *arg1 = (wxRect *) 0 ;
8066 int arg2 ;
8067 void *argp1 = 0 ;
8068 int res1 = 0 ;
8069 int val2 ;
8070 int ecode2 = 0 ;
8071 PyObject *swig_obj[2] ;
8072
8073 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
8074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8075 if (!SWIG_IsOK(res1)) {
8076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
8077 }
8078 arg1 = reinterpret_cast< wxRect * >(argp1);
8079 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8080 if (!SWIG_IsOK(ecode2)) {
8081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
8082 }
8083 arg2 = static_cast< int >(val2);
8084 if (arg1) (arg1)->width = arg2;
8085
8086 resultobj = SWIG_Py_Void();
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8094 PyObject *resultobj = 0;
8095 wxRect *arg1 = (wxRect *) 0 ;
8096 int result;
8097 void *argp1 = 0 ;
8098 int res1 = 0 ;
8099 PyObject *swig_obj[1] ;
8100
8101 if (!args) SWIG_fail;
8102 swig_obj[0] = args;
8103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8104 if (!SWIG_IsOK(res1)) {
8105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8106 }
8107 arg1 = reinterpret_cast< wxRect * >(argp1);
8108 result = (int) ((arg1)->width);
8109 resultobj = SWIG_From_int(static_cast< int >(result));
8110 return resultobj;
8111 fail:
8112 return NULL;
8113 }
8114
8115
8116 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8117 PyObject *resultobj = 0;
8118 wxRect *arg1 = (wxRect *) 0 ;
8119 int arg2 ;
8120 void *argp1 = 0 ;
8121 int res1 = 0 ;
8122 int val2 ;
8123 int ecode2 = 0 ;
8124 PyObject *swig_obj[2] ;
8125
8126 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8128 if (!SWIG_IsOK(res1)) {
8129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8130 }
8131 arg1 = reinterpret_cast< wxRect * >(argp1);
8132 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8133 if (!SWIG_IsOK(ecode2)) {
8134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8135 }
8136 arg2 = static_cast< int >(val2);
8137 if (arg1) (arg1)->height = arg2;
8138
8139 resultobj = SWIG_Py_Void();
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8147 PyObject *resultobj = 0;
8148 wxRect *arg1 = (wxRect *) 0 ;
8149 int result;
8150 void *argp1 = 0 ;
8151 int res1 = 0 ;
8152 PyObject *swig_obj[1] ;
8153
8154 if (!args) SWIG_fail;
8155 swig_obj[0] = args;
8156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8157 if (!SWIG_IsOK(res1)) {
8158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8159 }
8160 arg1 = reinterpret_cast< wxRect * >(argp1);
8161 result = (int) ((arg1)->height);
8162 resultobj = SWIG_From_int(static_cast< int >(result));
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8170 PyObject *resultobj = 0;
8171 wxRect *arg1 = (wxRect *) 0 ;
8172 int arg2 = (int) 0 ;
8173 int arg3 = (int) 0 ;
8174 int arg4 = (int) 0 ;
8175 int arg5 = (int) 0 ;
8176 void *argp1 = 0 ;
8177 int res1 = 0 ;
8178 int val2 ;
8179 int ecode2 = 0 ;
8180 int val3 ;
8181 int ecode3 = 0 ;
8182 int val4 ;
8183 int ecode4 = 0 ;
8184 int val5 ;
8185 int ecode5 = 0 ;
8186 PyObject * obj0 = 0 ;
8187 PyObject * obj1 = 0 ;
8188 PyObject * obj2 = 0 ;
8189 PyObject * obj3 = 0 ;
8190 PyObject * obj4 = 0 ;
8191 char * kwnames[] = {
8192 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8193 };
8194
8195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8197 if (!SWIG_IsOK(res1)) {
8198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8199 }
8200 arg1 = reinterpret_cast< wxRect * >(argp1);
8201 if (obj1) {
8202 ecode2 = SWIG_AsVal_int(obj1, &val2);
8203 if (!SWIG_IsOK(ecode2)) {
8204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8205 }
8206 arg2 = static_cast< int >(val2);
8207 }
8208 if (obj2) {
8209 ecode3 = SWIG_AsVal_int(obj2, &val3);
8210 if (!SWIG_IsOK(ecode3)) {
8211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8212 }
8213 arg3 = static_cast< int >(val3);
8214 }
8215 if (obj3) {
8216 ecode4 = SWIG_AsVal_int(obj3, &val4);
8217 if (!SWIG_IsOK(ecode4)) {
8218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8219 }
8220 arg4 = static_cast< int >(val4);
8221 }
8222 if (obj4) {
8223 ecode5 = SWIG_AsVal_int(obj4, &val5);
8224 if (!SWIG_IsOK(ecode5)) {
8225 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8226 }
8227 arg5 = static_cast< int >(val5);
8228 }
8229 {
8230 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 resultobj = SWIG_Py_Void();
8234 return resultobj;
8235 fail:
8236 return NULL;
8237 }
8238
8239
8240 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8241 PyObject *resultobj = 0;
8242 wxRect *arg1 = (wxRect *) 0 ;
8243 PyObject *result = 0 ;
8244 void *argp1 = 0 ;
8245 int res1 = 0 ;
8246 PyObject *swig_obj[1] ;
8247
8248 if (!args) SWIG_fail;
8249 swig_obj[0] = args;
8250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8251 if (!SWIG_IsOK(res1)) {
8252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8253 }
8254 arg1 = reinterpret_cast< wxRect * >(argp1);
8255 {
8256 result = (PyObject *)wxRect_Get(arg1);
8257 if (PyErr_Occurred()) SWIG_fail;
8258 }
8259 resultobj = result;
8260 return resultobj;
8261 fail:
8262 return NULL;
8263 }
8264
8265
8266 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8267 PyObject *obj;
8268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8269 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8270 return SWIG_Py_Void();
8271 }
8272
8273 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8274 return SWIG_Python_InitShadowInstance(args);
8275 }
8276
8277 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8278 PyObject *resultobj = 0;
8279 wxRect *arg1 = (wxRect *) 0 ;
8280 wxRect *arg2 = (wxRect *) 0 ;
8281 PyObject *result = 0 ;
8282 void *argp1 = 0 ;
8283 int res1 = 0 ;
8284 void *argp2 = 0 ;
8285 int res2 = 0 ;
8286 PyObject * obj0 = 0 ;
8287 PyObject * obj1 = 0 ;
8288 char * kwnames[] = {
8289 (char *) "r1",(char *) "r2", NULL
8290 };
8291
8292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8294 if (!SWIG_IsOK(res1)) {
8295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8296 }
8297 arg1 = reinterpret_cast< wxRect * >(argp1);
8298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8299 if (!SWIG_IsOK(res2)) {
8300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8301 }
8302 arg2 = reinterpret_cast< wxRect * >(argp2);
8303 {
8304 if (!wxPyCheckForApp()) SWIG_fail;
8305 PyThreadState* __tstate = wxPyBeginAllowThreads();
8306 result = (PyObject *)wxIntersectRect(arg1,arg2);
8307 wxPyEndAllowThreads(__tstate);
8308 if (PyErr_Occurred()) SWIG_fail;
8309 }
8310 resultobj = result;
8311 return resultobj;
8312 fail:
8313 return NULL;
8314 }
8315
8316
8317 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8318 PyObject *resultobj = 0;
8319 double arg1 = (double) 0.0 ;
8320 double arg2 = (double) 0.0 ;
8321 wxPoint2D *result = 0 ;
8322 double val1 ;
8323 int ecode1 = 0 ;
8324 double val2 ;
8325 int ecode2 = 0 ;
8326 PyObject * obj0 = 0 ;
8327 PyObject * obj1 = 0 ;
8328 char * kwnames[] = {
8329 (char *) "x",(char *) "y", NULL
8330 };
8331
8332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8333 if (obj0) {
8334 ecode1 = SWIG_AsVal_double(obj0, &val1);
8335 if (!SWIG_IsOK(ecode1)) {
8336 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8337 }
8338 arg1 = static_cast< double >(val1);
8339 }
8340 if (obj1) {
8341 ecode2 = SWIG_AsVal_double(obj1, &val2);
8342 if (!SWIG_IsOK(ecode2)) {
8343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8344 }
8345 arg2 = static_cast< double >(val2);
8346 }
8347 {
8348 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8349 if (PyErr_Occurred()) SWIG_fail;
8350 }
8351 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8352 return resultobj;
8353 fail:
8354 return NULL;
8355 }
8356
8357
8358 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8359 PyObject *resultobj = 0;
8360 wxPoint2D *arg1 = 0 ;
8361 wxPoint2D *result = 0 ;
8362 wxPoint2D temp1 ;
8363 PyObject * obj0 = 0 ;
8364 char * kwnames[] = {
8365 (char *) "pt", NULL
8366 };
8367
8368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8369 {
8370 arg1 = &temp1;
8371 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8372 }
8373 {
8374 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8375 if (PyErr_Occurred()) SWIG_fail;
8376 }
8377 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8378 return resultobj;
8379 fail:
8380 return NULL;
8381 }
8382
8383
8384 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8385 PyObject *resultobj = 0;
8386 wxPoint *arg1 = 0 ;
8387 wxPoint2D *result = 0 ;
8388 wxPoint temp1 ;
8389 PyObject * obj0 = 0 ;
8390 char * kwnames[] = {
8391 (char *) "pt", NULL
8392 };
8393
8394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8395 {
8396 arg1 = &temp1;
8397 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8398 }
8399 {
8400 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8401 if (PyErr_Occurred()) SWIG_fail;
8402 }
8403 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8404 return resultobj;
8405 fail:
8406 return NULL;
8407 }
8408
8409
8410 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8411 PyObject *resultobj = 0;
8412 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8413 void *argp1 = 0 ;
8414 int res1 = 0 ;
8415 PyObject *swig_obj[1] ;
8416
8417 if (!args) SWIG_fail;
8418 swig_obj[0] = args;
8419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8420 if (!SWIG_IsOK(res1)) {
8421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8422 }
8423 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8424 {
8425 delete arg1;
8426
8427 if (PyErr_Occurred()) SWIG_fail;
8428 }
8429 resultobj = SWIG_Py_Void();
8430 return resultobj;
8431 fail:
8432 return NULL;
8433 }
8434
8435
8436 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8437 PyObject *resultobj = 0;
8438 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8439 int *arg2 = (int *) 0 ;
8440 int *arg3 = (int *) 0 ;
8441 void *argp1 = 0 ;
8442 int res1 = 0 ;
8443 int temp2 ;
8444 int res2 = SWIG_TMPOBJ ;
8445 int temp3 ;
8446 int res3 = SWIG_TMPOBJ ;
8447 PyObject *swig_obj[1] ;
8448
8449 arg2 = &temp2;
8450 arg3 = &temp3;
8451 if (!args) SWIG_fail;
8452 swig_obj[0] = args;
8453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8454 if (!SWIG_IsOK(res1)) {
8455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8456 }
8457 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8458 {
8459 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8460 if (PyErr_Occurred()) SWIG_fail;
8461 }
8462 resultobj = SWIG_Py_Void();
8463 if (SWIG_IsTmpObj(res2)) {
8464 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8465 } else {
8466 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8467 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8468 }
8469 if (SWIG_IsTmpObj(res3)) {
8470 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8471 } else {
8472 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8473 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8474 }
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8482 PyObject *resultobj = 0;
8483 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8484 int *arg2 = (int *) 0 ;
8485 int *arg3 = (int *) 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 int temp2 ;
8489 int res2 = SWIG_TMPOBJ ;
8490 int temp3 ;
8491 int res3 = SWIG_TMPOBJ ;
8492 PyObject *swig_obj[1] ;
8493
8494 arg2 = &temp2;
8495 arg3 = &temp3;
8496 if (!args) SWIG_fail;
8497 swig_obj[0] = args;
8498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8499 if (!SWIG_IsOK(res1)) {
8500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8501 }
8502 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8503 {
8504 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8505 if (PyErr_Occurred()) SWIG_fail;
8506 }
8507 resultobj = SWIG_Py_Void();
8508 if (SWIG_IsTmpObj(res2)) {
8509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8510 } else {
8511 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8513 }
8514 if (SWIG_IsTmpObj(res3)) {
8515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8516 } else {
8517 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8519 }
8520 return resultobj;
8521 fail:
8522 return NULL;
8523 }
8524
8525
8526 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8527 PyObject *resultobj = 0;
8528 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8529 double result;
8530 void *argp1 = 0 ;
8531 int res1 = 0 ;
8532 PyObject *swig_obj[1] ;
8533
8534 if (!args) SWIG_fail;
8535 swig_obj[0] = args;
8536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8537 if (!SWIG_IsOK(res1)) {
8538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8539 }
8540 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8541 {
8542 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8543 if (PyErr_Occurred()) SWIG_fail;
8544 }
8545 resultobj = SWIG_From_double(static_cast< double >(result));
8546 return resultobj;
8547 fail:
8548 return NULL;
8549 }
8550
8551
8552 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8553 PyObject *resultobj = 0;
8554 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8555 double result;
8556 void *argp1 = 0 ;
8557 int res1 = 0 ;
8558 PyObject *swig_obj[1] ;
8559
8560 if (!args) SWIG_fail;
8561 swig_obj[0] = args;
8562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8563 if (!SWIG_IsOK(res1)) {
8564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8565 }
8566 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8567 {
8568 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8569 if (PyErr_Occurred()) SWIG_fail;
8570 }
8571 resultobj = SWIG_From_double(static_cast< double >(result));
8572 return resultobj;
8573 fail:
8574 return NULL;
8575 }
8576
8577
8578 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8579 PyObject *resultobj = 0;
8580 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8581 double arg2 ;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 double val2 ;
8585 int ecode2 = 0 ;
8586 PyObject * obj0 = 0 ;
8587 PyObject * obj1 = 0 ;
8588 char * kwnames[] = {
8589 (char *) "self",(char *) "length", NULL
8590 };
8591
8592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8594 if (!SWIG_IsOK(res1)) {
8595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8596 }
8597 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8598 ecode2 = SWIG_AsVal_double(obj1, &val2);
8599 if (!SWIG_IsOK(ecode2)) {
8600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8601 }
8602 arg2 = static_cast< double >(val2);
8603 {
8604 (arg1)->SetVectorLength(arg2);
8605 if (PyErr_Occurred()) SWIG_fail;
8606 }
8607 resultobj = SWIG_Py_Void();
8608 return resultobj;
8609 fail:
8610 return NULL;
8611 }
8612
8613
8614 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8615 PyObject *resultobj = 0;
8616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8617 double arg2 ;
8618 void *argp1 = 0 ;
8619 int res1 = 0 ;
8620 double val2 ;
8621 int ecode2 = 0 ;
8622 PyObject * obj0 = 0 ;
8623 PyObject * obj1 = 0 ;
8624 char * kwnames[] = {
8625 (char *) "self",(char *) "degrees", NULL
8626 };
8627
8628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8630 if (!SWIG_IsOK(res1)) {
8631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8632 }
8633 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8634 ecode2 = SWIG_AsVal_double(obj1, &val2);
8635 if (!SWIG_IsOK(ecode2)) {
8636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8637 }
8638 arg2 = static_cast< double >(val2);
8639 {
8640 (arg1)->SetVectorAngle(arg2);
8641 if (PyErr_Occurred()) SWIG_fail;
8642 }
8643 resultobj = SWIG_Py_Void();
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8653 wxPoint2D *arg2 = 0 ;
8654 double result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 wxPoint2D temp2 ;
8658 PyObject * obj0 = 0 ;
8659 PyObject * obj1 = 0 ;
8660 char * kwnames[] = {
8661 (char *) "self",(char *) "pt", NULL
8662 };
8663
8664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8666 if (!SWIG_IsOK(res1)) {
8667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8668 }
8669 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8670 {
8671 arg2 = &temp2;
8672 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8673 }
8674 {
8675 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8676 if (PyErr_Occurred()) SWIG_fail;
8677 }
8678 resultobj = SWIG_From_double(static_cast< double >(result));
8679 return resultobj;
8680 fail:
8681 return NULL;
8682 }
8683
8684
8685 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8686 PyObject *resultobj = 0;
8687 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8688 wxPoint2D *arg2 = 0 ;
8689 double result;
8690 void *argp1 = 0 ;
8691 int res1 = 0 ;
8692 wxPoint2D temp2 ;
8693 PyObject * obj0 = 0 ;
8694 PyObject * obj1 = 0 ;
8695 char * kwnames[] = {
8696 (char *) "self",(char *) "pt", NULL
8697 };
8698
8699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8701 if (!SWIG_IsOK(res1)) {
8702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8703 }
8704 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8705 {
8706 arg2 = &temp2;
8707 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8708 }
8709 {
8710 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8711 if (PyErr_Occurred()) SWIG_fail;
8712 }
8713 resultobj = SWIG_From_double(static_cast< double >(result));
8714 return resultobj;
8715 fail:
8716 return NULL;
8717 }
8718
8719
8720 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8721 PyObject *resultobj = 0;
8722 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8723 wxPoint2D *arg2 = 0 ;
8724 double result;
8725 void *argp1 = 0 ;
8726 int res1 = 0 ;
8727 wxPoint2D temp2 ;
8728 PyObject * obj0 = 0 ;
8729 PyObject * obj1 = 0 ;
8730 char * kwnames[] = {
8731 (char *) "self",(char *) "vec", NULL
8732 };
8733
8734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8736 if (!SWIG_IsOK(res1)) {
8737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8738 }
8739 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8740 {
8741 arg2 = &temp2;
8742 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8743 }
8744 {
8745 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8746 if (PyErr_Occurred()) SWIG_fail;
8747 }
8748 resultobj = SWIG_From_double(static_cast< double >(result));
8749 return resultobj;
8750 fail:
8751 return NULL;
8752 }
8753
8754
8755 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8756 PyObject *resultobj = 0;
8757 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8758 wxPoint2D *arg2 = 0 ;
8759 double result;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 wxPoint2D temp2 ;
8763 PyObject * obj0 = 0 ;
8764 PyObject * obj1 = 0 ;
8765 char * kwnames[] = {
8766 (char *) "self",(char *) "vec", NULL
8767 };
8768
8769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8771 if (!SWIG_IsOK(res1)) {
8772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8773 }
8774 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8775 {
8776 arg2 = &temp2;
8777 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8778 }
8779 {
8780 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8781 if (PyErr_Occurred()) SWIG_fail;
8782 }
8783 resultobj = SWIG_From_double(static_cast< double >(result));
8784 return resultobj;
8785 fail:
8786 return NULL;
8787 }
8788
8789
8790 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8791 PyObject *resultobj = 0;
8792 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8793 wxPoint2D result;
8794 void *argp1 = 0 ;
8795 int res1 = 0 ;
8796 PyObject *swig_obj[1] ;
8797
8798 if (!args) SWIG_fail;
8799 swig_obj[0] = args;
8800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8801 if (!SWIG_IsOK(res1)) {
8802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8803 }
8804 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8805 {
8806 result = (arg1)->operator -();
8807 if (PyErr_Occurred()) SWIG_fail;
8808 }
8809 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8810 return resultobj;
8811 fail:
8812 return NULL;
8813 }
8814
8815
8816 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8817 PyObject *resultobj = 0;
8818 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8819 wxPoint2D *arg2 = 0 ;
8820 wxPoint2D *result = 0 ;
8821 void *argp1 = 0 ;
8822 int res1 = 0 ;
8823 wxPoint2D temp2 ;
8824 PyObject * obj0 = 0 ;
8825 PyObject * obj1 = 0 ;
8826 char * kwnames[] = {
8827 (char *) "self",(char *) "pt", NULL
8828 };
8829
8830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8832 if (!SWIG_IsOK(res1)) {
8833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8834 }
8835 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8836 {
8837 arg2 = &temp2;
8838 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8839 }
8840 {
8841 {
8842 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8843 result = (wxPoint2D *) &_result_ref;
8844 }
8845 if (PyErr_Occurred()) SWIG_fail;
8846 }
8847 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8848 return resultobj;
8849 fail:
8850 return NULL;
8851 }
8852
8853
8854 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8855 PyObject *resultobj = 0;
8856 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8857 wxPoint2D *arg2 = 0 ;
8858 wxPoint2D *result = 0 ;
8859 void *argp1 = 0 ;
8860 int res1 = 0 ;
8861 wxPoint2D temp2 ;
8862 PyObject * obj0 = 0 ;
8863 PyObject * obj1 = 0 ;
8864 char * kwnames[] = {
8865 (char *) "self",(char *) "pt", NULL
8866 };
8867
8868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8870 if (!SWIG_IsOK(res1)) {
8871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8872 }
8873 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8874 {
8875 arg2 = &temp2;
8876 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8877 }
8878 {
8879 {
8880 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8881 result = (wxPoint2D *) &_result_ref;
8882 }
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8886 return resultobj;
8887 fail:
8888 return NULL;
8889 }
8890
8891
8892 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8893 PyObject *resultobj = 0;
8894 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8895 wxPoint2D *arg2 = 0 ;
8896 wxPoint2D *result = 0 ;
8897 void *argp1 = 0 ;
8898 int res1 = 0 ;
8899 wxPoint2D temp2 ;
8900 PyObject * obj0 = 0 ;
8901 PyObject * obj1 = 0 ;
8902 char * kwnames[] = {
8903 (char *) "self",(char *) "pt", NULL
8904 };
8905
8906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8908 if (!SWIG_IsOK(res1)) {
8909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8910 }
8911 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8912 {
8913 arg2 = &temp2;
8914 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8915 }
8916 {
8917 {
8918 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8919 result = (wxPoint2D *) &_result_ref;
8920 }
8921 if (PyErr_Occurred()) SWIG_fail;
8922 }
8923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8924 return resultobj;
8925 fail:
8926 return NULL;
8927 }
8928
8929
8930 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8931 PyObject *resultobj = 0;
8932 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8933 wxPoint2D *arg2 = 0 ;
8934 wxPoint2D *result = 0 ;
8935 void *argp1 = 0 ;
8936 int res1 = 0 ;
8937 wxPoint2D temp2 ;
8938 PyObject * obj0 = 0 ;
8939 PyObject * obj1 = 0 ;
8940 char * kwnames[] = {
8941 (char *) "self",(char *) "pt", NULL
8942 };
8943
8944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8946 if (!SWIG_IsOK(res1)) {
8947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8948 }
8949 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8950 {
8951 arg2 = &temp2;
8952 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8953 }
8954 {
8955 {
8956 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8957 result = (wxPoint2D *) &_result_ref;
8958 }
8959 if (PyErr_Occurred()) SWIG_fail;
8960 }
8961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8962 return resultobj;
8963 fail:
8964 return NULL;
8965 }
8966
8967
8968 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8969 PyObject *resultobj = 0;
8970 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8971 PyObject *arg2 = (PyObject *) 0 ;
8972 bool result;
8973 void *argp1 = 0 ;
8974 int res1 = 0 ;
8975 PyObject * obj0 = 0 ;
8976 PyObject * obj1 = 0 ;
8977 char * kwnames[] = {
8978 (char *) "self",(char *) "other", NULL
8979 };
8980
8981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8983 if (!SWIG_IsOK(res1)) {
8984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8985 }
8986 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8987 arg2 = obj1;
8988 {
8989 result = (bool)wxPoint2D___eq__(arg1,arg2);
8990 if (PyErr_Occurred()) SWIG_fail;
8991 }
8992 {
8993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8994 }
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj = 0;
9003 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9004 PyObject *arg2 = (PyObject *) 0 ;
9005 bool result;
9006 void *argp1 = 0 ;
9007 int res1 = 0 ;
9008 PyObject * obj0 = 0 ;
9009 PyObject * obj1 = 0 ;
9010 char * kwnames[] = {
9011 (char *) "self",(char *) "other", NULL
9012 };
9013
9014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
9015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9016 if (!SWIG_IsOK(res1)) {
9017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9018 }
9019 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9020 arg2 = obj1;
9021 {
9022 result = (bool)wxPoint2D___ne__(arg1,arg2);
9023 if (PyErr_Occurred()) SWIG_fail;
9024 }
9025 {
9026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9027 }
9028 return resultobj;
9029 fail:
9030 return NULL;
9031 }
9032
9033
9034 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9035 PyObject *resultobj = 0;
9036 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9037 double arg2 ;
9038 void *argp1 = 0 ;
9039 int res1 = 0 ;
9040 double val2 ;
9041 int ecode2 = 0 ;
9042 PyObject *swig_obj[2] ;
9043
9044 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
9045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9046 if (!SWIG_IsOK(res1)) {
9047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9048 }
9049 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9050 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9051 if (!SWIG_IsOK(ecode2)) {
9052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
9053 }
9054 arg2 = static_cast< double >(val2);
9055 if (arg1) (arg1)->m_x = arg2;
9056
9057 resultobj = SWIG_Py_Void();
9058 return resultobj;
9059 fail:
9060 return NULL;
9061 }
9062
9063
9064 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9065 PyObject *resultobj = 0;
9066 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9067 double result;
9068 void *argp1 = 0 ;
9069 int res1 = 0 ;
9070 PyObject *swig_obj[1] ;
9071
9072 if (!args) SWIG_fail;
9073 swig_obj[0] = args;
9074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9075 if (!SWIG_IsOK(res1)) {
9076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9077 }
9078 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9079 result = (double) ((arg1)->m_x);
9080 resultobj = SWIG_From_double(static_cast< double >(result));
9081 return resultobj;
9082 fail:
9083 return NULL;
9084 }
9085
9086
9087 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9088 PyObject *resultobj = 0;
9089 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9090 double arg2 ;
9091 void *argp1 = 0 ;
9092 int res1 = 0 ;
9093 double val2 ;
9094 int ecode2 = 0 ;
9095 PyObject *swig_obj[2] ;
9096
9097 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9099 if (!SWIG_IsOK(res1)) {
9100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9101 }
9102 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9103 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9104 if (!SWIG_IsOK(ecode2)) {
9105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9106 }
9107 arg2 = static_cast< double >(val2);
9108 if (arg1) (arg1)->m_y = arg2;
9109
9110 resultobj = SWIG_Py_Void();
9111 return resultobj;
9112 fail:
9113 return NULL;
9114 }
9115
9116
9117 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9118 PyObject *resultobj = 0;
9119 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9120 double result;
9121 void *argp1 = 0 ;
9122 int res1 = 0 ;
9123 PyObject *swig_obj[1] ;
9124
9125 if (!args) SWIG_fail;
9126 swig_obj[0] = args;
9127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9128 if (!SWIG_IsOK(res1)) {
9129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9130 }
9131 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9132 result = (double) ((arg1)->m_y);
9133 resultobj = SWIG_From_double(static_cast< double >(result));
9134 return resultobj;
9135 fail:
9136 return NULL;
9137 }
9138
9139
9140 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9141 PyObject *resultobj = 0;
9142 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9143 double arg2 = (double) 0 ;
9144 double arg3 = (double) 0 ;
9145 void *argp1 = 0 ;
9146 int res1 = 0 ;
9147 double val2 ;
9148 int ecode2 = 0 ;
9149 double val3 ;
9150 int ecode3 = 0 ;
9151 PyObject * obj0 = 0 ;
9152 PyObject * obj1 = 0 ;
9153 PyObject * obj2 = 0 ;
9154 char * kwnames[] = {
9155 (char *) "self",(char *) "x",(char *) "y", NULL
9156 };
9157
9158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9160 if (!SWIG_IsOK(res1)) {
9161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9162 }
9163 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9164 if (obj1) {
9165 ecode2 = SWIG_AsVal_double(obj1, &val2);
9166 if (!SWIG_IsOK(ecode2)) {
9167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9168 }
9169 arg2 = static_cast< double >(val2);
9170 }
9171 if (obj2) {
9172 ecode3 = SWIG_AsVal_double(obj2, &val3);
9173 if (!SWIG_IsOK(ecode3)) {
9174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9175 }
9176 arg3 = static_cast< double >(val3);
9177 }
9178 {
9179 wxPoint2D_Set(arg1,arg2,arg3);
9180 if (PyErr_Occurred()) SWIG_fail;
9181 }
9182 resultobj = SWIG_Py_Void();
9183 return resultobj;
9184 fail:
9185 return NULL;
9186 }
9187
9188
9189 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9190 PyObject *resultobj = 0;
9191 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9192 PyObject *result = 0 ;
9193 void *argp1 = 0 ;
9194 int res1 = 0 ;
9195 PyObject *swig_obj[1] ;
9196
9197 if (!args) SWIG_fail;
9198 swig_obj[0] = args;
9199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9200 if (!SWIG_IsOK(res1)) {
9201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9202 }
9203 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9204 {
9205 result = (PyObject *)wxPoint2D_Get(arg1);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = result;
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *obj;
9217 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9218 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9219 return SWIG_Py_Void();
9220 }
9221
9222 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9223 return SWIG_Python_InitShadowInstance(args);
9224 }
9225
9226 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9227 PyObject *resultobj = 0;
9228 wxDouble arg1 = (wxDouble) 0.0 ;
9229 wxDouble arg2 = (wxDouble) 0.0 ;
9230 wxDouble arg3 = (wxDouble) 0.0 ;
9231 wxDouble arg4 = (wxDouble) 0.0 ;
9232 wxRect2D *result = 0 ;
9233 void *argp1 ;
9234 int res1 = 0 ;
9235 void *argp2 ;
9236 int res2 = 0 ;
9237 void *argp3 ;
9238 int res3 = 0 ;
9239 void *argp4 ;
9240 int res4 = 0 ;
9241 PyObject * obj0 = 0 ;
9242 PyObject * obj1 = 0 ;
9243 PyObject * obj2 = 0 ;
9244 PyObject * obj3 = 0 ;
9245 char * kwnames[] = {
9246 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9247 };
9248
9249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9250 if (obj0) {
9251 {
9252 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9253 if (!SWIG_IsOK(res1)) {
9254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9255 }
9256 if (!argp1) {
9257 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9258 } else {
9259 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9260 arg1 = *temp;
9261 if (SWIG_IsNewObj(res1)) delete temp;
9262 }
9263 }
9264 }
9265 if (obj1) {
9266 {
9267 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9268 if (!SWIG_IsOK(res2)) {
9269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9270 }
9271 if (!argp2) {
9272 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9273 } else {
9274 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9275 arg2 = *temp;
9276 if (SWIG_IsNewObj(res2)) delete temp;
9277 }
9278 }
9279 }
9280 if (obj2) {
9281 {
9282 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9283 if (!SWIG_IsOK(res3)) {
9284 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9285 }
9286 if (!argp3) {
9287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9288 } else {
9289 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9290 arg3 = *temp;
9291 if (SWIG_IsNewObj(res3)) delete temp;
9292 }
9293 }
9294 }
9295 if (obj3) {
9296 {
9297 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9298 if (!SWIG_IsOK(res4)) {
9299 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9300 }
9301 if (!argp4) {
9302 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9303 } else {
9304 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9305 arg4 = *temp;
9306 if (SWIG_IsNewObj(res4)) delete temp;
9307 }
9308 }
9309 }
9310 {
9311 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9312 if (PyErr_Occurred()) SWIG_fail;
9313 }
9314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9315 return resultobj;
9316 fail:
9317 return NULL;
9318 }
9319
9320
9321 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9322 PyObject *resultobj = 0;
9323 wxRect2D *arg1 = (wxRect2D *) 0 ;
9324 void *argp1 = 0 ;
9325 int res1 = 0 ;
9326 PyObject *swig_obj[1] ;
9327
9328 if (!args) SWIG_fail;
9329 swig_obj[0] = args;
9330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9331 if (!SWIG_IsOK(res1)) {
9332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9333 }
9334 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9335 {
9336 delete arg1;
9337
9338 if (PyErr_Occurred()) SWIG_fail;
9339 }
9340 resultobj = SWIG_Py_Void();
9341 return resultobj;
9342 fail:
9343 return NULL;
9344 }
9345
9346
9347 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9348 PyObject *resultobj = 0;
9349 wxRect2D *arg1 = (wxRect2D *) 0 ;
9350 wxPoint2D result;
9351 void *argp1 = 0 ;
9352 int res1 = 0 ;
9353 PyObject *swig_obj[1] ;
9354
9355 if (!args) SWIG_fail;
9356 swig_obj[0] = args;
9357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9358 if (!SWIG_IsOK(res1)) {
9359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9360 }
9361 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9362 {
9363 result = (arg1)->GetPosition();
9364 if (PyErr_Occurred()) SWIG_fail;
9365 }
9366 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9367 return resultobj;
9368 fail:
9369 return NULL;
9370 }
9371
9372
9373 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9374 PyObject *resultobj = 0;
9375 wxRect2D *arg1 = (wxRect2D *) 0 ;
9376 wxSize result;
9377 void *argp1 = 0 ;
9378 int res1 = 0 ;
9379 PyObject *swig_obj[1] ;
9380
9381 if (!args) SWIG_fail;
9382 swig_obj[0] = args;
9383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9384 if (!SWIG_IsOK(res1)) {
9385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9386 }
9387 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9388 {
9389 result = (arg1)->GetSize();
9390 if (PyErr_Occurred()) SWIG_fail;
9391 }
9392 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9393 return resultobj;
9394 fail:
9395 return NULL;
9396 }
9397
9398
9399 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9400 PyObject *resultobj = 0;
9401 wxRect2D *arg1 = (wxRect2D *) 0 ;
9402 wxDouble result;
9403 void *argp1 = 0 ;
9404 int res1 = 0 ;
9405 PyObject *swig_obj[1] ;
9406
9407 if (!args) SWIG_fail;
9408 swig_obj[0] = args;
9409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9410 if (!SWIG_IsOK(res1)) {
9411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9412 }
9413 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9414 {
9415 result = ((wxRect2D const *)arg1)->GetLeft();
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9419 return resultobj;
9420 fail:
9421 return NULL;
9422 }
9423
9424
9425 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9426 PyObject *resultobj = 0;
9427 wxRect2D *arg1 = (wxRect2D *) 0 ;
9428 wxDouble arg2 ;
9429 void *argp1 = 0 ;
9430 int res1 = 0 ;
9431 void *argp2 ;
9432 int res2 = 0 ;
9433 PyObject * obj0 = 0 ;
9434 PyObject * obj1 = 0 ;
9435 char * kwnames[] = {
9436 (char *) "self",(char *) "n", NULL
9437 };
9438
9439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9441 if (!SWIG_IsOK(res1)) {
9442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9443 }
9444 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9445 {
9446 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9447 if (!SWIG_IsOK(res2)) {
9448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9449 }
9450 if (!argp2) {
9451 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9452 } else {
9453 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9454 arg2 = *temp;
9455 if (SWIG_IsNewObj(res2)) delete temp;
9456 }
9457 }
9458 {
9459 (arg1)->SetLeft(arg2);
9460 if (PyErr_Occurred()) SWIG_fail;
9461 }
9462 resultobj = SWIG_Py_Void();
9463 return resultobj;
9464 fail:
9465 return NULL;
9466 }
9467
9468
9469 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9470 PyObject *resultobj = 0;
9471 wxRect2D *arg1 = (wxRect2D *) 0 ;
9472 wxDouble arg2 ;
9473 void *argp1 = 0 ;
9474 int res1 = 0 ;
9475 void *argp2 ;
9476 int res2 = 0 ;
9477 PyObject * obj0 = 0 ;
9478 PyObject * obj1 = 0 ;
9479 char * kwnames[] = {
9480 (char *) "self",(char *) "n", NULL
9481 };
9482
9483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9485 if (!SWIG_IsOK(res1)) {
9486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9487 }
9488 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9489 {
9490 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9491 if (!SWIG_IsOK(res2)) {
9492 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9493 }
9494 if (!argp2) {
9495 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9496 } else {
9497 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9498 arg2 = *temp;
9499 if (SWIG_IsNewObj(res2)) delete temp;
9500 }
9501 }
9502 {
9503 (arg1)->MoveLeftTo(arg2);
9504 if (PyErr_Occurred()) SWIG_fail;
9505 }
9506 resultobj = SWIG_Py_Void();
9507 return resultobj;
9508 fail:
9509 return NULL;
9510 }
9511
9512
9513 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 PyObject *resultobj = 0;
9515 wxRect2D *arg1 = (wxRect2D *) 0 ;
9516 wxDouble result;
9517 void *argp1 = 0 ;
9518 int res1 = 0 ;
9519 PyObject *swig_obj[1] ;
9520
9521 if (!args) SWIG_fail;
9522 swig_obj[0] = args;
9523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9524 if (!SWIG_IsOK(res1)) {
9525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9526 }
9527 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9528 {
9529 result = ((wxRect2D const *)arg1)->GetTop();
9530 if (PyErr_Occurred()) SWIG_fail;
9531 }
9532 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9533 return resultobj;
9534 fail:
9535 return NULL;
9536 }
9537
9538
9539 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9540 PyObject *resultobj = 0;
9541 wxRect2D *arg1 = (wxRect2D *) 0 ;
9542 wxDouble arg2 ;
9543 void *argp1 = 0 ;
9544 int res1 = 0 ;
9545 void *argp2 ;
9546 int res2 = 0 ;
9547 PyObject * obj0 = 0 ;
9548 PyObject * obj1 = 0 ;
9549 char * kwnames[] = {
9550 (char *) "self",(char *) "n", NULL
9551 };
9552
9553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9555 if (!SWIG_IsOK(res1)) {
9556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9557 }
9558 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9559 {
9560 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9561 if (!SWIG_IsOK(res2)) {
9562 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9563 }
9564 if (!argp2) {
9565 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9566 } else {
9567 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9568 arg2 = *temp;
9569 if (SWIG_IsNewObj(res2)) delete temp;
9570 }
9571 }
9572 {
9573 (arg1)->SetTop(arg2);
9574 if (PyErr_Occurred()) SWIG_fail;
9575 }
9576 resultobj = SWIG_Py_Void();
9577 return resultobj;
9578 fail:
9579 return NULL;
9580 }
9581
9582
9583 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9584 PyObject *resultobj = 0;
9585 wxRect2D *arg1 = (wxRect2D *) 0 ;
9586 wxDouble arg2 ;
9587 void *argp1 = 0 ;
9588 int res1 = 0 ;
9589 void *argp2 ;
9590 int res2 = 0 ;
9591 PyObject * obj0 = 0 ;
9592 PyObject * obj1 = 0 ;
9593 char * kwnames[] = {
9594 (char *) "self",(char *) "n", NULL
9595 };
9596
9597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9599 if (!SWIG_IsOK(res1)) {
9600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9601 }
9602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9603 {
9604 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9605 if (!SWIG_IsOK(res2)) {
9606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9607 }
9608 if (!argp2) {
9609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9610 } else {
9611 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9612 arg2 = *temp;
9613 if (SWIG_IsNewObj(res2)) delete temp;
9614 }
9615 }
9616 {
9617 (arg1)->MoveTopTo(arg2);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 resultobj = SWIG_Py_Void();
9621 return resultobj;
9622 fail:
9623 return NULL;
9624 }
9625
9626
9627 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9628 PyObject *resultobj = 0;
9629 wxRect2D *arg1 = (wxRect2D *) 0 ;
9630 wxDouble result;
9631 void *argp1 = 0 ;
9632 int res1 = 0 ;
9633 PyObject *swig_obj[1] ;
9634
9635 if (!args) SWIG_fail;
9636 swig_obj[0] = args;
9637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9638 if (!SWIG_IsOK(res1)) {
9639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9640 }
9641 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9642 {
9643 result = ((wxRect2D const *)arg1)->GetBottom();
9644 if (PyErr_Occurred()) SWIG_fail;
9645 }
9646 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9647 return resultobj;
9648 fail:
9649 return NULL;
9650 }
9651
9652
9653 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9654 PyObject *resultobj = 0;
9655 wxRect2D *arg1 = (wxRect2D *) 0 ;
9656 wxDouble arg2 ;
9657 void *argp1 = 0 ;
9658 int res1 = 0 ;
9659 void *argp2 ;
9660 int res2 = 0 ;
9661 PyObject * obj0 = 0 ;
9662 PyObject * obj1 = 0 ;
9663 char * kwnames[] = {
9664 (char *) "self",(char *) "n", NULL
9665 };
9666
9667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9669 if (!SWIG_IsOK(res1)) {
9670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9671 }
9672 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9673 {
9674 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9675 if (!SWIG_IsOK(res2)) {
9676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9677 }
9678 if (!argp2) {
9679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9680 } else {
9681 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9682 arg2 = *temp;
9683 if (SWIG_IsNewObj(res2)) delete temp;
9684 }
9685 }
9686 {
9687 (arg1)->SetBottom(arg2);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 resultobj = SWIG_Py_Void();
9691 return resultobj;
9692 fail:
9693 return NULL;
9694 }
9695
9696
9697 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9698 PyObject *resultobj = 0;
9699 wxRect2D *arg1 = (wxRect2D *) 0 ;
9700 wxDouble arg2 ;
9701 void *argp1 = 0 ;
9702 int res1 = 0 ;
9703 void *argp2 ;
9704 int res2 = 0 ;
9705 PyObject * obj0 = 0 ;
9706 PyObject * obj1 = 0 ;
9707 char * kwnames[] = {
9708 (char *) "self",(char *) "n", NULL
9709 };
9710
9711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9713 if (!SWIG_IsOK(res1)) {
9714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9715 }
9716 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9717 {
9718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9719 if (!SWIG_IsOK(res2)) {
9720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9721 }
9722 if (!argp2) {
9723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9724 } else {
9725 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9726 arg2 = *temp;
9727 if (SWIG_IsNewObj(res2)) delete temp;
9728 }
9729 }
9730 {
9731 (arg1)->MoveBottomTo(arg2);
9732 if (PyErr_Occurred()) SWIG_fail;
9733 }
9734 resultobj = SWIG_Py_Void();
9735 return resultobj;
9736 fail:
9737 return NULL;
9738 }
9739
9740
9741 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9742 PyObject *resultobj = 0;
9743 wxRect2D *arg1 = (wxRect2D *) 0 ;
9744 wxDouble result;
9745 void *argp1 = 0 ;
9746 int res1 = 0 ;
9747 PyObject *swig_obj[1] ;
9748
9749 if (!args) SWIG_fail;
9750 swig_obj[0] = args;
9751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9752 if (!SWIG_IsOK(res1)) {
9753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9754 }
9755 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9756 {
9757 result = ((wxRect2D const *)arg1)->GetRight();
9758 if (PyErr_Occurred()) SWIG_fail;
9759 }
9760 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9761 return resultobj;
9762 fail:
9763 return NULL;
9764 }
9765
9766
9767 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9768 PyObject *resultobj = 0;
9769 wxRect2D *arg1 = (wxRect2D *) 0 ;
9770 wxDouble arg2 ;
9771 void *argp1 = 0 ;
9772 int res1 = 0 ;
9773 void *argp2 ;
9774 int res2 = 0 ;
9775 PyObject * obj0 = 0 ;
9776 PyObject * obj1 = 0 ;
9777 char * kwnames[] = {
9778 (char *) "self",(char *) "n", NULL
9779 };
9780
9781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9783 if (!SWIG_IsOK(res1)) {
9784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9785 }
9786 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9787 {
9788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9789 if (!SWIG_IsOK(res2)) {
9790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9791 }
9792 if (!argp2) {
9793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9794 } else {
9795 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9796 arg2 = *temp;
9797 if (SWIG_IsNewObj(res2)) delete temp;
9798 }
9799 }
9800 {
9801 (arg1)->SetRight(arg2);
9802 if (PyErr_Occurred()) SWIG_fail;
9803 }
9804 resultobj = SWIG_Py_Void();
9805 return resultobj;
9806 fail:
9807 return NULL;
9808 }
9809
9810
9811 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9812 PyObject *resultobj = 0;
9813 wxRect2D *arg1 = (wxRect2D *) 0 ;
9814 wxDouble arg2 ;
9815 void *argp1 = 0 ;
9816 int res1 = 0 ;
9817 void *argp2 ;
9818 int res2 = 0 ;
9819 PyObject * obj0 = 0 ;
9820 PyObject * obj1 = 0 ;
9821 char * kwnames[] = {
9822 (char *) "self",(char *) "n", NULL
9823 };
9824
9825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9827 if (!SWIG_IsOK(res1)) {
9828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9829 }
9830 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9831 {
9832 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9833 if (!SWIG_IsOK(res2)) {
9834 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9835 }
9836 if (!argp2) {
9837 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9838 } else {
9839 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9840 arg2 = *temp;
9841 if (SWIG_IsNewObj(res2)) delete temp;
9842 }
9843 }
9844 {
9845 (arg1)->MoveRightTo(arg2);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 resultobj = SWIG_Py_Void();
9849 return resultobj;
9850 fail:
9851 return NULL;
9852 }
9853
9854
9855 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9856 PyObject *resultobj = 0;
9857 wxRect2D *arg1 = (wxRect2D *) 0 ;
9858 wxPoint2D result;
9859 void *argp1 = 0 ;
9860 int res1 = 0 ;
9861 PyObject *swig_obj[1] ;
9862
9863 if (!args) SWIG_fail;
9864 swig_obj[0] = args;
9865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9866 if (!SWIG_IsOK(res1)) {
9867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9868 }
9869 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9870 {
9871 result = ((wxRect2D const *)arg1)->GetLeftTop();
9872 if (PyErr_Occurred()) SWIG_fail;
9873 }
9874 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9875 return resultobj;
9876 fail:
9877 return NULL;
9878 }
9879
9880
9881 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9882 PyObject *resultobj = 0;
9883 wxRect2D *arg1 = (wxRect2D *) 0 ;
9884 wxPoint2D *arg2 = 0 ;
9885 void *argp1 = 0 ;
9886 int res1 = 0 ;
9887 wxPoint2D temp2 ;
9888 PyObject * obj0 = 0 ;
9889 PyObject * obj1 = 0 ;
9890 char * kwnames[] = {
9891 (char *) "self",(char *) "pt", NULL
9892 };
9893
9894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9896 if (!SWIG_IsOK(res1)) {
9897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9898 }
9899 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9900 {
9901 arg2 = &temp2;
9902 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9903 }
9904 {
9905 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 resultobj = SWIG_Py_Void();
9909 return resultobj;
9910 fail:
9911 return NULL;
9912 }
9913
9914
9915 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9916 PyObject *resultobj = 0;
9917 wxRect2D *arg1 = (wxRect2D *) 0 ;
9918 wxPoint2D *arg2 = 0 ;
9919 void *argp1 = 0 ;
9920 int res1 = 0 ;
9921 wxPoint2D temp2 ;
9922 PyObject * obj0 = 0 ;
9923 PyObject * obj1 = 0 ;
9924 char * kwnames[] = {
9925 (char *) "self",(char *) "pt", NULL
9926 };
9927
9928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9930 if (!SWIG_IsOK(res1)) {
9931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9932 }
9933 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9934 {
9935 arg2 = &temp2;
9936 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9937 }
9938 {
9939 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9940 if (PyErr_Occurred()) SWIG_fail;
9941 }
9942 resultobj = SWIG_Py_Void();
9943 return resultobj;
9944 fail:
9945 return NULL;
9946 }
9947
9948
9949 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9950 PyObject *resultobj = 0;
9951 wxRect2D *arg1 = (wxRect2D *) 0 ;
9952 wxPoint2D result;
9953 void *argp1 = 0 ;
9954 int res1 = 0 ;
9955 PyObject *swig_obj[1] ;
9956
9957 if (!args) SWIG_fail;
9958 swig_obj[0] = args;
9959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9960 if (!SWIG_IsOK(res1)) {
9961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9962 }
9963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9964 {
9965 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9966 if (PyErr_Occurred()) SWIG_fail;
9967 }
9968 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9969 return resultobj;
9970 fail:
9971 return NULL;
9972 }
9973
9974
9975 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9976 PyObject *resultobj = 0;
9977 wxRect2D *arg1 = (wxRect2D *) 0 ;
9978 wxPoint2D *arg2 = 0 ;
9979 void *argp1 = 0 ;
9980 int res1 = 0 ;
9981 wxPoint2D temp2 ;
9982 PyObject * obj0 = 0 ;
9983 PyObject * obj1 = 0 ;
9984 char * kwnames[] = {
9985 (char *) "self",(char *) "pt", NULL
9986 };
9987
9988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9990 if (!SWIG_IsOK(res1)) {
9991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9992 }
9993 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9994 {
9995 arg2 = &temp2;
9996 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9997 }
9998 {
9999 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_Py_Void();
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxRect2D *arg1 = (wxRect2D *) 0 ;
10012 wxPoint2D *arg2 = 0 ;
10013 void *argp1 = 0 ;
10014 int res1 = 0 ;
10015 wxPoint2D temp2 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 char * kwnames[] = {
10019 (char *) "self",(char *) "pt", NULL
10020 };
10021
10022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10024 if (!SWIG_IsOK(res1)) {
10025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10026 }
10027 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10028 {
10029 arg2 = &temp2;
10030 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10031 }
10032 {
10033 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
10034 if (PyErr_Occurred()) SWIG_fail;
10035 }
10036 resultobj = SWIG_Py_Void();
10037 return resultobj;
10038 fail:
10039 return NULL;
10040 }
10041
10042
10043 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10044 PyObject *resultobj = 0;
10045 wxRect2D *arg1 = (wxRect2D *) 0 ;
10046 wxPoint2D result;
10047 void *argp1 = 0 ;
10048 int res1 = 0 ;
10049 PyObject *swig_obj[1] ;
10050
10051 if (!args) SWIG_fail;
10052 swig_obj[0] = args;
10053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10054 if (!SWIG_IsOK(res1)) {
10055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10056 }
10057 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10058 {
10059 result = ((wxRect2D const *)arg1)->GetRightTop();
10060 if (PyErr_Occurred()) SWIG_fail;
10061 }
10062 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10063 return resultobj;
10064 fail:
10065 return NULL;
10066 }
10067
10068
10069 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10070 PyObject *resultobj = 0;
10071 wxRect2D *arg1 = (wxRect2D *) 0 ;
10072 wxPoint2D *arg2 = 0 ;
10073 void *argp1 = 0 ;
10074 int res1 = 0 ;
10075 wxPoint2D temp2 ;
10076 PyObject * obj0 = 0 ;
10077 PyObject * obj1 = 0 ;
10078 char * kwnames[] = {
10079 (char *) "self",(char *) "pt", NULL
10080 };
10081
10082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
10083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10084 if (!SWIG_IsOK(res1)) {
10085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
10086 }
10087 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10088 {
10089 arg2 = &temp2;
10090 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10091 }
10092 {
10093 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
10094 if (PyErr_Occurred()) SWIG_fail;
10095 }
10096 resultobj = SWIG_Py_Void();
10097 return resultobj;
10098 fail:
10099 return NULL;
10100 }
10101
10102
10103 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10104 PyObject *resultobj = 0;
10105 wxRect2D *arg1 = (wxRect2D *) 0 ;
10106 wxPoint2D *arg2 = 0 ;
10107 void *argp1 = 0 ;
10108 int res1 = 0 ;
10109 wxPoint2D temp2 ;
10110 PyObject * obj0 = 0 ;
10111 PyObject * obj1 = 0 ;
10112 char * kwnames[] = {
10113 (char *) "self",(char *) "pt", NULL
10114 };
10115
10116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10118 if (!SWIG_IsOK(res1)) {
10119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10120 }
10121 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10122 {
10123 arg2 = &temp2;
10124 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10125 }
10126 {
10127 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10128 if (PyErr_Occurred()) SWIG_fail;
10129 }
10130 resultobj = SWIG_Py_Void();
10131 return resultobj;
10132 fail:
10133 return NULL;
10134 }
10135
10136
10137 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10138 PyObject *resultobj = 0;
10139 wxRect2D *arg1 = (wxRect2D *) 0 ;
10140 wxPoint2D result;
10141 void *argp1 = 0 ;
10142 int res1 = 0 ;
10143 PyObject *swig_obj[1] ;
10144
10145 if (!args) SWIG_fail;
10146 swig_obj[0] = args;
10147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10148 if (!SWIG_IsOK(res1)) {
10149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10150 }
10151 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10152 {
10153 result = ((wxRect2D const *)arg1)->GetRightBottom();
10154 if (PyErr_Occurred()) SWIG_fail;
10155 }
10156 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10157 return resultobj;
10158 fail:
10159 return NULL;
10160 }
10161
10162
10163 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10164 PyObject *resultobj = 0;
10165 wxRect2D *arg1 = (wxRect2D *) 0 ;
10166 wxPoint2D *arg2 = 0 ;
10167 void *argp1 = 0 ;
10168 int res1 = 0 ;
10169 wxPoint2D temp2 ;
10170 PyObject * obj0 = 0 ;
10171 PyObject * obj1 = 0 ;
10172 char * kwnames[] = {
10173 (char *) "self",(char *) "pt", NULL
10174 };
10175
10176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10178 if (!SWIG_IsOK(res1)) {
10179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10180 }
10181 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10182 {
10183 arg2 = &temp2;
10184 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10185 }
10186 {
10187 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10188 if (PyErr_Occurred()) SWIG_fail;
10189 }
10190 resultobj = SWIG_Py_Void();
10191 return resultobj;
10192 fail:
10193 return NULL;
10194 }
10195
10196
10197 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10198 PyObject *resultobj = 0;
10199 wxRect2D *arg1 = (wxRect2D *) 0 ;
10200 wxPoint2D *arg2 = 0 ;
10201 void *argp1 = 0 ;
10202 int res1 = 0 ;
10203 wxPoint2D temp2 ;
10204 PyObject * obj0 = 0 ;
10205 PyObject * obj1 = 0 ;
10206 char * kwnames[] = {
10207 (char *) "self",(char *) "pt", NULL
10208 };
10209
10210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10212 if (!SWIG_IsOK(res1)) {
10213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10214 }
10215 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10216 {
10217 arg2 = &temp2;
10218 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10219 }
10220 {
10221 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 resultobj = SWIG_Py_Void();
10225 return resultobj;
10226 fail:
10227 return NULL;
10228 }
10229
10230
10231 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10232 PyObject *resultobj = 0;
10233 wxRect2D *arg1 = (wxRect2D *) 0 ;
10234 wxPoint2D result;
10235 void *argp1 = 0 ;
10236 int res1 = 0 ;
10237 PyObject *swig_obj[1] ;
10238
10239 if (!args) SWIG_fail;
10240 swig_obj[0] = args;
10241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10242 if (!SWIG_IsOK(res1)) {
10243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10244 }
10245 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10246 {
10247 result = ((wxRect2D const *)arg1)->GetCentre();
10248 if (PyErr_Occurred()) SWIG_fail;
10249 }
10250 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10251 return resultobj;
10252 fail:
10253 return NULL;
10254 }
10255
10256
10257 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10258 PyObject *resultobj = 0;
10259 wxRect2D *arg1 = (wxRect2D *) 0 ;
10260 wxPoint2D *arg2 = 0 ;
10261 void *argp1 = 0 ;
10262 int res1 = 0 ;
10263 wxPoint2D temp2 ;
10264 PyObject * obj0 = 0 ;
10265 PyObject * obj1 = 0 ;
10266 char * kwnames[] = {
10267 (char *) "self",(char *) "pt", NULL
10268 };
10269
10270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10272 if (!SWIG_IsOK(res1)) {
10273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10274 }
10275 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10276 {
10277 arg2 = &temp2;
10278 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10279 }
10280 {
10281 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 resultobj = SWIG_Py_Void();
10285 return resultobj;
10286 fail:
10287 return NULL;
10288 }
10289
10290
10291 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10292 PyObject *resultobj = 0;
10293 wxRect2D *arg1 = (wxRect2D *) 0 ;
10294 wxPoint2D *arg2 = 0 ;
10295 void *argp1 = 0 ;
10296 int res1 = 0 ;
10297 wxPoint2D temp2 ;
10298 PyObject * obj0 = 0 ;
10299 PyObject * obj1 = 0 ;
10300 char * kwnames[] = {
10301 (char *) "self",(char *) "pt", NULL
10302 };
10303
10304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10306 if (!SWIG_IsOK(res1)) {
10307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10308 }
10309 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10310 {
10311 arg2 = &temp2;
10312 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10313 }
10314 {
10315 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10316 if (PyErr_Occurred()) SWIG_fail;
10317 }
10318 resultobj = SWIG_Py_Void();
10319 return resultobj;
10320 fail:
10321 return NULL;
10322 }
10323
10324
10325 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10326 PyObject *resultobj = 0;
10327 wxRect2D *arg1 = (wxRect2D *) 0 ;
10328 wxPoint2D *arg2 = 0 ;
10329 wxOutCode result;
10330 void *argp1 = 0 ;
10331 int res1 = 0 ;
10332 wxPoint2D temp2 ;
10333 PyObject * obj0 = 0 ;
10334 PyObject * obj1 = 0 ;
10335 char * kwnames[] = {
10336 (char *) "self",(char *) "pt", NULL
10337 };
10338
10339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10341 if (!SWIG_IsOK(res1)) {
10342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10343 }
10344 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10345 {
10346 arg2 = &temp2;
10347 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10348 }
10349 {
10350 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10351 if (PyErr_Occurred()) SWIG_fail;
10352 }
10353 resultobj = SWIG_From_int(static_cast< int >(result));
10354 return resultobj;
10355 fail:
10356 return NULL;
10357 }
10358
10359
10360 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj = 0;
10362 wxRect2D *arg1 = (wxRect2D *) 0 ;
10363 wxPoint2D *arg2 = 0 ;
10364 bool result;
10365 void *argp1 = 0 ;
10366 int res1 = 0 ;
10367 wxPoint2D temp2 ;
10368 PyObject * obj0 = 0 ;
10369 PyObject * obj1 = 0 ;
10370 char * kwnames[] = {
10371 (char *) "self",(char *) "pt", NULL
10372 };
10373
10374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10376 if (!SWIG_IsOK(res1)) {
10377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10378 }
10379 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10380 {
10381 arg2 = &temp2;
10382 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10383 }
10384 {
10385 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10386 if (PyErr_Occurred()) SWIG_fail;
10387 }
10388 {
10389 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10390 }
10391 return resultobj;
10392 fail:
10393 return NULL;
10394 }
10395
10396
10397 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10398 PyObject *resultobj = 0;
10399 wxRect2D *arg1 = (wxRect2D *) 0 ;
10400 wxRect2D *arg2 = 0 ;
10401 bool result;
10402 void *argp1 = 0 ;
10403 int res1 = 0 ;
10404 wxRect2D temp2 ;
10405 PyObject * obj0 = 0 ;
10406 PyObject * obj1 = 0 ;
10407 char * kwnames[] = {
10408 (char *) "self",(char *) "rect", NULL
10409 };
10410
10411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10413 if (!SWIG_IsOK(res1)) {
10414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10415 }
10416 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10417 {
10418 arg2 = &temp2;
10419 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10420 }
10421 {
10422 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10423 if (PyErr_Occurred()) SWIG_fail;
10424 }
10425 {
10426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10427 }
10428 return resultobj;
10429 fail:
10430 return NULL;
10431 }
10432
10433
10434 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10435 PyObject *resultobj = 0;
10436 wxRect2D *arg1 = (wxRect2D *) 0 ;
10437 bool result;
10438 void *argp1 = 0 ;
10439 int res1 = 0 ;
10440 PyObject *swig_obj[1] ;
10441
10442 if (!args) SWIG_fail;
10443 swig_obj[0] = args;
10444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10445 if (!SWIG_IsOK(res1)) {
10446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10447 }
10448 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10449 {
10450 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10451 if (PyErr_Occurred()) SWIG_fail;
10452 }
10453 {
10454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10455 }
10456 return resultobj;
10457 fail:
10458 return NULL;
10459 }
10460
10461
10462 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10463 PyObject *resultobj = 0;
10464 wxRect2D *arg1 = (wxRect2D *) 0 ;
10465 wxRect2D *arg2 = 0 ;
10466 bool result;
10467 void *argp1 = 0 ;
10468 int res1 = 0 ;
10469 wxRect2D temp2 ;
10470 PyObject * obj0 = 0 ;
10471 PyObject * obj1 = 0 ;
10472 char * kwnames[] = {
10473 (char *) "self",(char *) "rect", NULL
10474 };
10475
10476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10478 if (!SWIG_IsOK(res1)) {
10479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10480 }
10481 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10482 {
10483 arg2 = &temp2;
10484 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10485 }
10486 {
10487 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10488 if (PyErr_Occurred()) SWIG_fail;
10489 }
10490 {
10491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10492 }
10493 return resultobj;
10494 fail:
10495 return NULL;
10496 }
10497
10498
10499 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10500 PyObject *resultobj = 0;
10501 wxRect2D *arg1 = (wxRect2D *) 0 ;
10502 wxDouble arg2 ;
10503 wxDouble arg3 ;
10504 void *argp1 = 0 ;
10505 int res1 = 0 ;
10506 void *argp2 ;
10507 int res2 = 0 ;
10508 void *argp3 ;
10509 int res3 = 0 ;
10510
10511 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10513 if (!SWIG_IsOK(res1)) {
10514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10515 }
10516 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10517 {
10518 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10519 if (!SWIG_IsOK(res2)) {
10520 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10521 }
10522 if (!argp2) {
10523 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10524 } else {
10525 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10526 arg2 = *temp;
10527 if (SWIG_IsNewObj(res2)) delete temp;
10528 }
10529 }
10530 {
10531 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10532 if (!SWIG_IsOK(res3)) {
10533 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10534 }
10535 if (!argp3) {
10536 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10537 } else {
10538 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10539 arg3 = *temp;
10540 if (SWIG_IsNewObj(res3)) delete temp;
10541 }
10542 }
10543 {
10544 (arg1)->Inset(arg2,arg3);
10545 if (PyErr_Occurred()) SWIG_fail;
10546 }
10547 resultobj = SWIG_Py_Void();
10548 return resultobj;
10549 fail:
10550 return NULL;
10551 }
10552
10553
10554 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10555 PyObject *resultobj = 0;
10556 wxRect2D *arg1 = (wxRect2D *) 0 ;
10557 wxDouble arg2 ;
10558 wxDouble arg3 ;
10559 wxDouble arg4 ;
10560 wxDouble arg5 ;
10561 void *argp1 = 0 ;
10562 int res1 = 0 ;
10563 void *argp2 ;
10564 int res2 = 0 ;
10565 void *argp3 ;
10566 int res3 = 0 ;
10567 void *argp4 ;
10568 int res4 = 0 ;
10569 void *argp5 ;
10570 int res5 = 0 ;
10571
10572 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10574 if (!SWIG_IsOK(res1)) {
10575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10576 }
10577 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10578 {
10579 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10580 if (!SWIG_IsOK(res2)) {
10581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10582 }
10583 if (!argp2) {
10584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10585 } else {
10586 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10587 arg2 = *temp;
10588 if (SWIG_IsNewObj(res2)) delete temp;
10589 }
10590 }
10591 {
10592 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10593 if (!SWIG_IsOK(res3)) {
10594 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10595 }
10596 if (!argp3) {
10597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10598 } else {
10599 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10600 arg3 = *temp;
10601 if (SWIG_IsNewObj(res3)) delete temp;
10602 }
10603 }
10604 {
10605 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10606 if (!SWIG_IsOK(res4)) {
10607 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10608 }
10609 if (!argp4) {
10610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10611 } else {
10612 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10613 arg4 = *temp;
10614 if (SWIG_IsNewObj(res4)) delete temp;
10615 }
10616 }
10617 {
10618 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10619 if (!SWIG_IsOK(res5)) {
10620 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10621 }
10622 if (!argp5) {
10623 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10624 } else {
10625 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10626 arg5 = *temp;
10627 if (SWIG_IsNewObj(res5)) delete temp;
10628 }
10629 }
10630 {
10631 (arg1)->Inset(arg2,arg3,arg4,arg5);
10632 if (PyErr_Occurred()) SWIG_fail;
10633 }
10634 resultobj = SWIG_Py_Void();
10635 return resultobj;
10636 fail:
10637 return NULL;
10638 }
10639
10640
10641 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10642 int argc;
10643 PyObject *argv[6];
10644
10645 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10646 --argc;
10647 if (argc == 3) {
10648 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10649 }
10650 if (argc == 5) {
10651 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10652 }
10653
10654 fail:
10655 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10656 return NULL;
10657 }
10658
10659
10660 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10661 PyObject *resultobj = 0;
10662 wxRect2D *arg1 = (wxRect2D *) 0 ;
10663 wxPoint2D *arg2 = 0 ;
10664 void *argp1 = 0 ;
10665 int res1 = 0 ;
10666 wxPoint2D temp2 ;
10667 PyObject * obj0 = 0 ;
10668 PyObject * obj1 = 0 ;
10669 char * kwnames[] = {
10670 (char *) "self",(char *) "pt", NULL
10671 };
10672
10673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10675 if (!SWIG_IsOK(res1)) {
10676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10677 }
10678 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10679 {
10680 arg2 = &temp2;
10681 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10682 }
10683 {
10684 (arg1)->Offset((wxPoint2D const &)*arg2);
10685 if (PyErr_Occurred()) SWIG_fail;
10686 }
10687 resultobj = SWIG_Py_Void();
10688 return resultobj;
10689 fail:
10690 return NULL;
10691 }
10692
10693
10694 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10695 PyObject *resultobj = 0;
10696 wxRect2D *arg1 = (wxRect2D *) 0 ;
10697 wxRect2D *arg2 = 0 ;
10698 void *argp1 = 0 ;
10699 int res1 = 0 ;
10700 wxRect2D temp2 ;
10701 PyObject * obj0 = 0 ;
10702 PyObject * obj1 = 0 ;
10703 char * kwnames[] = {
10704 (char *) "self",(char *) "rect", NULL
10705 };
10706
10707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10709 if (!SWIG_IsOK(res1)) {
10710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10711 }
10712 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10713 {
10714 arg2 = &temp2;
10715 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10716 }
10717 {
10718 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10719 if (PyErr_Occurred()) SWIG_fail;
10720 }
10721 resultobj = SWIG_Py_Void();
10722 return resultobj;
10723 fail:
10724 return NULL;
10725 }
10726
10727
10728 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10729 PyObject *resultobj = 0;
10730 wxRect2D *arg1 = (wxRect2D *) 0 ;
10731 int arg2 ;
10732 int arg3 ;
10733 wxPoint2D result;
10734 void *argp1 = 0 ;
10735 int res1 = 0 ;
10736 int val2 ;
10737 int ecode2 = 0 ;
10738 int val3 ;
10739 int ecode3 = 0 ;
10740 PyObject * obj0 = 0 ;
10741 PyObject * obj1 = 0 ;
10742 PyObject * obj2 = 0 ;
10743 char * kwnames[] = {
10744 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10745 };
10746
10747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10749 if (!SWIG_IsOK(res1)) {
10750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10751 }
10752 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10753 ecode2 = SWIG_AsVal_int(obj1, &val2);
10754 if (!SWIG_IsOK(ecode2)) {
10755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10756 }
10757 arg2 = static_cast< int >(val2);
10758 ecode3 = SWIG_AsVal_int(obj2, &val3);
10759 if (!SWIG_IsOK(ecode3)) {
10760 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10761 }
10762 arg3 = static_cast< int >(val3);
10763 {
10764 result = (arg1)->Interpolate(arg2,arg3);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10775 PyObject *resultobj = 0;
10776 wxRect2D *arg1 = (wxRect2D *) 0 ;
10777 wxRect2D *arg2 = 0 ;
10778 void *argp1 = 0 ;
10779 int res1 = 0 ;
10780 wxRect2D temp2 ;
10781 PyObject * obj0 = 0 ;
10782 PyObject * obj1 = 0 ;
10783 char * kwnames[] = {
10784 (char *) "self",(char *) "otherRect", NULL
10785 };
10786
10787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10789 if (!SWIG_IsOK(res1)) {
10790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10791 }
10792 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10793 {
10794 arg2 = &temp2;
10795 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10796 }
10797 {
10798 (arg1)->Intersect((wxRect2D const &)*arg2);
10799 if (PyErr_Occurred()) SWIG_fail;
10800 }
10801 resultobj = SWIG_Py_Void();
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj = 0;
10810 wxRect2D *arg1 = (wxRect2D *) 0 ;
10811 wxRect2D *arg2 = 0 ;
10812 wxRect2D result;
10813 void *argp1 = 0 ;
10814 int res1 = 0 ;
10815 wxRect2D temp2 ;
10816 PyObject * obj0 = 0 ;
10817 PyObject * obj1 = 0 ;
10818 char * kwnames[] = {
10819 (char *) "self",(char *) "otherRect", NULL
10820 };
10821
10822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10824 if (!SWIG_IsOK(res1)) {
10825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10826 }
10827 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10828 {
10829 arg2 = &temp2;
10830 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10831 }
10832 {
10833 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10834 if (PyErr_Occurred()) SWIG_fail;
10835 }
10836 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10837 return resultobj;
10838 fail:
10839 return NULL;
10840 }
10841
10842
10843 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10844 PyObject *resultobj = 0;
10845 wxRect2D *arg1 = (wxRect2D *) 0 ;
10846 wxRect2D *arg2 = 0 ;
10847 bool result;
10848 void *argp1 = 0 ;
10849 int res1 = 0 ;
10850 wxRect2D temp2 ;
10851 PyObject * obj0 = 0 ;
10852 PyObject * obj1 = 0 ;
10853 char * kwnames[] = {
10854 (char *) "self",(char *) "rect", NULL
10855 };
10856
10857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10859 if (!SWIG_IsOK(res1)) {
10860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10861 }
10862 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10863 {
10864 arg2 = &temp2;
10865 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10866 }
10867 {
10868 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 {
10872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10873 }
10874 return resultobj;
10875 fail:
10876 return NULL;
10877 }
10878
10879
10880 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10881 PyObject *resultobj = 0;
10882 wxRect2D *arg1 = (wxRect2D *) 0 ;
10883 wxRect2D *arg2 = 0 ;
10884 void *argp1 = 0 ;
10885 int res1 = 0 ;
10886 wxRect2D temp2 ;
10887 PyObject * obj0 = 0 ;
10888 PyObject * obj1 = 0 ;
10889 char * kwnames[] = {
10890 (char *) "self",(char *) "otherRect", NULL
10891 };
10892
10893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10895 if (!SWIG_IsOK(res1)) {
10896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10897 }
10898 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10899 {
10900 arg2 = &temp2;
10901 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10902 }
10903 {
10904 (arg1)->Union((wxRect2D const &)*arg2);
10905 if (PyErr_Occurred()) SWIG_fail;
10906 }
10907 resultobj = SWIG_Py_Void();
10908 return resultobj;
10909 fail:
10910 return NULL;
10911 }
10912
10913
10914 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10915 PyObject *resultobj = 0;
10916 wxRect2D *arg1 = (wxRect2D *) 0 ;
10917 wxRect2D *arg2 = 0 ;
10918 wxRect2D result;
10919 void *argp1 = 0 ;
10920 int res1 = 0 ;
10921 wxRect2D temp2 ;
10922 PyObject * obj0 = 0 ;
10923 PyObject * obj1 = 0 ;
10924 char * kwnames[] = {
10925 (char *) "self",(char *) "otherRect", NULL
10926 };
10927
10928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10930 if (!SWIG_IsOK(res1)) {
10931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10932 }
10933 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10934 {
10935 arg2 = &temp2;
10936 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10937 }
10938 {
10939 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10940 if (PyErr_Occurred()) SWIG_fail;
10941 }
10942 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10943 return resultobj;
10944 fail:
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10950 PyObject *resultobj = 0;
10951 wxRect2D *arg1 = (wxRect2D *) 0 ;
10952 wxDouble arg2 ;
10953 void *argp1 = 0 ;
10954 int res1 = 0 ;
10955 void *argp2 ;
10956 int res2 = 0 ;
10957
10958 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10960 if (!SWIG_IsOK(res1)) {
10961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10962 }
10963 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10964 {
10965 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10966 if (!SWIG_IsOK(res2)) {
10967 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10968 }
10969 if (!argp2) {
10970 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10971 } else {
10972 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10973 arg2 = *temp;
10974 if (SWIG_IsNewObj(res2)) delete temp;
10975 }
10976 }
10977 {
10978 (arg1)->Scale(arg2);
10979 if (PyErr_Occurred()) SWIG_fail;
10980 }
10981 resultobj = SWIG_Py_Void();
10982 return resultobj;
10983 fail:
10984 return NULL;
10985 }
10986
10987
10988 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10989 PyObject *resultobj = 0;
10990 wxRect2D *arg1 = (wxRect2D *) 0 ;
10991 int arg2 ;
10992 int arg3 ;
10993 void *argp1 = 0 ;
10994 int res1 = 0 ;
10995 int val2 ;
10996 int ecode2 = 0 ;
10997 int val3 ;
10998 int ecode3 = 0 ;
10999
11000 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
11001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11002 if (!SWIG_IsOK(res1)) {
11003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
11004 }
11005 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11006 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
11007 if (!SWIG_IsOK(ecode2)) {
11008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
11009 }
11010 arg2 = static_cast< int >(val2);
11011 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
11012 if (!SWIG_IsOK(ecode3)) {
11013 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
11014 }
11015 arg3 = static_cast< int >(val3);
11016 {
11017 (arg1)->Scale(arg2,arg3);
11018 if (PyErr_Occurred()) SWIG_fail;
11019 }
11020 resultobj = SWIG_Py_Void();
11021 return resultobj;
11022 fail:
11023 return NULL;
11024 }
11025
11026
11027 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
11028 int argc;
11029 PyObject *argv[4];
11030
11031 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
11032 --argc;
11033 if (argc == 2) {
11034 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
11035 }
11036 if (argc == 3) {
11037 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
11038 }
11039
11040 fail:
11041 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
11042 return NULL;
11043 }
11044
11045
11046 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11047 PyObject *resultobj = 0;
11048 wxRect2D *arg1 = (wxRect2D *) 0 ;
11049 PyObject *arg2 = (PyObject *) 0 ;
11050 bool result;
11051 void *argp1 = 0 ;
11052 int res1 = 0 ;
11053 PyObject * obj0 = 0 ;
11054 PyObject * obj1 = 0 ;
11055 char * kwnames[] = {
11056 (char *) "self",(char *) "other", NULL
11057 };
11058
11059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11061 if (!SWIG_IsOK(res1)) {
11062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11063 }
11064 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11065 arg2 = obj1;
11066 {
11067 result = (bool)wxRect2D___eq__(arg1,arg2);
11068 if (PyErr_Occurred()) SWIG_fail;
11069 }
11070 {
11071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11072 }
11073 return resultobj;
11074 fail:
11075 return NULL;
11076 }
11077
11078
11079 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11080 PyObject *resultobj = 0;
11081 wxRect2D *arg1 = (wxRect2D *) 0 ;
11082 PyObject *arg2 = (PyObject *) 0 ;
11083 bool result;
11084 void *argp1 = 0 ;
11085 int res1 = 0 ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 char * kwnames[] = {
11089 (char *) "self",(char *) "other", NULL
11090 };
11091
11092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11094 if (!SWIG_IsOK(res1)) {
11095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
11096 }
11097 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11098 arg2 = obj1;
11099 {
11100 result = (bool)wxRect2D___ne__(arg1,arg2);
11101 if (PyErr_Occurred()) SWIG_fail;
11102 }
11103 {
11104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11105 }
11106 return resultobj;
11107 fail:
11108 return NULL;
11109 }
11110
11111
11112 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11113 PyObject *resultobj = 0;
11114 wxRect2D *arg1 = (wxRect2D *) 0 ;
11115 wxDouble arg2 ;
11116 void *argp1 = 0 ;
11117 int res1 = 0 ;
11118 void *argp2 ;
11119 int res2 = 0 ;
11120 PyObject *swig_obj[2] ;
11121
11122 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
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_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11126 }
11127 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11128 {
11129 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11130 if (!SWIG_IsOK(res2)) {
11131 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11132 }
11133 if (!argp2) {
11134 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11135 } else {
11136 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11137 arg2 = *temp;
11138 if (SWIG_IsNewObj(res2)) delete temp;
11139 }
11140 }
11141 if (arg1) (arg1)->m_x = arg2;
11142
11143 resultobj = SWIG_Py_Void();
11144 return resultobj;
11145 fail:
11146 return NULL;
11147 }
11148
11149
11150 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11151 PyObject *resultobj = 0;
11152 wxRect2D *arg1 = (wxRect2D *) 0 ;
11153 wxDouble result;
11154 void *argp1 = 0 ;
11155 int res1 = 0 ;
11156 PyObject *swig_obj[1] ;
11157
11158 if (!args) SWIG_fail;
11159 swig_obj[0] = args;
11160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11161 if (!SWIG_IsOK(res1)) {
11162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11163 }
11164 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11165 result = ((arg1)->m_x);
11166 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11167 return resultobj;
11168 fail:
11169 return NULL;
11170 }
11171
11172
11173 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11174 PyObject *resultobj = 0;
11175 wxRect2D *arg1 = (wxRect2D *) 0 ;
11176 wxDouble arg2 ;
11177 void *argp1 = 0 ;
11178 int res1 = 0 ;
11179 void *argp2 ;
11180 int res2 = 0 ;
11181 PyObject *swig_obj[2] ;
11182
11183 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
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_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11187 }
11188 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11189 {
11190 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11191 if (!SWIG_IsOK(res2)) {
11192 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11193 }
11194 if (!argp2) {
11195 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11196 } else {
11197 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11198 arg2 = *temp;
11199 if (SWIG_IsNewObj(res2)) delete temp;
11200 }
11201 }
11202 if (arg1) (arg1)->m_y = arg2;
11203
11204 resultobj = SWIG_Py_Void();
11205 return resultobj;
11206 fail:
11207 return NULL;
11208 }
11209
11210
11211 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11212 PyObject *resultobj = 0;
11213 wxRect2D *arg1 = (wxRect2D *) 0 ;
11214 wxDouble result;
11215 void *argp1 = 0 ;
11216 int res1 = 0 ;
11217 PyObject *swig_obj[1] ;
11218
11219 if (!args) SWIG_fail;
11220 swig_obj[0] = args;
11221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11222 if (!SWIG_IsOK(res1)) {
11223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11224 }
11225 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11226 result = ((arg1)->m_y);
11227 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11228 return resultobj;
11229 fail:
11230 return NULL;
11231 }
11232
11233
11234 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11235 PyObject *resultobj = 0;
11236 wxRect2D *arg1 = (wxRect2D *) 0 ;
11237 wxDouble arg2 ;
11238 void *argp1 = 0 ;
11239 int res1 = 0 ;
11240 void *argp2 ;
11241 int res2 = 0 ;
11242 PyObject *swig_obj[2] ;
11243
11244 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
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_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11248 }
11249 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11250 {
11251 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11252 if (!SWIG_IsOK(res2)) {
11253 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11254 }
11255 if (!argp2) {
11256 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11257 } else {
11258 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11259 arg2 = *temp;
11260 if (SWIG_IsNewObj(res2)) delete temp;
11261 }
11262 }
11263 if (arg1) (arg1)->m_width = arg2;
11264
11265 resultobj = SWIG_Py_Void();
11266 return resultobj;
11267 fail:
11268 return NULL;
11269 }
11270
11271
11272 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11273 PyObject *resultobj = 0;
11274 wxRect2D *arg1 = (wxRect2D *) 0 ;
11275 wxDouble result;
11276 void *argp1 = 0 ;
11277 int res1 = 0 ;
11278 PyObject *swig_obj[1] ;
11279
11280 if (!args) SWIG_fail;
11281 swig_obj[0] = args;
11282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11283 if (!SWIG_IsOK(res1)) {
11284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11285 }
11286 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11287 result = ((arg1)->m_width);
11288 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11289 return resultobj;
11290 fail:
11291 return NULL;
11292 }
11293
11294
11295 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11296 PyObject *resultobj = 0;
11297 wxRect2D *arg1 = (wxRect2D *) 0 ;
11298 wxDouble arg2 ;
11299 void *argp1 = 0 ;
11300 int res1 = 0 ;
11301 void *argp2 ;
11302 int res2 = 0 ;
11303 PyObject *swig_obj[2] ;
11304
11305 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11307 if (!SWIG_IsOK(res1)) {
11308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11309 }
11310 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11311 {
11312 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11313 if (!SWIG_IsOK(res2)) {
11314 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11315 }
11316 if (!argp2) {
11317 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11318 } else {
11319 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11320 arg2 = *temp;
11321 if (SWIG_IsNewObj(res2)) delete temp;
11322 }
11323 }
11324 if (arg1) (arg1)->m_height = arg2;
11325
11326 resultobj = SWIG_Py_Void();
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11334 PyObject *resultobj = 0;
11335 wxRect2D *arg1 = (wxRect2D *) 0 ;
11336 wxDouble result;
11337 void *argp1 = 0 ;
11338 int res1 = 0 ;
11339 PyObject *swig_obj[1] ;
11340
11341 if (!args) SWIG_fail;
11342 swig_obj[0] = args;
11343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11344 if (!SWIG_IsOK(res1)) {
11345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11346 }
11347 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11348 result = ((arg1)->m_height);
11349 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11350 return resultobj;
11351 fail:
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxRect2D *arg1 = (wxRect2D *) 0 ;
11359 wxDouble arg2 = (wxDouble) 0 ;
11360 wxDouble arg3 = (wxDouble) 0 ;
11361 wxDouble arg4 = (wxDouble) 0 ;
11362 wxDouble arg5 = (wxDouble) 0 ;
11363 void *argp1 = 0 ;
11364 int res1 = 0 ;
11365 void *argp2 ;
11366 int res2 = 0 ;
11367 void *argp3 ;
11368 int res3 = 0 ;
11369 void *argp4 ;
11370 int res4 = 0 ;
11371 void *argp5 ;
11372 int res5 = 0 ;
11373 PyObject * obj0 = 0 ;
11374 PyObject * obj1 = 0 ;
11375 PyObject * obj2 = 0 ;
11376 PyObject * obj3 = 0 ;
11377 PyObject * obj4 = 0 ;
11378 char * kwnames[] = {
11379 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11380 };
11381
11382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11384 if (!SWIG_IsOK(res1)) {
11385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11386 }
11387 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11388 if (obj1) {
11389 {
11390 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11391 if (!SWIG_IsOK(res2)) {
11392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11393 }
11394 if (!argp2) {
11395 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11396 } else {
11397 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11398 arg2 = *temp;
11399 if (SWIG_IsNewObj(res2)) delete temp;
11400 }
11401 }
11402 }
11403 if (obj2) {
11404 {
11405 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11406 if (!SWIG_IsOK(res3)) {
11407 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11408 }
11409 if (!argp3) {
11410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11411 } else {
11412 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11413 arg3 = *temp;
11414 if (SWIG_IsNewObj(res3)) delete temp;
11415 }
11416 }
11417 }
11418 if (obj3) {
11419 {
11420 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11421 if (!SWIG_IsOK(res4)) {
11422 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11423 }
11424 if (!argp4) {
11425 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11426 } else {
11427 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11428 arg4 = *temp;
11429 if (SWIG_IsNewObj(res4)) delete temp;
11430 }
11431 }
11432 }
11433 if (obj4) {
11434 {
11435 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11436 if (!SWIG_IsOK(res5)) {
11437 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11438 }
11439 if (!argp5) {
11440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11441 } else {
11442 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11443 arg5 = *temp;
11444 if (SWIG_IsNewObj(res5)) delete temp;
11445 }
11446 }
11447 }
11448 {
11449 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11450 if (PyErr_Occurred()) SWIG_fail;
11451 }
11452 resultobj = SWIG_Py_Void();
11453 return resultobj;
11454 fail:
11455 return NULL;
11456 }
11457
11458
11459 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11460 PyObject *resultobj = 0;
11461 wxRect2D *arg1 = (wxRect2D *) 0 ;
11462 PyObject *result = 0 ;
11463 void *argp1 = 0 ;
11464 int res1 = 0 ;
11465 PyObject *swig_obj[1] ;
11466
11467 if (!args) SWIG_fail;
11468 swig_obj[0] = args;
11469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11470 if (!SWIG_IsOK(res1)) {
11471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11472 }
11473 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11474 {
11475 result = (PyObject *)wxRect2D_Get(arg1);
11476 if (PyErr_Occurred()) SWIG_fail;
11477 }
11478 resultobj = result;
11479 return resultobj;
11480 fail:
11481 return NULL;
11482 }
11483
11484
11485 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11486 PyObject *obj;
11487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11488 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11489 return SWIG_Py_Void();
11490 }
11491
11492 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11493 return SWIG_Python_InitShadowInstance(args);
11494 }
11495
11496 SWIGINTERN PyObject *_wrap_new_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11497 PyObject *resultobj = 0;
11498 int arg1 = (int) 0 ;
11499 int arg2 = (int) 0 ;
11500 wxPosition *result = 0 ;
11501 int val1 ;
11502 int ecode1 = 0 ;
11503 int val2 ;
11504 int ecode2 = 0 ;
11505 PyObject * obj0 = 0 ;
11506 PyObject * obj1 = 0 ;
11507 char * kwnames[] = {
11508 (char *) "row",(char *) "col", NULL
11509 };
11510
11511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Position",kwnames,&obj0,&obj1)) SWIG_fail;
11512 if (obj0) {
11513 ecode1 = SWIG_AsVal_int(obj0, &val1);
11514 if (!SWIG_IsOK(ecode1)) {
11515 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Position" "', expected argument " "1"" of type '" "int""'");
11516 }
11517 arg1 = static_cast< int >(val1);
11518 }
11519 if (obj1) {
11520 ecode2 = SWIG_AsVal_int(obj1, &val2);
11521 if (!SWIG_IsOK(ecode2)) {
11522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Position" "', expected argument " "2"" of type '" "int""'");
11523 }
11524 arg2 = static_cast< int >(val2);
11525 }
11526 {
11527 result = (wxPosition *)new wxPosition(arg1,arg2);
11528 if (PyErr_Occurred()) SWIG_fail;
11529 }
11530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPosition, SWIG_POINTER_NEW | 0 );
11531 return resultobj;
11532 fail:
11533 return NULL;
11534 }
11535
11536
11537 SWIGINTERN PyObject *_wrap_delete_Position(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11538 PyObject *resultobj = 0;
11539 wxPosition *arg1 = (wxPosition *) 0 ;
11540 void *argp1 = 0 ;
11541 int res1 = 0 ;
11542 PyObject *swig_obj[1] ;
11543
11544 if (!args) SWIG_fail;
11545 swig_obj[0] = args;
11546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, SWIG_POINTER_DISOWN | 0 );
11547 if (!SWIG_IsOK(res1)) {
11548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Position" "', expected argument " "1"" of type '" "wxPosition *""'");
11549 }
11550 arg1 = reinterpret_cast< wxPosition * >(argp1);
11551 {
11552 delete arg1;
11553
11554 if (PyErr_Occurred()) SWIG_fail;
11555 }
11556 resultobj = SWIG_Py_Void();
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 SWIGINTERN PyObject *_wrap_Position_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11564 PyObject *resultobj = 0;
11565 wxPosition *arg1 = (wxPosition *) 0 ;
11566 int result;
11567 void *argp1 = 0 ;
11568 int res1 = 0 ;
11569 PyObject *swig_obj[1] ;
11570
11571 if (!args) SWIG_fail;
11572 swig_obj[0] = args;
11573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11574 if (!SWIG_IsOK(res1)) {
11575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetRow" "', expected argument " "1"" of type '" "wxPosition const *""'");
11576 }
11577 arg1 = reinterpret_cast< wxPosition * >(argp1);
11578 {
11579 result = (int)((wxPosition const *)arg1)->GetRow();
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 resultobj = SWIG_From_int(static_cast< int >(result));
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 SWIGINTERN PyObject *_wrap_Position_GetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11590 PyObject *resultobj = 0;
11591 wxPosition *arg1 = (wxPosition *) 0 ;
11592 int result;
11593 void *argp1 = 0 ;
11594 int res1 = 0 ;
11595 PyObject *swig_obj[1] ;
11596
11597 if (!args) SWIG_fail;
11598 swig_obj[0] = args;
11599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11600 if (!SWIG_IsOK(res1)) {
11601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetColumn" "', expected argument " "1"" of type '" "wxPosition const *""'");
11602 }
11603 arg1 = reinterpret_cast< wxPosition * >(argp1);
11604 {
11605 result = (int)((wxPosition const *)arg1)->GetColumn();
11606 if (PyErr_Occurred()) SWIG_fail;
11607 }
11608 resultobj = SWIG_From_int(static_cast< int >(result));
11609 return resultobj;
11610 fail:
11611 return NULL;
11612 }
11613
11614
11615 SWIGINTERN PyObject *_wrap_Position_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11616 PyObject *resultobj = 0;
11617 wxPosition *arg1 = (wxPosition *) 0 ;
11618 int result;
11619 void *argp1 = 0 ;
11620 int res1 = 0 ;
11621 PyObject *swig_obj[1] ;
11622
11623 if (!args) SWIG_fail;
11624 swig_obj[0] = args;
11625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11626 if (!SWIG_IsOK(res1)) {
11627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_GetCol" "', expected argument " "1"" of type '" "wxPosition const *""'");
11628 }
11629 arg1 = reinterpret_cast< wxPosition * >(argp1);
11630 {
11631 result = (int)((wxPosition const *)arg1)->GetCol();
11632 if (PyErr_Occurred()) SWIG_fail;
11633 }
11634 resultobj = SWIG_From_int(static_cast< int >(result));
11635 return resultobj;
11636 fail:
11637 return NULL;
11638 }
11639
11640
11641 SWIGINTERN PyObject *_wrap_Position_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11642 PyObject *resultobj = 0;
11643 wxPosition *arg1 = (wxPosition *) 0 ;
11644 int arg2 ;
11645 void *argp1 = 0 ;
11646 int res1 = 0 ;
11647 int val2 ;
11648 int ecode2 = 0 ;
11649 PyObject * obj0 = 0 ;
11650 PyObject * obj1 = 0 ;
11651 char * kwnames[] = {
11652 (char *) "self",(char *) "row", NULL
11653 };
11654
11655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
11656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11657 if (!SWIG_IsOK(res1)) {
11658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetRow" "', expected argument " "1"" of type '" "wxPosition *""'");
11659 }
11660 arg1 = reinterpret_cast< wxPosition * >(argp1);
11661 ecode2 = SWIG_AsVal_int(obj1, &val2);
11662 if (!SWIG_IsOK(ecode2)) {
11663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetRow" "', expected argument " "2"" of type '" "int""'");
11664 }
11665 arg2 = static_cast< int >(val2);
11666 {
11667 (arg1)->SetRow(arg2);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 resultobj = SWIG_Py_Void();
11671 return resultobj;
11672 fail:
11673 return NULL;
11674 }
11675
11676
11677 SWIGINTERN PyObject *_wrap_Position_SetColumn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11678 PyObject *resultobj = 0;
11679 wxPosition *arg1 = (wxPosition *) 0 ;
11680 int arg2 ;
11681 void *argp1 = 0 ;
11682 int res1 = 0 ;
11683 int val2 ;
11684 int ecode2 = 0 ;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "column", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetColumn",kwnames,&obj0,&obj1)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetColumn" "', expected argument " "1"" of type '" "wxPosition *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPosition * >(argp1);
11697 ecode2 = SWIG_AsVal_int(obj1, &val2);
11698 if (!SWIG_IsOK(ecode2)) {
11699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetColumn" "', expected argument " "2"" of type '" "int""'");
11700 }
11701 arg2 = static_cast< int >(val2);
11702 {
11703 (arg1)->SetColumn(arg2);
11704 if (PyErr_Occurred()) SWIG_fail;
11705 }
11706 resultobj = SWIG_Py_Void();
11707 return resultobj;
11708 fail:
11709 return NULL;
11710 }
11711
11712
11713 SWIGINTERN PyObject *_wrap_Position_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11714 PyObject *resultobj = 0;
11715 wxPosition *arg1 = (wxPosition *) 0 ;
11716 int arg2 ;
11717 void *argp1 = 0 ;
11718 int res1 = 0 ;
11719 int val2 ;
11720 int ecode2 = 0 ;
11721 PyObject * obj0 = 0 ;
11722 PyObject * obj1 = 0 ;
11723 char * kwnames[] = {
11724 (char *) "self",(char *) "column", NULL
11725 };
11726
11727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
11728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11729 if (!SWIG_IsOK(res1)) {
11730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position_SetCol" "', expected argument " "1"" of type '" "wxPosition *""'");
11731 }
11732 arg1 = reinterpret_cast< wxPosition * >(argp1);
11733 ecode2 = SWIG_AsVal_int(obj1, &val2);
11734 if (!SWIG_IsOK(ecode2)) {
11735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Position_SetCol" "', expected argument " "2"" of type '" "int""'");
11736 }
11737 arg2 = static_cast< int >(val2);
11738 {
11739 (arg1)->SetCol(arg2);
11740 if (PyErr_Occurred()) SWIG_fail;
11741 }
11742 resultobj = SWIG_Py_Void();
11743 return resultobj;
11744 fail:
11745 return NULL;
11746 }
11747
11748
11749 SWIGINTERN PyObject *_wrap_Position___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11750 PyObject *resultobj = 0;
11751 wxPosition *arg1 = (wxPosition *) 0 ;
11752 PyObject *arg2 = (PyObject *) 0 ;
11753 bool result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject * obj0 = 0 ;
11757 PyObject * obj1 = 0 ;
11758 char * kwnames[] = {
11759 (char *) "self",(char *) "other", NULL
11760 };
11761
11762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
11763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11764 if (!SWIG_IsOK(res1)) {
11765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___eq__" "', expected argument " "1"" of type '" "wxPosition *""'");
11766 }
11767 arg1 = reinterpret_cast< wxPosition * >(argp1);
11768 arg2 = obj1;
11769 {
11770 result = (bool)wxPosition___eq__(arg1,arg2);
11771 if (PyErr_Occurred()) SWIG_fail;
11772 }
11773 {
11774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11775 }
11776 return resultobj;
11777 fail:
11778 return NULL;
11779 }
11780
11781
11782 SWIGINTERN PyObject *_wrap_Position___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11783 PyObject *resultobj = 0;
11784 wxPosition *arg1 = (wxPosition *) 0 ;
11785 PyObject *arg2 = (PyObject *) 0 ;
11786 bool result;
11787 void *argp1 = 0 ;
11788 int res1 = 0 ;
11789 PyObject * obj0 = 0 ;
11790 PyObject * obj1 = 0 ;
11791 char * kwnames[] = {
11792 (char *) "self",(char *) "other", NULL
11793 };
11794
11795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Position___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
11796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11797 if (!SWIG_IsOK(res1)) {
11798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___ne__" "', expected argument " "1"" of type '" "wxPosition *""'");
11799 }
11800 arg1 = reinterpret_cast< wxPosition * >(argp1);
11801 arg2 = obj1;
11802 {
11803 result = (bool)wxPosition___ne__(arg1,arg2);
11804 if (PyErr_Occurred()) SWIG_fail;
11805 }
11806 {
11807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11808 }
11809 return resultobj;
11810 fail:
11811 return NULL;
11812 }
11813
11814
11815 SWIGINTERN PyObject *_wrap_Position___add____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11816 PyObject *resultobj = 0;
11817 wxPosition *arg1 = (wxPosition *) 0 ;
11818 wxPosition *arg2 = 0 ;
11819 wxPosition result;
11820 void *argp1 = 0 ;
11821 int res1 = 0 ;
11822 void *argp2 = 0 ;
11823 int res2 = 0 ;
11824
11825 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11827 if (!SWIG_IsOK(res1)) {
11828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11829 }
11830 arg1 = reinterpret_cast< wxPosition * >(argp1);
11831 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11832 if (!SWIG_IsOK(res2)) {
11833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11834 }
11835 if (!argp2) {
11836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___add__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11837 }
11838 arg2 = reinterpret_cast< wxPosition * >(argp2);
11839 {
11840 result = ((wxPosition const *)arg1)->operator +((wxPosition const &)*arg2);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11844 return resultobj;
11845 fail:
11846 return NULL;
11847 }
11848
11849
11850 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11851 PyObject *resultobj = 0;
11852 wxPosition *arg1 = (wxPosition *) 0 ;
11853 wxPosition *arg2 = 0 ;
11854 wxPosition result;
11855 void *argp1 = 0 ;
11856 int res1 = 0 ;
11857 void *argp2 = 0 ;
11858 int res2 = 0 ;
11859
11860 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11862 if (!SWIG_IsOK(res1)) {
11863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11864 }
11865 arg1 = reinterpret_cast< wxPosition * >(argp1);
11866 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxPosition, 0 | 0);
11867 if (!SWIG_IsOK(res2)) {
11868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11869 }
11870 if (!argp2) {
11871 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Position___sub__" "', expected argument " "2"" of type '" "wxPosition const &""'");
11872 }
11873 arg2 = reinterpret_cast< wxPosition * >(argp2);
11874 {
11875 result = ((wxPosition const *)arg1)->operator -((wxPosition const &)*arg2);
11876 if (PyErr_Occurred()) SWIG_fail;
11877 }
11878 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11879 return resultobj;
11880 fail:
11881 return NULL;
11882 }
11883
11884
11885 SWIGINTERN PyObject *_wrap_Position___add____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11886 PyObject *resultobj = 0;
11887 wxPosition *arg1 = (wxPosition *) 0 ;
11888 wxSize *arg2 = 0 ;
11889 wxPosition result;
11890 void *argp1 = 0 ;
11891 int res1 = 0 ;
11892 wxSize temp2 ;
11893
11894 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11896 if (!SWIG_IsOK(res1)) {
11897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___add__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11898 }
11899 arg1 = reinterpret_cast< wxPosition * >(argp1);
11900 {
11901 arg2 = &temp2;
11902 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11903 }
11904 {
11905 result = ((wxPosition const *)arg1)->operator +((wxSize const &)*arg2);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11909 return resultobj;
11910 fail:
11911 return NULL;
11912 }
11913
11914
11915 SWIGINTERN PyObject *_wrap_Position___add__(PyObject *self, PyObject *args) {
11916 int argc;
11917 PyObject *argv[3];
11918
11919 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___add__",0,2,argv))) SWIG_fail;
11920 --argc;
11921 if (argc == 2) {
11922 int _v = 0;
11923 {
11924 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11925 _v = SWIG_CheckState(res);
11926 }
11927 if (!_v) goto check_1;
11928 return _wrap_Position___add____SWIG_0(self, argc, argv);
11929 }
11930 check_1:
11931
11932 if (argc == 2) {
11933 return _wrap_Position___add____SWIG_1(self, argc, argv);
11934 }
11935
11936 fail:
11937 Py_INCREF(Py_NotImplemented);
11938 return Py_NotImplemented;
11939 }
11940
11941
11942 SWIGINTERN PyObject *_wrap_Position___sub____SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
11943 PyObject *resultobj = 0;
11944 wxPosition *arg1 = (wxPosition *) 0 ;
11945 wxSize *arg2 = 0 ;
11946 wxPosition result;
11947 void *argp1 = 0 ;
11948 int res1 = 0 ;
11949 wxSize temp2 ;
11950
11951 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
11952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPosition, 0 | 0 );
11953 if (!SWIG_IsOK(res1)) {
11954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Position___sub__" "', expected argument " "1"" of type '" "wxPosition const *""'");
11955 }
11956 arg1 = reinterpret_cast< wxPosition * >(argp1);
11957 {
11958 arg2 = &temp2;
11959 if ( ! wxSize_helper(swig_obj[1], &arg2)) SWIG_fail;
11960 }
11961 {
11962 result = ((wxPosition const *)arg1)->operator -((wxSize const &)*arg2);
11963 if (PyErr_Occurred()) SWIG_fail;
11964 }
11965 resultobj = SWIG_NewPointerObj((new wxPosition(static_cast< const wxPosition& >(result))), SWIGTYPE_p_wxPosition, SWIG_POINTER_OWN | 0 );
11966 return resultobj;
11967 fail:
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_Position___sub__(PyObject *self, PyObject *args) {
11973 int argc;
11974 PyObject *argv[3];
11975
11976 if (!(argc = SWIG_Python_UnpackTuple(args,"Position___sub__",0,2,argv))) SWIG_fail;
11977 --argc;
11978 if (argc == 2) {
11979 int _v = 0;
11980 {
11981 int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_wxPosition, 0);
11982 _v = SWIG_CheckState(res);
11983 }
11984 if (!_v) goto check_1;
11985 return _wrap_Position___sub____SWIG_0(self, argc, argv);
11986 }
11987 check_1:
11988
11989 if (argc == 2) {
11990 return _wrap_Position___sub____SWIG_1(self, argc, argv);
11991 }
11992
11993 fail:
11994 Py_INCREF(Py_NotImplemented);
11995 return Py_NotImplemented;
11996 }
11997
11998
11999 SWIGINTERN PyObject *Position_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12000 PyObject *obj;
12001 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12002 SWIG_TypeNewClientData(SWIGTYPE_p_wxPosition, SWIG_NewClientData(obj));
12003 return SWIG_Py_Void();
12004 }
12005
12006 SWIGINTERN PyObject *Position_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12007 return SWIG_Python_InitShadowInstance(args);
12008 }
12009
12010 SWIGINTERN int DefaultPosition_set(PyObject *) {
12011 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
12012 return 1;
12013 }
12014
12015
12016 SWIGINTERN PyObject *DefaultPosition_get(void) {
12017 PyObject *pyobj = 0;
12018
12019 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
12020 return pyobj;
12021 }
12022
12023
12024 SWIGINTERN int DefaultSize_set(PyObject *) {
12025 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
12026 return 1;
12027 }
12028
12029
12030 SWIGINTERN PyObject *DefaultSize_get(void) {
12031 PyObject *pyobj = 0;
12032
12033 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
12034 return pyobj;
12035 }
12036
12037
12038 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12039 PyObject *resultobj = 0;
12040 PyObject *arg1 = (PyObject *) 0 ;
12041 wxPyInputStream *result = 0 ;
12042 PyObject * obj0 = 0 ;
12043 char * kwnames[] = {
12044 (char *) "p", NULL
12045 };
12046
12047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
12048 arg1 = obj0;
12049 {
12050 PyThreadState* __tstate = wxPyBeginAllowThreads();
12051 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
12052 wxPyEndAllowThreads(__tstate);
12053 if (PyErr_Occurred()) SWIG_fail;
12054 }
12055 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
12056 return resultobj;
12057 fail:
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12063 PyObject *resultobj = 0;
12064 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12065 void *argp1 = 0 ;
12066 int res1 = 0 ;
12067 PyObject *swig_obj[1] ;
12068
12069 if (!args) SWIG_fail;
12070 swig_obj[0] = args;
12071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
12072 if (!SWIG_IsOK(res1)) {
12073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12074 }
12075 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12076 {
12077 PyThreadState* __tstate = wxPyBeginAllowThreads();
12078 delete arg1;
12079
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 resultobj = SWIG_Py_Void();
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 PyObject *resultobj = 0;
12092 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12093 void *argp1 = 0 ;
12094 int res1 = 0 ;
12095 PyObject *swig_obj[1] ;
12096
12097 if (!args) SWIG_fail;
12098 swig_obj[0] = args;
12099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12100 if (!SWIG_IsOK(res1)) {
12101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12102 }
12103 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12104 {
12105 PyThreadState* __tstate = wxPyBeginAllowThreads();
12106 (arg1)->close();
12107 wxPyEndAllowThreads(__tstate);
12108 if (PyErr_Occurred()) SWIG_fail;
12109 }
12110 resultobj = SWIG_Py_Void();
12111 return resultobj;
12112 fail:
12113 return NULL;
12114 }
12115
12116
12117 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12118 PyObject *resultobj = 0;
12119 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12120 void *argp1 = 0 ;
12121 int res1 = 0 ;
12122 PyObject *swig_obj[1] ;
12123
12124 if (!args) SWIG_fail;
12125 swig_obj[0] = args;
12126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12127 if (!SWIG_IsOK(res1)) {
12128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12129 }
12130 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12131 {
12132 PyThreadState* __tstate = wxPyBeginAllowThreads();
12133 (arg1)->flush();
12134 wxPyEndAllowThreads(__tstate);
12135 if (PyErr_Occurred()) SWIG_fail;
12136 }
12137 resultobj = SWIG_Py_Void();
12138 return resultobj;
12139 fail:
12140 return NULL;
12141 }
12142
12143
12144 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12145 PyObject *resultobj = 0;
12146 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12147 bool result;
12148 void *argp1 = 0 ;
12149 int res1 = 0 ;
12150 PyObject *swig_obj[1] ;
12151
12152 if (!args) SWIG_fail;
12153 swig_obj[0] = args;
12154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12155 if (!SWIG_IsOK(res1)) {
12156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12157 }
12158 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12159 {
12160 PyThreadState* __tstate = wxPyBeginAllowThreads();
12161 result = (bool)(arg1)->eof();
12162 wxPyEndAllowThreads(__tstate);
12163 if (PyErr_Occurred()) SWIG_fail;
12164 }
12165 {
12166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12167 }
12168 return resultobj;
12169 fail:
12170 return NULL;
12171 }
12172
12173
12174 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12175 PyObject *resultobj = 0;
12176 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12177 int arg2 = (int) -1 ;
12178 PyObject *result = 0 ;
12179 void *argp1 = 0 ;
12180 int res1 = 0 ;
12181 int val2 ;
12182 int ecode2 = 0 ;
12183 PyObject * obj0 = 0 ;
12184 PyObject * obj1 = 0 ;
12185 char * kwnames[] = {
12186 (char *) "self",(char *) "size", NULL
12187 };
12188
12189 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
12190 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12191 if (!SWIG_IsOK(res1)) {
12192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12193 }
12194 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12195 if (obj1) {
12196 ecode2 = SWIG_AsVal_int(obj1, &val2);
12197 if (!SWIG_IsOK(ecode2)) {
12198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
12199 }
12200 arg2 = static_cast< int >(val2);
12201 }
12202 {
12203 PyThreadState* __tstate = wxPyBeginAllowThreads();
12204 result = (PyObject *)(arg1)->read(arg2);
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 resultobj = result;
12209 return resultobj;
12210 fail:
12211 return NULL;
12212 }
12213
12214
12215 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12216 PyObject *resultobj = 0;
12217 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12218 int arg2 = (int) -1 ;
12219 PyObject *result = 0 ;
12220 void *argp1 = 0 ;
12221 int res1 = 0 ;
12222 int val2 ;
12223 int ecode2 = 0 ;
12224 PyObject * obj0 = 0 ;
12225 PyObject * obj1 = 0 ;
12226 char * kwnames[] = {
12227 (char *) "self",(char *) "size", NULL
12228 };
12229
12230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
12231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12232 if (!SWIG_IsOK(res1)) {
12233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12234 }
12235 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12236 if (obj1) {
12237 ecode2 = SWIG_AsVal_int(obj1, &val2);
12238 if (!SWIG_IsOK(ecode2)) {
12239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
12240 }
12241 arg2 = static_cast< int >(val2);
12242 }
12243 {
12244 PyThreadState* __tstate = wxPyBeginAllowThreads();
12245 result = (PyObject *)(arg1)->readline(arg2);
12246 wxPyEndAllowThreads(__tstate);
12247 if (PyErr_Occurred()) SWIG_fail;
12248 }
12249 resultobj = result;
12250 return resultobj;
12251 fail:
12252 return NULL;
12253 }
12254
12255
12256 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12257 PyObject *resultobj = 0;
12258 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12259 int arg2 = (int) -1 ;
12260 PyObject *result = 0 ;
12261 void *argp1 = 0 ;
12262 int res1 = 0 ;
12263 int val2 ;
12264 int ecode2 = 0 ;
12265 PyObject * obj0 = 0 ;
12266 PyObject * obj1 = 0 ;
12267 char * kwnames[] = {
12268 (char *) "self",(char *) "sizehint", NULL
12269 };
12270
12271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
12272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12273 if (!SWIG_IsOK(res1)) {
12274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12275 }
12276 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12277 if (obj1) {
12278 ecode2 = SWIG_AsVal_int(obj1, &val2);
12279 if (!SWIG_IsOK(ecode2)) {
12280 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
12281 }
12282 arg2 = static_cast< int >(val2);
12283 }
12284 {
12285 PyThreadState* __tstate = wxPyBeginAllowThreads();
12286 result = (PyObject *)(arg1)->readlines(arg2);
12287 wxPyEndAllowThreads(__tstate);
12288 if (PyErr_Occurred()) SWIG_fail;
12289 }
12290 resultobj = result;
12291 return resultobj;
12292 fail:
12293 return NULL;
12294 }
12295
12296
12297 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12298 PyObject *resultobj = 0;
12299 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12300 int arg2 ;
12301 int arg3 = (int) 0 ;
12302 void *argp1 = 0 ;
12303 int res1 = 0 ;
12304 int val2 ;
12305 int ecode2 = 0 ;
12306 int val3 ;
12307 int ecode3 = 0 ;
12308 PyObject * obj0 = 0 ;
12309 PyObject * obj1 = 0 ;
12310 PyObject * obj2 = 0 ;
12311 char * kwnames[] = {
12312 (char *) "self",(char *) "offset",(char *) "whence", NULL
12313 };
12314
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12317 if (!SWIG_IsOK(res1)) {
12318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12319 }
12320 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12321 ecode2 = SWIG_AsVal_int(obj1, &val2);
12322 if (!SWIG_IsOK(ecode2)) {
12323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
12324 }
12325 arg2 = static_cast< int >(val2);
12326 if (obj2) {
12327 ecode3 = SWIG_AsVal_int(obj2, &val3);
12328 if (!SWIG_IsOK(ecode3)) {
12329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
12330 }
12331 arg3 = static_cast< int >(val3);
12332 }
12333 {
12334 PyThreadState* __tstate = wxPyBeginAllowThreads();
12335 (arg1)->seek(arg2,arg3);
12336 wxPyEndAllowThreads(__tstate);
12337 if (PyErr_Occurred()) SWIG_fail;
12338 }
12339 resultobj = SWIG_Py_Void();
12340 return resultobj;
12341 fail:
12342 return NULL;
12343 }
12344
12345
12346 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12347 PyObject *resultobj = 0;
12348 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12349 int result;
12350 void *argp1 = 0 ;
12351 int res1 = 0 ;
12352 PyObject *swig_obj[1] ;
12353
12354 if (!args) SWIG_fail;
12355 swig_obj[0] = args;
12356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12357 if (!SWIG_IsOK(res1)) {
12358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12359 }
12360 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12361 {
12362 PyThreadState* __tstate = wxPyBeginAllowThreads();
12363 result = (int)(arg1)->tell();
12364 wxPyEndAllowThreads(__tstate);
12365 if (PyErr_Occurred()) SWIG_fail;
12366 }
12367 resultobj = SWIG_From_int(static_cast< int >(result));
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12375 PyObject *resultobj = 0;
12376 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12377 char result;
12378 void *argp1 = 0 ;
12379 int res1 = 0 ;
12380 PyObject *swig_obj[1] ;
12381
12382 if (!args) SWIG_fail;
12383 swig_obj[0] = args;
12384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12385 if (!SWIG_IsOK(res1)) {
12386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12387 }
12388 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12389 {
12390 PyThreadState* __tstate = wxPyBeginAllowThreads();
12391 result = (char)(arg1)->Peek();
12392 wxPyEndAllowThreads(__tstate);
12393 if (PyErr_Occurred()) SWIG_fail;
12394 }
12395 resultobj = SWIG_From_char(static_cast< char >(result));
12396 return resultobj;
12397 fail:
12398 return NULL;
12399 }
12400
12401
12402 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12403 PyObject *resultobj = 0;
12404 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12405 char result;
12406 void *argp1 = 0 ;
12407 int res1 = 0 ;
12408 PyObject *swig_obj[1] ;
12409
12410 if (!args) SWIG_fail;
12411 swig_obj[0] = args;
12412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12413 if (!SWIG_IsOK(res1)) {
12414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12415 }
12416 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12417 {
12418 PyThreadState* __tstate = wxPyBeginAllowThreads();
12419 result = (char)(arg1)->GetC();
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 resultobj = SWIG_From_char(static_cast< char >(result));
12424 return resultobj;
12425 fail:
12426 return NULL;
12427 }
12428
12429
12430 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12431 PyObject *resultobj = 0;
12432 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12433 size_t result;
12434 void *argp1 = 0 ;
12435 int res1 = 0 ;
12436 PyObject *swig_obj[1] ;
12437
12438 if (!args) SWIG_fail;
12439 swig_obj[0] = args;
12440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12441 if (!SWIG_IsOK(res1)) {
12442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12443 }
12444 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12445 {
12446 PyThreadState* __tstate = wxPyBeginAllowThreads();
12447 result = (size_t)(arg1)->LastRead();
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12459 PyObject *resultobj = 0;
12460 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12461 bool result;
12462 void *argp1 = 0 ;
12463 int res1 = 0 ;
12464 PyObject *swig_obj[1] ;
12465
12466 if (!args) SWIG_fail;
12467 swig_obj[0] = args;
12468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12469 if (!SWIG_IsOK(res1)) {
12470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12471 }
12472 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12473 {
12474 PyThreadState* __tstate = wxPyBeginAllowThreads();
12475 result = (bool)(arg1)->CanRead();
12476 wxPyEndAllowThreads(__tstate);
12477 if (PyErr_Occurred()) SWIG_fail;
12478 }
12479 {
12480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12481 }
12482 return resultobj;
12483 fail:
12484 return NULL;
12485 }
12486
12487
12488 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12489 PyObject *resultobj = 0;
12490 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12491 bool result;
12492 void *argp1 = 0 ;
12493 int res1 = 0 ;
12494 PyObject *swig_obj[1] ;
12495
12496 if (!args) SWIG_fail;
12497 swig_obj[0] = args;
12498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12499 if (!SWIG_IsOK(res1)) {
12500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12501 }
12502 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12503 {
12504 PyThreadState* __tstate = wxPyBeginAllowThreads();
12505 result = (bool)(arg1)->Eof();
12506 wxPyEndAllowThreads(__tstate);
12507 if (PyErr_Occurred()) SWIG_fail;
12508 }
12509 {
12510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12511 }
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj = 0;
12520 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12521 char arg2 ;
12522 bool result;
12523 void *argp1 = 0 ;
12524 int res1 = 0 ;
12525 char val2 ;
12526 int ecode2 = 0 ;
12527 PyObject * obj0 = 0 ;
12528 PyObject * obj1 = 0 ;
12529 char * kwnames[] = {
12530 (char *) "self",(char *) "c", NULL
12531 };
12532
12533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
12534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12535 if (!SWIG_IsOK(res1)) {
12536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12537 }
12538 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12539 ecode2 = SWIG_AsVal_char(obj1, &val2);
12540 if (!SWIG_IsOK(ecode2)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
12542 }
12543 arg2 = static_cast< char >(val2);
12544 {
12545 PyThreadState* __tstate = wxPyBeginAllowThreads();
12546 result = (bool)(arg1)->Ungetch(arg2);
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 {
12551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12552 }
12553 return resultobj;
12554 fail:
12555 return NULL;
12556 }
12557
12558
12559 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12560 PyObject *resultobj = 0;
12561 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12562 long arg2 ;
12563 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
12564 long result;
12565 void *argp1 = 0 ;
12566 int res1 = 0 ;
12567 long val2 ;
12568 int ecode2 = 0 ;
12569 int val3 ;
12570 int ecode3 = 0 ;
12571 PyObject * obj0 = 0 ;
12572 PyObject * obj1 = 0 ;
12573 PyObject * obj2 = 0 ;
12574 char * kwnames[] = {
12575 (char *) "self",(char *) "pos",(char *) "mode", NULL
12576 };
12577
12578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12580 if (!SWIG_IsOK(res1)) {
12581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12582 }
12583 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12584 ecode2 = SWIG_AsVal_long(obj1, &val2);
12585 if (!SWIG_IsOK(ecode2)) {
12586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
12587 }
12588 arg2 = static_cast< long >(val2);
12589 if (obj2) {
12590 ecode3 = SWIG_AsVal_int(obj2, &val3);
12591 if (!SWIG_IsOK(ecode3)) {
12592 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
12593 }
12594 arg3 = static_cast< wxSeekMode >(val3);
12595 }
12596 {
12597 PyThreadState* __tstate = wxPyBeginAllowThreads();
12598 result = (long)(arg1)->SeekI(arg2,arg3);
12599 wxPyEndAllowThreads(__tstate);
12600 if (PyErr_Occurred()) SWIG_fail;
12601 }
12602 resultobj = SWIG_From_long(static_cast< long >(result));
12603 return resultobj;
12604 fail:
12605 return NULL;
12606 }
12607
12608
12609 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12610 PyObject *resultobj = 0;
12611 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12612 long result;
12613 void *argp1 = 0 ;
12614 int res1 = 0 ;
12615 PyObject *swig_obj[1] ;
12616
12617 if (!args) SWIG_fail;
12618 swig_obj[0] = args;
12619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12620 if (!SWIG_IsOK(res1)) {
12621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12622 }
12623 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12624 {
12625 PyThreadState* __tstate = wxPyBeginAllowThreads();
12626 result = (long)(arg1)->TellI();
12627 wxPyEndAllowThreads(__tstate);
12628 if (PyErr_Occurred()) SWIG_fail;
12629 }
12630 resultobj = SWIG_From_long(static_cast< long >(result));
12631 return resultobj;
12632 fail:
12633 return NULL;
12634 }
12635
12636
12637 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12638 PyObject *obj;
12639 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12640 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12641 return SWIG_Py_Void();
12642 }
12643
12644 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12645 return SWIG_Python_InitShadowInstance(args);
12646 }
12647
12648 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12649 PyObject *resultobj = 0;
12650 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12651 PyObject *arg2 = (PyObject *) 0 ;
12652 void *argp1 = 0 ;
12653 int res1 = 0 ;
12654 PyObject * obj0 = 0 ;
12655 PyObject * obj1 = 0 ;
12656 char * kwnames[] = {
12657 (char *) "self",(char *) "obj", NULL
12658 };
12659
12660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12662 if (!SWIG_IsOK(res1)) {
12663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12664 }
12665 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12666 arg2 = obj1;
12667 {
12668 PyThreadState* __tstate = wxPyBeginAllowThreads();
12669 wxOutputStream_write(arg1,arg2);
12670 wxPyEndAllowThreads(__tstate);
12671 if (PyErr_Occurred()) SWIG_fail;
12672 }
12673 resultobj = SWIG_Py_Void();
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *resultobj = 0;
12682 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12683 size_t result;
12684 void *argp1 = 0 ;
12685 int res1 = 0 ;
12686 PyObject *swig_obj[1] ;
12687
12688 if (!args) SWIG_fail;
12689 swig_obj[0] = args;
12690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12691 if (!SWIG_IsOK(res1)) {
12692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12693 }
12694 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12695 {
12696 PyThreadState* __tstate = wxPyBeginAllowThreads();
12697 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12702 return resultobj;
12703 fail:
12704 return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12709 PyObject *obj;
12710 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12711 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12712 return SWIG_Py_Void();
12713 }
12714
12715 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12716 PyObject *resultobj = 0;
12717 wxInputStream *arg1 = (wxInputStream *) 0 ;
12718 wxString *arg2 = 0 ;
12719 wxString *arg3 = 0 ;
12720 wxString *arg4 = 0 ;
12721 wxDateTime arg5 ;
12722 wxFSFile *result = 0 ;
12723 wxPyInputStream *temp1 ;
12724 bool temp2 = false ;
12725 bool temp3 = false ;
12726 bool temp4 = false ;
12727 void *argp5 ;
12728 int res5 = 0 ;
12729 PyObject * obj0 = 0 ;
12730 PyObject * obj1 = 0 ;
12731 PyObject * obj2 = 0 ;
12732 PyObject * obj3 = 0 ;
12733 PyObject * obj4 = 0 ;
12734 char * kwnames[] = {
12735 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12736 };
12737
12738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12739 {
12740 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12741 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12742 } else {
12743 PyErr_Clear(); // clear the failure of the wxPyConvert above
12744 arg1 = wxPyCBInputStream_create(obj0, true);
12745 if (arg1 == NULL) {
12746 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12747 SWIG_fail;
12748 }
12749 }
12750 }
12751 {
12752 arg2 = wxString_in_helper(obj1);
12753 if (arg2 == NULL) SWIG_fail;
12754 temp2 = true;
12755 }
12756 {
12757 arg3 = wxString_in_helper(obj2);
12758 if (arg3 == NULL) SWIG_fail;
12759 temp3 = true;
12760 }
12761 {
12762 arg4 = wxString_in_helper(obj3);
12763 if (arg4 == NULL) SWIG_fail;
12764 temp4 = true;
12765 }
12766 {
12767 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12768 if (!SWIG_IsOK(res5)) {
12769 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12770 }
12771 if (!argp5) {
12772 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12773 } else {
12774 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12775 arg5 = *temp;
12776 if (SWIG_IsNewObj(res5)) delete temp;
12777 }
12778 }
12779 {
12780 PyThreadState* __tstate = wxPyBeginAllowThreads();
12781 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12782 wxPyEndAllowThreads(__tstate);
12783 if (PyErr_Occurred()) SWIG_fail;
12784 }
12785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12786 {
12787 if (temp2)
12788 delete arg2;
12789 }
12790 {
12791 if (temp3)
12792 delete arg3;
12793 }
12794 {
12795 if (temp4)
12796 delete arg4;
12797 }
12798 return resultobj;
12799 fail:
12800 {
12801 if (temp2)
12802 delete arg2;
12803 }
12804 {
12805 if (temp3)
12806 delete arg3;
12807 }
12808 {
12809 if (temp4)
12810 delete arg4;
12811 }
12812 return NULL;
12813 }
12814
12815
12816 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12817 PyObject *resultobj = 0;
12818 wxFSFile *arg1 = (wxFSFile *) 0 ;
12819 void *argp1 = 0 ;
12820 int res1 = 0 ;
12821 PyObject *swig_obj[1] ;
12822
12823 if (!args) SWIG_fail;
12824 swig_obj[0] = args;
12825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12826 if (!SWIG_IsOK(res1)) {
12827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12828 }
12829 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12830 {
12831 PyThreadState* __tstate = wxPyBeginAllowThreads();
12832 delete arg1;
12833
12834 wxPyEndAllowThreads(__tstate);
12835 if (PyErr_Occurred()) SWIG_fail;
12836 }
12837 resultobj = SWIG_Py_Void();
12838 return resultobj;
12839 fail:
12840 return NULL;
12841 }
12842
12843
12844 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12845 PyObject *resultobj = 0;
12846 wxFSFile *arg1 = (wxFSFile *) 0 ;
12847 wxInputStream *result = 0 ;
12848 void *argp1 = 0 ;
12849 int res1 = 0 ;
12850 PyObject *swig_obj[1] ;
12851
12852 if (!args) SWIG_fail;
12853 swig_obj[0] = args;
12854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12855 if (!SWIG_IsOK(res1)) {
12856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12857 }
12858 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12859 {
12860 PyThreadState* __tstate = wxPyBeginAllowThreads();
12861 result = (wxInputStream *)(arg1)->GetStream();
12862 wxPyEndAllowThreads(__tstate);
12863 if (PyErr_Occurred()) SWIG_fail;
12864 }
12865 {
12866 wxPyInputStream * _ptr = NULL;
12867
12868 if (result) {
12869 _ptr = new wxPyInputStream(result);
12870 }
12871 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12872 }
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12880 PyObject *resultobj = 0;
12881 wxFSFile *arg1 = (wxFSFile *) 0 ;
12882 void *argp1 = 0 ;
12883 int res1 = 0 ;
12884 PyObject *swig_obj[1] ;
12885
12886 if (!args) SWIG_fail;
12887 swig_obj[0] = args;
12888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12889 if (!SWIG_IsOK(res1)) {
12890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12891 }
12892 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12893 {
12894 PyThreadState* __tstate = wxPyBeginAllowThreads();
12895 (arg1)->DetachStream();
12896 wxPyEndAllowThreads(__tstate);
12897 if (PyErr_Occurred()) SWIG_fail;
12898 }
12899 resultobj = SWIG_Py_Void();
12900 return resultobj;
12901 fail:
12902 return NULL;
12903 }
12904
12905
12906 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12907 PyObject *resultobj = 0;
12908 wxFSFile *arg1 = (wxFSFile *) 0 ;
12909 wxString *result = 0 ;
12910 void *argp1 = 0 ;
12911 int res1 = 0 ;
12912 PyObject *swig_obj[1] ;
12913
12914 if (!args) SWIG_fail;
12915 swig_obj[0] = args;
12916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12917 if (!SWIG_IsOK(res1)) {
12918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12919 }
12920 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 {
12924 wxString const &_result_ref = (arg1)->GetMimeType();
12925 result = (wxString *) &_result_ref;
12926 }
12927 wxPyEndAllowThreads(__tstate);
12928 if (PyErr_Occurred()) SWIG_fail;
12929 }
12930 {
12931 #if wxUSE_UNICODE
12932 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12933 #else
12934 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12935 #endif
12936 }
12937 return resultobj;
12938 fail:
12939 return NULL;
12940 }
12941
12942
12943 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12944 PyObject *resultobj = 0;
12945 wxFSFile *arg1 = (wxFSFile *) 0 ;
12946 wxString *result = 0 ;
12947 void *argp1 = 0 ;
12948 int res1 = 0 ;
12949 PyObject *swig_obj[1] ;
12950
12951 if (!args) SWIG_fail;
12952 swig_obj[0] = args;
12953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12954 if (!SWIG_IsOK(res1)) {
12955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12956 }
12957 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 {
12961 wxString const &_result_ref = (arg1)->GetLocation();
12962 result = (wxString *) &_result_ref;
12963 }
12964 wxPyEndAllowThreads(__tstate);
12965 if (PyErr_Occurred()) SWIG_fail;
12966 }
12967 {
12968 #if wxUSE_UNICODE
12969 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12970 #else
12971 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12972 #endif
12973 }
12974 return resultobj;
12975 fail:
12976 return NULL;
12977 }
12978
12979
12980 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12981 PyObject *resultobj = 0;
12982 wxFSFile *arg1 = (wxFSFile *) 0 ;
12983 wxString *result = 0 ;
12984 void *argp1 = 0 ;
12985 int res1 = 0 ;
12986 PyObject *swig_obj[1] ;
12987
12988 if (!args) SWIG_fail;
12989 swig_obj[0] = args;
12990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12991 if (!SWIG_IsOK(res1)) {
12992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12993 }
12994 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12995 {
12996 PyThreadState* __tstate = wxPyBeginAllowThreads();
12997 {
12998 wxString const &_result_ref = (arg1)->GetAnchor();
12999 result = (wxString *) &_result_ref;
13000 }
13001 wxPyEndAllowThreads(__tstate);
13002 if (PyErr_Occurred()) SWIG_fail;
13003 }
13004 {
13005 #if wxUSE_UNICODE
13006 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
13007 #else
13008 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
13009 #endif
13010 }
13011 return resultobj;
13012 fail:
13013 return NULL;
13014 }
13015
13016
13017 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13018 PyObject *resultobj = 0;
13019 wxFSFile *arg1 = (wxFSFile *) 0 ;
13020 wxDateTime result;
13021 void *argp1 = 0 ;
13022 int res1 = 0 ;
13023 PyObject *swig_obj[1] ;
13024
13025 if (!args) SWIG_fail;
13026 swig_obj[0] = args;
13027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
13028 if (!SWIG_IsOK(res1)) {
13029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
13030 }
13031 arg1 = reinterpret_cast< wxFSFile * >(argp1);
13032 {
13033 PyThreadState* __tstate = wxPyBeginAllowThreads();
13034 result = (arg1)->GetModificationTime();
13035 wxPyEndAllowThreads(__tstate);
13036 if (PyErr_Occurred()) SWIG_fail;
13037 }
13038 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
13039 return resultobj;
13040 fail:
13041 return NULL;
13042 }
13043
13044
13045 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13046 PyObject *obj;
13047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13048 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
13049 return SWIG_Py_Void();
13050 }
13051
13052 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13053 return SWIG_Python_InitShadowInstance(args);
13054 }
13055
13056 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 PyObject *resultobj = 0;
13058 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13059 void *argp1 = 0 ;
13060 int res1 = 0 ;
13061 PyObject *swig_obj[1] ;
13062
13063 if (!args) SWIG_fail;
13064 swig_obj[0] = args;
13065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13066 if (!SWIG_IsOK(res1)) {
13067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13068 }
13069 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13070 {
13071 PyThreadState* __tstate = wxPyBeginAllowThreads();
13072 delete arg1;
13073
13074 wxPyEndAllowThreads(__tstate);
13075 if (PyErr_Occurred()) SWIG_fail;
13076 }
13077 resultobj = SWIG_Py_Void();
13078 return resultobj;
13079 fail:
13080 return NULL;
13081 }
13082
13083
13084 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13085 PyObject *obj;
13086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13087 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
13088 return SWIG_Py_Void();
13089 }
13090
13091 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13092 PyObject *resultobj = 0;
13093 wxPyFileSystemHandler *result = 0 ;
13094
13095 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
13096 {
13097 PyThreadState* __tstate = wxPyBeginAllowThreads();
13098 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
13099 wxPyEndAllowThreads(__tstate);
13100 if (PyErr_Occurred()) SWIG_fail;
13101 }
13102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
13103 return resultobj;
13104 fail:
13105 return NULL;
13106 }
13107
13108
13109 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13110 PyObject *resultobj = 0;
13111 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13112 PyObject *arg2 = (PyObject *) 0 ;
13113 PyObject *arg3 = (PyObject *) 0 ;
13114 void *argp1 = 0 ;
13115 int res1 = 0 ;
13116 PyObject * obj0 = 0 ;
13117 PyObject * obj1 = 0 ;
13118 PyObject * obj2 = 0 ;
13119 char * kwnames[] = {
13120 (char *) "self",(char *) "self",(char *) "_class", NULL
13121 };
13122
13123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13125 if (!SWIG_IsOK(res1)) {
13126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13127 }
13128 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13129 arg2 = obj1;
13130 arg3 = obj2;
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 (arg1)->_setCallbackInfo(arg2,arg3);
13134 wxPyEndAllowThreads(__tstate);
13135 if (PyErr_Occurred()) SWIG_fail;
13136 }
13137 resultobj = SWIG_Py_Void();
13138 return resultobj;
13139 fail:
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13145 PyObject *resultobj = 0;
13146 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13147 wxString *arg2 = 0 ;
13148 bool result;
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:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13160 if (!SWIG_IsOK(res1)) {
13161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13162 }
13163 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(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 = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13172 wxPyEndAllowThreads(__tstate);
13173 if (PyErr_Occurred()) SWIG_fail;
13174 }
13175 {
13176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
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_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13193 PyObject *resultobj = 0;
13194 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13195 wxFileSystem *arg2 = 0 ;
13196 wxString *arg3 = 0 ;
13197 wxFSFile *result = 0 ;
13198 void *argp1 = 0 ;
13199 int res1 = 0 ;
13200 void *argp2 = 0 ;
13201 int res2 = 0 ;
13202 bool temp3 = false ;
13203 PyObject * obj0 = 0 ;
13204 PyObject * obj1 = 0 ;
13205 PyObject * obj2 = 0 ;
13206 char * kwnames[] = {
13207 (char *) "self",(char *) "fs",(char *) "location", NULL
13208 };
13209
13210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13212 if (!SWIG_IsOK(res1)) {
13213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13214 }
13215 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13216 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13217 if (!SWIG_IsOK(res2)) {
13218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13219 }
13220 if (!argp2) {
13221 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13222 }
13223 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13224 {
13225 arg3 = wxString_in_helper(obj2);
13226 if (arg3 == NULL) SWIG_fail;
13227 temp3 = true;
13228 }
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 {
13236 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13237 }
13238 {
13239 if (temp3)
13240 delete arg3;
13241 }
13242 return resultobj;
13243 fail:
13244 {
13245 if (temp3)
13246 delete arg3;
13247 }
13248 return NULL;
13249 }
13250
13251
13252 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13253 PyObject *resultobj = 0;
13254 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13255 wxString *arg2 = 0 ;
13256 int arg3 = (int) 0 ;
13257 wxString result;
13258 void *argp1 = 0 ;
13259 int res1 = 0 ;
13260 bool temp2 = false ;
13261 int val3 ;
13262 int ecode3 = 0 ;
13263 PyObject * obj0 = 0 ;
13264 PyObject * obj1 = 0 ;
13265 PyObject * obj2 = 0 ;
13266 char * kwnames[] = {
13267 (char *) "self",(char *) "spec",(char *) "flags", NULL
13268 };
13269
13270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13272 if (!SWIG_IsOK(res1)) {
13273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13274 }
13275 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13276 {
13277 arg2 = wxString_in_helper(obj1);
13278 if (arg2 == NULL) SWIG_fail;
13279 temp2 = true;
13280 }
13281 if (obj2) {
13282 ecode3 = SWIG_AsVal_int(obj2, &val3);
13283 if (!SWIG_IsOK(ecode3)) {
13284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13285 }
13286 arg3 = static_cast< int >(val3);
13287 }
13288 {
13289 PyThreadState* __tstate = wxPyBeginAllowThreads();
13290 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13291 wxPyEndAllowThreads(__tstate);
13292 if (PyErr_Occurred()) SWIG_fail;
13293 }
13294 {
13295 #if wxUSE_UNICODE
13296 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13297 #else
13298 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13299 #endif
13300 }
13301 {
13302 if (temp2)
13303 delete arg2;
13304 }
13305 return resultobj;
13306 fail:
13307 {
13308 if (temp2)
13309 delete arg2;
13310 }
13311 return NULL;
13312 }
13313
13314
13315 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13316 PyObject *resultobj = 0;
13317 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13318 wxString result;
13319 void *argp1 = 0 ;
13320 int res1 = 0 ;
13321 PyObject *swig_obj[1] ;
13322
13323 if (!args) SWIG_fail;
13324 swig_obj[0] = args;
13325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13326 if (!SWIG_IsOK(res1)) {
13327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13328 }
13329 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13330 {
13331 PyThreadState* __tstate = wxPyBeginAllowThreads();
13332 result = (arg1)->FindNext();
13333 wxPyEndAllowThreads(__tstate);
13334 if (PyErr_Occurred()) SWIG_fail;
13335 }
13336 {
13337 #if wxUSE_UNICODE
13338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13339 #else
13340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13341 #endif
13342 }
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13350 PyObject *resultobj = 0;
13351 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13352 wxString *arg2 = 0 ;
13353 wxString result;
13354 void *argp1 = 0 ;
13355 int res1 = 0 ;
13356 bool temp2 = false ;
13357 PyObject * obj0 = 0 ;
13358 PyObject * obj1 = 0 ;
13359 char * kwnames[] = {
13360 (char *) "self",(char *) "location", NULL
13361 };
13362
13363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
13364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13365 if (!SWIG_IsOK(res1)) {
13366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13367 }
13368 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13369 {
13370 arg2 = wxString_in_helper(obj1);
13371 if (arg2 == NULL) SWIG_fail;
13372 temp2 = true;
13373 }
13374 {
13375 PyThreadState* __tstate = wxPyBeginAllowThreads();
13376 result = (arg1)->GetProtocol((wxString const &)*arg2);
13377 wxPyEndAllowThreads(__tstate);
13378 if (PyErr_Occurred()) SWIG_fail;
13379 }
13380 {
13381 #if wxUSE_UNICODE
13382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13383 #else
13384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13385 #endif
13386 }
13387 {
13388 if (temp2)
13389 delete arg2;
13390 }
13391 return resultobj;
13392 fail:
13393 {
13394 if (temp2)
13395 delete arg2;
13396 }
13397 return NULL;
13398 }
13399
13400
13401 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13402 PyObject *resultobj = 0;
13403 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13404 wxString *arg2 = 0 ;
13405 wxString result;
13406 void *argp1 = 0 ;
13407 int res1 = 0 ;
13408 bool temp2 = false ;
13409 PyObject * obj0 = 0 ;
13410 PyObject * obj1 = 0 ;
13411 char * kwnames[] = {
13412 (char *) "self",(char *) "location", NULL
13413 };
13414
13415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13417 if (!SWIG_IsOK(res1)) {
13418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13419 }
13420 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13421 {
13422 arg2 = wxString_in_helper(obj1);
13423 if (arg2 == NULL) SWIG_fail;
13424 temp2 = true;
13425 }
13426 {
13427 PyThreadState* __tstate = wxPyBeginAllowThreads();
13428 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
13429 wxPyEndAllowThreads(__tstate);
13430 if (PyErr_Occurred()) SWIG_fail;
13431 }
13432 {
13433 #if wxUSE_UNICODE
13434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13435 #else
13436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13437 #endif
13438 }
13439 {
13440 if (temp2)
13441 delete arg2;
13442 }
13443 return resultobj;
13444 fail:
13445 {
13446 if (temp2)
13447 delete arg2;
13448 }
13449 return NULL;
13450 }
13451
13452
13453 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13454 PyObject *resultobj = 0;
13455 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13456 wxString *arg2 = 0 ;
13457 wxString result;
13458 void *argp1 = 0 ;
13459 int res1 = 0 ;
13460 bool temp2 = false ;
13461 PyObject * obj0 = 0 ;
13462 PyObject * obj1 = 0 ;
13463 char * kwnames[] = {
13464 (char *) "self",(char *) "location", NULL
13465 };
13466
13467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
13468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13469 if (!SWIG_IsOK(res1)) {
13470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13471 }
13472 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13473 {
13474 arg2 = wxString_in_helper(obj1);
13475 if (arg2 == NULL) SWIG_fail;
13476 temp2 = true;
13477 }
13478 {
13479 PyThreadState* __tstate = wxPyBeginAllowThreads();
13480 result = (arg1)->GetAnchor((wxString const &)*arg2);
13481 wxPyEndAllowThreads(__tstate);
13482 if (PyErr_Occurred()) SWIG_fail;
13483 }
13484 {
13485 #if wxUSE_UNICODE
13486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13487 #else
13488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13489 #endif
13490 }
13491 {
13492 if (temp2)
13493 delete arg2;
13494 }
13495 return resultobj;
13496 fail:
13497 {
13498 if (temp2)
13499 delete arg2;
13500 }
13501 return NULL;
13502 }
13503
13504
13505 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13506 PyObject *resultobj = 0;
13507 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13508 wxString *arg2 = 0 ;
13509 wxString result;
13510 void *argp1 = 0 ;
13511 int res1 = 0 ;
13512 bool temp2 = false ;
13513 PyObject * obj0 = 0 ;
13514 PyObject * obj1 = 0 ;
13515 char * kwnames[] = {
13516 (char *) "self",(char *) "location", NULL
13517 };
13518
13519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
13520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13521 if (!SWIG_IsOK(res1)) {
13522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13523 }
13524 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13525 {
13526 arg2 = wxString_in_helper(obj1);
13527 if (arg2 == NULL) SWIG_fail;
13528 temp2 = true;
13529 }
13530 {
13531 PyThreadState* __tstate = wxPyBeginAllowThreads();
13532 result = (arg1)->GetRightLocation((wxString const &)*arg2);
13533 wxPyEndAllowThreads(__tstate);
13534 if (PyErr_Occurred()) SWIG_fail;
13535 }
13536 {
13537 #if wxUSE_UNICODE
13538 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13539 #else
13540 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13541 #endif
13542 }
13543 {
13544 if (temp2)
13545 delete arg2;
13546 }
13547 return resultobj;
13548 fail:
13549 {
13550 if (temp2)
13551 delete arg2;
13552 }
13553 return NULL;
13554 }
13555
13556
13557 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13558 PyObject *resultobj = 0;
13559 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
13560 wxString *arg2 = 0 ;
13561 wxString result;
13562 void *argp1 = 0 ;
13563 int res1 = 0 ;
13564 bool temp2 = false ;
13565 PyObject * obj0 = 0 ;
13566 PyObject * obj1 = 0 ;
13567 char * kwnames[] = {
13568 (char *) "self",(char *) "location", NULL
13569 };
13570
13571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
13572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
13573 if (!SWIG_IsOK(res1)) {
13574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
13575 }
13576 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
13577 {
13578 arg2 = wxString_in_helper(obj1);
13579 if (arg2 == NULL) SWIG_fail;
13580 temp2 = true;
13581 }
13582 {
13583 PyThreadState* __tstate = wxPyBeginAllowThreads();
13584 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
13585 wxPyEndAllowThreads(__tstate);
13586 if (PyErr_Occurred()) SWIG_fail;
13587 }
13588 {
13589 #if wxUSE_UNICODE
13590 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13591 #else
13592 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13593 #endif
13594 }
13595 {
13596 if (temp2)
13597 delete arg2;
13598 }
13599 return resultobj;
13600 fail:
13601 {
13602 if (temp2)
13603 delete arg2;
13604 }
13605 return NULL;
13606 }
13607
13608
13609 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13610 PyObject *obj;
13611 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13612 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13613 return SWIG_Py_Void();
13614 }
13615
13616 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13617 return SWIG_Python_InitShadowInstance(args);
13618 }
13619
13620 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13621 PyObject *resultobj = 0;
13622 wxFileSystem *result = 0 ;
13623
13624 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13625 {
13626 PyThreadState* __tstate = wxPyBeginAllowThreads();
13627 result = (wxFileSystem *)new wxFileSystem();
13628 wxPyEndAllowThreads(__tstate);
13629 if (PyErr_Occurred()) SWIG_fail;
13630 }
13631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13632 return resultobj;
13633 fail:
13634 return NULL;
13635 }
13636
13637
13638 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13639 PyObject *resultobj = 0;
13640 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13641 void *argp1 = 0 ;
13642 int res1 = 0 ;
13643 PyObject *swig_obj[1] ;
13644
13645 if (!args) SWIG_fail;
13646 swig_obj[0] = args;
13647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13648 if (!SWIG_IsOK(res1)) {
13649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13650 }
13651 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13652 {
13653 PyThreadState* __tstate = wxPyBeginAllowThreads();
13654 delete arg1;
13655
13656 wxPyEndAllowThreads(__tstate);
13657 if (PyErr_Occurred()) SWIG_fail;
13658 }
13659 resultobj = SWIG_Py_Void();
13660 return resultobj;
13661 fail:
13662 return NULL;
13663 }
13664
13665
13666 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13667 PyObject *resultobj = 0;
13668 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13669 wxString *arg2 = 0 ;
13670 bool arg3 = (bool) false ;
13671 void *argp1 = 0 ;
13672 int res1 = 0 ;
13673 bool temp2 = false ;
13674 bool val3 ;
13675 int ecode3 = 0 ;
13676 PyObject * obj0 = 0 ;
13677 PyObject * obj1 = 0 ;
13678 PyObject * obj2 = 0 ;
13679 char * kwnames[] = {
13680 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13681 };
13682
13683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13685 if (!SWIG_IsOK(res1)) {
13686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13687 }
13688 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13689 {
13690 arg2 = wxString_in_helper(obj1);
13691 if (arg2 == NULL) SWIG_fail;
13692 temp2 = true;
13693 }
13694 if (obj2) {
13695 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13696 if (!SWIG_IsOK(ecode3)) {
13697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13698 }
13699 arg3 = static_cast< bool >(val3);
13700 }
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 resultobj = SWIG_Py_Void();
13708 {
13709 if (temp2)
13710 delete arg2;
13711 }
13712 return resultobj;
13713 fail:
13714 {
13715 if (temp2)
13716 delete arg2;
13717 }
13718 return NULL;
13719 }
13720
13721
13722 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13723 PyObject *resultobj = 0;
13724 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13725 wxString result;
13726 void *argp1 = 0 ;
13727 int res1 = 0 ;
13728 PyObject *swig_obj[1] ;
13729
13730 if (!args) SWIG_fail;
13731 swig_obj[0] = args;
13732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13733 if (!SWIG_IsOK(res1)) {
13734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13735 }
13736 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13737 {
13738 PyThreadState* __tstate = wxPyBeginAllowThreads();
13739 result = (arg1)->GetPath();
13740 wxPyEndAllowThreads(__tstate);
13741 if (PyErr_Occurred()) SWIG_fail;
13742 }
13743 {
13744 #if wxUSE_UNICODE
13745 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13746 #else
13747 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13748 #endif
13749 }
13750 return resultobj;
13751 fail:
13752 return NULL;
13753 }
13754
13755
13756 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13757 PyObject *resultobj = 0;
13758 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13759 wxString *arg2 = 0 ;
13760 wxFSFile *result = 0 ;
13761 void *argp1 = 0 ;
13762 int res1 = 0 ;
13763 bool temp2 = false ;
13764 PyObject * obj0 = 0 ;
13765 PyObject * obj1 = 0 ;
13766 char * kwnames[] = {
13767 (char *) "self",(char *) "location", NULL
13768 };
13769
13770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13772 if (!SWIG_IsOK(res1)) {
13773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13774 }
13775 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13776 {
13777 arg2 = wxString_in_helper(obj1);
13778 if (arg2 == NULL) SWIG_fail;
13779 temp2 = true;
13780 }
13781 {
13782 PyThreadState* __tstate = wxPyBeginAllowThreads();
13783 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13784 wxPyEndAllowThreads(__tstate);
13785 if (PyErr_Occurred()) SWIG_fail;
13786 }
13787 {
13788 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13789 }
13790 {
13791 if (temp2)
13792 delete arg2;
13793 }
13794 return resultobj;
13795 fail:
13796 {
13797 if (temp2)
13798 delete arg2;
13799 }
13800 return NULL;
13801 }
13802
13803
13804 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13805 PyObject *resultobj = 0;
13806 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13807 wxString *arg2 = 0 ;
13808 int arg3 = (int) 0 ;
13809 wxString result;
13810 void *argp1 = 0 ;
13811 int res1 = 0 ;
13812 bool temp2 = false ;
13813 int val3 ;
13814 int ecode3 = 0 ;
13815 PyObject * obj0 = 0 ;
13816 PyObject * obj1 = 0 ;
13817 PyObject * obj2 = 0 ;
13818 char * kwnames[] = {
13819 (char *) "self",(char *) "spec",(char *) "flags", NULL
13820 };
13821
13822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13824 if (!SWIG_IsOK(res1)) {
13825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13826 }
13827 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13828 {
13829 arg2 = wxString_in_helper(obj1);
13830 if (arg2 == NULL) SWIG_fail;
13831 temp2 = true;
13832 }
13833 if (obj2) {
13834 ecode3 = SWIG_AsVal_int(obj2, &val3);
13835 if (!SWIG_IsOK(ecode3)) {
13836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13837 }
13838 arg3 = static_cast< int >(val3);
13839 }
13840 {
13841 PyThreadState* __tstate = wxPyBeginAllowThreads();
13842 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13843 wxPyEndAllowThreads(__tstate);
13844 if (PyErr_Occurred()) SWIG_fail;
13845 }
13846 {
13847 #if wxUSE_UNICODE
13848 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13849 #else
13850 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13851 #endif
13852 }
13853 {
13854 if (temp2)
13855 delete arg2;
13856 }
13857 return resultobj;
13858 fail:
13859 {
13860 if (temp2)
13861 delete arg2;
13862 }
13863 return NULL;
13864 }
13865
13866
13867 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13868 PyObject *resultobj = 0;
13869 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13870 wxString result;
13871 void *argp1 = 0 ;
13872 int res1 = 0 ;
13873 PyObject *swig_obj[1] ;
13874
13875 if (!args) SWIG_fail;
13876 swig_obj[0] = args;
13877 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13878 if (!SWIG_IsOK(res1)) {
13879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13880 }
13881 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13882 {
13883 PyThreadState* __tstate = wxPyBeginAllowThreads();
13884 result = (arg1)->FindNext();
13885 wxPyEndAllowThreads(__tstate);
13886 if (PyErr_Occurred()) SWIG_fail;
13887 }
13888 {
13889 #if wxUSE_UNICODE
13890 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13891 #else
13892 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13893 #endif
13894 }
13895 return resultobj;
13896 fail:
13897 return NULL;
13898 }
13899
13900
13901 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13902 PyObject *resultobj = 0;
13903 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13904 int res1 = 0 ;
13905 PyObject * obj0 = 0 ;
13906 char * kwnames[] = {
13907 (char *) "handler", NULL
13908 };
13909
13910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13911 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13912 if (!SWIG_IsOK(res1)) {
13913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13914 }
13915 {
13916 PyThreadState* __tstate = wxPyBeginAllowThreads();
13917 wxFileSystem::AddHandler(arg1);
13918 wxPyEndAllowThreads(__tstate);
13919 if (PyErr_Occurred()) SWIG_fail;
13920 }
13921 resultobj = SWIG_Py_Void();
13922 return resultobj;
13923 fail:
13924 return NULL;
13925 }
13926
13927
13928 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13929 PyObject *resultobj = 0;
13930 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13931 wxFileSystemHandler *result = 0 ;
13932 void *argp1 = 0 ;
13933 int res1 = 0 ;
13934 PyObject * obj0 = 0 ;
13935 char * kwnames[] = {
13936 (char *) "handler", NULL
13937 };
13938
13939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13941 if (!SWIG_IsOK(res1)) {
13942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13943 }
13944 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13945 {
13946 PyThreadState* __tstate = wxPyBeginAllowThreads();
13947 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13948 wxPyEndAllowThreads(__tstate);
13949 if (PyErr_Occurred()) SWIG_fail;
13950 }
13951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13952 return resultobj;
13953 fail:
13954 return NULL;
13955 }
13956
13957
13958 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13959 PyObject *resultobj = 0;
13960
13961 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13962 {
13963 PyThreadState* __tstate = wxPyBeginAllowThreads();
13964 wxFileSystem::CleanUpHandlers();
13965 wxPyEndAllowThreads(__tstate);
13966 if (PyErr_Occurred()) SWIG_fail;
13967 }
13968 resultobj = SWIG_Py_Void();
13969 return resultobj;
13970 fail:
13971 return NULL;
13972 }
13973
13974
13975 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13976 PyObject *resultobj = 0;
13977 wxString *arg1 = 0 ;
13978 wxString result;
13979 bool temp1 = false ;
13980 PyObject * obj0 = 0 ;
13981 char * kwnames[] = {
13982 (char *) "filename", NULL
13983 };
13984
13985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13986 {
13987 arg1 = wxString_in_helper(obj0);
13988 if (arg1 == NULL) SWIG_fail;
13989 temp1 = true;
13990 }
13991 {
13992 PyThreadState* __tstate = wxPyBeginAllowThreads();
13993 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13994 wxPyEndAllowThreads(__tstate);
13995 if (PyErr_Occurred()) SWIG_fail;
13996 }
13997 {
13998 #if wxUSE_UNICODE
13999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14000 #else
14001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14002 #endif
14003 }
14004 {
14005 if (temp1)
14006 delete arg1;
14007 }
14008 return resultobj;
14009 fail:
14010 {
14011 if (temp1)
14012 delete arg1;
14013 }
14014 return NULL;
14015 }
14016
14017
14018 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14019 PyObject *resultobj = 0;
14020 wxString *arg1 = 0 ;
14021 wxString result;
14022 bool temp1 = false ;
14023 PyObject * obj0 = 0 ;
14024 char * kwnames[] = {
14025 (char *) "url", NULL
14026 };
14027
14028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
14029 {
14030 arg1 = wxString_in_helper(obj0);
14031 if (arg1 == NULL) SWIG_fail;
14032 temp1 = true;
14033 }
14034 {
14035 PyThreadState* __tstate = wxPyBeginAllowThreads();
14036 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
14037 wxPyEndAllowThreads(__tstate);
14038 if (PyErr_Occurred()) SWIG_fail;
14039 }
14040 {
14041 #if wxUSE_UNICODE
14042 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14043 #else
14044 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14045 #endif
14046 }
14047 {
14048 if (temp1)
14049 delete arg1;
14050 }
14051 return resultobj;
14052 fail:
14053 {
14054 if (temp1)
14055 delete arg1;
14056 }
14057 return NULL;
14058 }
14059
14060
14061 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14062 PyObject *obj;
14063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14064 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
14065 return SWIG_Py_Void();
14066 }
14067
14068 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14069 return SWIG_Python_InitShadowInstance(args);
14070 }
14071
14072 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14073 PyObject *resultobj = 0;
14074 wxInternetFSHandler *result = 0 ;
14075
14076 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
14077 {
14078 PyThreadState* __tstate = wxPyBeginAllowThreads();
14079 result = (wxInternetFSHandler *)new wxInternetFSHandler();
14080 wxPyEndAllowThreads(__tstate);
14081 if (PyErr_Occurred()) SWIG_fail;
14082 }
14083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
14084 return resultobj;
14085 fail:
14086 return NULL;
14087 }
14088
14089
14090 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14091 PyObject *resultobj = 0;
14092 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14093 wxString *arg2 = 0 ;
14094 bool result;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 bool temp2 = false ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 char * kwnames[] = {
14101 (char *) "self",(char *) "location", NULL
14102 };
14103
14104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14106 if (!SWIG_IsOK(res1)) {
14107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14108 }
14109 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14110 {
14111 arg2 = wxString_in_helper(obj1);
14112 if (arg2 == NULL) SWIG_fail;
14113 temp2 = true;
14114 }
14115 {
14116 PyThreadState* __tstate = wxPyBeginAllowThreads();
14117 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14118 wxPyEndAllowThreads(__tstate);
14119 if (PyErr_Occurred()) SWIG_fail;
14120 }
14121 {
14122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14123 }
14124 {
14125 if (temp2)
14126 delete arg2;
14127 }
14128 return resultobj;
14129 fail:
14130 {
14131 if (temp2)
14132 delete arg2;
14133 }
14134 return NULL;
14135 }
14136
14137
14138 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj = 0;
14140 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
14141 wxFileSystem *arg2 = 0 ;
14142 wxString *arg3 = 0 ;
14143 wxFSFile *result = 0 ;
14144 void *argp1 = 0 ;
14145 int res1 = 0 ;
14146 void *argp2 = 0 ;
14147 int res2 = 0 ;
14148 bool temp3 = false ;
14149 PyObject * obj0 = 0 ;
14150 PyObject * obj1 = 0 ;
14151 PyObject * obj2 = 0 ;
14152 char * kwnames[] = {
14153 (char *) "self",(char *) "fs",(char *) "location", NULL
14154 };
14155
14156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
14158 if (!SWIG_IsOK(res1)) {
14159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
14160 }
14161 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
14162 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14163 if (!SWIG_IsOK(res2)) {
14164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14165 }
14166 if (!argp2) {
14167 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14168 }
14169 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14170 {
14171 arg3 = wxString_in_helper(obj2);
14172 if (arg3 == NULL) SWIG_fail;
14173 temp3 = true;
14174 }
14175 {
14176 PyThreadState* __tstate = wxPyBeginAllowThreads();
14177 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 {
14182 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14183 }
14184 {
14185 if (temp3)
14186 delete arg3;
14187 }
14188 return resultobj;
14189 fail:
14190 {
14191 if (temp3)
14192 delete arg3;
14193 }
14194 return NULL;
14195 }
14196
14197
14198 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14199 PyObject *obj;
14200 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14201 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
14202 return SWIG_Py_Void();
14203 }
14204
14205 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14206 return SWIG_Python_InitShadowInstance(args);
14207 }
14208
14209 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14210 PyObject *resultobj = 0;
14211 wxZipFSHandler *result = 0 ;
14212
14213 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
14214 {
14215 PyThreadState* __tstate = wxPyBeginAllowThreads();
14216 result = (wxZipFSHandler *)new wxZipFSHandler();
14217 wxPyEndAllowThreads(__tstate);
14218 if (PyErr_Occurred()) SWIG_fail;
14219 }
14220 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
14221 return resultobj;
14222 fail:
14223 return NULL;
14224 }
14225
14226
14227 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14228 PyObject *resultobj = 0;
14229 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14230 wxString *arg2 = 0 ;
14231 bool result;
14232 void *argp1 = 0 ;
14233 int res1 = 0 ;
14234 bool temp2 = false ;
14235 PyObject * obj0 = 0 ;
14236 PyObject * obj1 = 0 ;
14237 char * kwnames[] = {
14238 (char *) "self",(char *) "location", NULL
14239 };
14240
14241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14243 if (!SWIG_IsOK(res1)) {
14244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14245 }
14246 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14247 {
14248 arg2 = wxString_in_helper(obj1);
14249 if (arg2 == NULL) SWIG_fail;
14250 temp2 = true;
14251 }
14252 {
14253 PyThreadState* __tstate = wxPyBeginAllowThreads();
14254 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14255 wxPyEndAllowThreads(__tstate);
14256 if (PyErr_Occurred()) SWIG_fail;
14257 }
14258 {
14259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14260 }
14261 {
14262 if (temp2)
14263 delete arg2;
14264 }
14265 return resultobj;
14266 fail:
14267 {
14268 if (temp2)
14269 delete arg2;
14270 }
14271 return NULL;
14272 }
14273
14274
14275 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14276 PyObject *resultobj = 0;
14277 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14278 wxFileSystem *arg2 = 0 ;
14279 wxString *arg3 = 0 ;
14280 wxFSFile *result = 0 ;
14281 void *argp1 = 0 ;
14282 int res1 = 0 ;
14283 void *argp2 = 0 ;
14284 int res2 = 0 ;
14285 bool temp3 = false ;
14286 PyObject * obj0 = 0 ;
14287 PyObject * obj1 = 0 ;
14288 PyObject * obj2 = 0 ;
14289 char * kwnames[] = {
14290 (char *) "self",(char *) "fs",(char *) "location", NULL
14291 };
14292
14293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14295 if (!SWIG_IsOK(res1)) {
14296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14297 }
14298 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14299 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14300 if (!SWIG_IsOK(res2)) {
14301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14302 }
14303 if (!argp2) {
14304 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14305 }
14306 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14307 {
14308 arg3 = wxString_in_helper(obj2);
14309 if (arg3 == NULL) SWIG_fail;
14310 temp3 = true;
14311 }
14312 {
14313 PyThreadState* __tstate = wxPyBeginAllowThreads();
14314 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14315 wxPyEndAllowThreads(__tstate);
14316 if (PyErr_Occurred()) SWIG_fail;
14317 }
14318 {
14319 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14320 }
14321 {
14322 if (temp3)
14323 delete arg3;
14324 }
14325 return resultobj;
14326 fail:
14327 {
14328 if (temp3)
14329 delete arg3;
14330 }
14331 return NULL;
14332 }
14333
14334
14335 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14336 PyObject *resultobj = 0;
14337 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14338 wxString *arg2 = 0 ;
14339 int arg3 = (int) 0 ;
14340 wxString result;
14341 void *argp1 = 0 ;
14342 int res1 = 0 ;
14343 bool temp2 = false ;
14344 int val3 ;
14345 int ecode3 = 0 ;
14346 PyObject * obj0 = 0 ;
14347 PyObject * obj1 = 0 ;
14348 PyObject * obj2 = 0 ;
14349 char * kwnames[] = {
14350 (char *) "self",(char *) "spec",(char *) "flags", NULL
14351 };
14352
14353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14355 if (!SWIG_IsOK(res1)) {
14356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14357 }
14358 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14359 {
14360 arg2 = wxString_in_helper(obj1);
14361 if (arg2 == NULL) SWIG_fail;
14362 temp2 = true;
14363 }
14364 if (obj2) {
14365 ecode3 = SWIG_AsVal_int(obj2, &val3);
14366 if (!SWIG_IsOK(ecode3)) {
14367 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14368 }
14369 arg3 = static_cast< int >(val3);
14370 }
14371 {
14372 PyThreadState* __tstate = wxPyBeginAllowThreads();
14373 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14374 wxPyEndAllowThreads(__tstate);
14375 if (PyErr_Occurred()) SWIG_fail;
14376 }
14377 {
14378 #if wxUSE_UNICODE
14379 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14380 #else
14381 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14382 #endif
14383 }
14384 {
14385 if (temp2)
14386 delete arg2;
14387 }
14388 return resultobj;
14389 fail:
14390 {
14391 if (temp2)
14392 delete arg2;
14393 }
14394 return NULL;
14395 }
14396
14397
14398 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14399 PyObject *resultobj = 0;
14400 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
14401 wxString result;
14402 void *argp1 = 0 ;
14403 int res1 = 0 ;
14404 PyObject *swig_obj[1] ;
14405
14406 if (!args) SWIG_fail;
14407 swig_obj[0] = args;
14408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
14409 if (!SWIG_IsOK(res1)) {
14410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
14411 }
14412 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
14413 {
14414 PyThreadState* __tstate = wxPyBeginAllowThreads();
14415 result = (arg1)->FindNext();
14416 wxPyEndAllowThreads(__tstate);
14417 if (PyErr_Occurred()) SWIG_fail;
14418 }
14419 {
14420 #if wxUSE_UNICODE
14421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14422 #else
14423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14424 #endif
14425 }
14426 return resultobj;
14427 fail:
14428 return NULL;
14429 }
14430
14431
14432 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14433 PyObject *obj;
14434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14435 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
14436 return SWIG_Py_Void();
14437 }
14438
14439 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14440 return SWIG_Python_InitShadowInstance(args);
14441 }
14442
14443 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14444 PyObject *resultobj = 0;
14445 wxString *arg1 = 0 ;
14446 wxImage *arg2 = 0 ;
14447 long arg3 ;
14448 bool temp1 = false ;
14449 void *argp2 = 0 ;
14450 int res2 = 0 ;
14451 long val3 ;
14452 int ecode3 = 0 ;
14453 PyObject * obj0 = 0 ;
14454 PyObject * obj1 = 0 ;
14455 PyObject * obj2 = 0 ;
14456 char * kwnames[] = {
14457 (char *) "filename",(char *) "image",(char *) "type", NULL
14458 };
14459
14460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14461 {
14462 arg1 = wxString_in_helper(obj0);
14463 if (arg1 == NULL) SWIG_fail;
14464 temp1 = true;
14465 }
14466 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
14467 if (!SWIG_IsOK(res2)) {
14468 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14469 }
14470 if (!argp2) {
14471 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
14472 }
14473 arg2 = reinterpret_cast< wxImage * >(argp2);
14474 ecode3 = SWIG_AsVal_long(obj2, &val3);
14475 if (!SWIG_IsOK(ecode3)) {
14476 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
14477 }
14478 arg3 = static_cast< long >(val3);
14479 {
14480 PyThreadState* __tstate = wxPyBeginAllowThreads();
14481 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
14482 wxPyEndAllowThreads(__tstate);
14483 if (PyErr_Occurred()) SWIG_fail;
14484 }
14485 resultobj = SWIG_Py_Void();
14486 {
14487 if (temp1)
14488 delete arg1;
14489 }
14490 return resultobj;
14491 fail:
14492 {
14493 if (temp1)
14494 delete arg1;
14495 }
14496 return NULL;
14497 }
14498
14499
14500 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj = 0;
14502 wxString *arg1 = 0 ;
14503 wxBitmap *arg2 = 0 ;
14504 long arg3 ;
14505 bool temp1 = false ;
14506 void *argp2 = 0 ;
14507 int res2 = 0 ;
14508 long val3 ;
14509 int ecode3 = 0 ;
14510 PyObject * obj0 = 0 ;
14511 PyObject * obj1 = 0 ;
14512 PyObject * obj2 = 0 ;
14513 char * kwnames[] = {
14514 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
14515 };
14516
14517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14518 {
14519 arg1 = wxString_in_helper(obj0);
14520 if (arg1 == NULL) SWIG_fail;
14521 temp1 = true;
14522 }
14523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
14524 if (!SWIG_IsOK(res2)) {
14525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14526 }
14527 if (!argp2) {
14528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
14529 }
14530 arg2 = reinterpret_cast< wxBitmap * >(argp2);
14531 ecode3 = SWIG_AsVal_long(obj2, &val3);
14532 if (!SWIG_IsOK(ecode3)) {
14533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
14534 }
14535 arg3 = static_cast< long >(val3);
14536 {
14537 PyThreadState* __tstate = wxPyBeginAllowThreads();
14538 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
14539 wxPyEndAllowThreads(__tstate);
14540 if (PyErr_Occurred()) SWIG_fail;
14541 }
14542 resultobj = SWIG_Py_Void();
14543 {
14544 if (temp1)
14545 delete arg1;
14546 }
14547 return resultobj;
14548 fail:
14549 {
14550 if (temp1)
14551 delete arg1;
14552 }
14553 return NULL;
14554 }
14555
14556
14557 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj = 0;
14559 wxString *arg1 = 0 ;
14560 PyObject *arg2 = (PyObject *) 0 ;
14561 bool temp1 = false ;
14562 PyObject * obj0 = 0 ;
14563 PyObject * obj1 = 0 ;
14564 char * kwnames[] = {
14565 (char *) "filename",(char *) "data", NULL
14566 };
14567
14568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
14569 {
14570 arg1 = wxString_in_helper(obj0);
14571 if (arg1 == NULL) SWIG_fail;
14572 temp1 = true;
14573 }
14574 arg2 = obj1;
14575 {
14576 PyThreadState* __tstate = wxPyBeginAllowThreads();
14577 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
14578 wxPyEndAllowThreads(__tstate);
14579 if (PyErr_Occurred()) SWIG_fail;
14580 }
14581 resultobj = SWIG_Py_Void();
14582 {
14583 if (temp1)
14584 delete arg1;
14585 }
14586 return resultobj;
14587 fail:
14588 {
14589 if (temp1)
14590 delete arg1;
14591 }
14592 return NULL;
14593 }
14594
14595
14596 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14597 PyObject *resultobj = 0;
14598 wxMemoryFSHandler *result = 0 ;
14599
14600 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
14601 {
14602 PyThreadState* __tstate = wxPyBeginAllowThreads();
14603 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj = 0;
14616 wxString *arg1 = 0 ;
14617 bool temp1 = false ;
14618 PyObject * obj0 = 0 ;
14619 char * kwnames[] = {
14620 (char *) "filename", NULL
14621 };
14622
14623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14624 {
14625 arg1 = wxString_in_helper(obj0);
14626 if (arg1 == NULL) SWIG_fail;
14627 temp1 = true;
14628 }
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14632 wxPyEndAllowThreads(__tstate);
14633 if (PyErr_Occurred()) SWIG_fail;
14634 }
14635 resultobj = SWIG_Py_Void();
14636 {
14637 if (temp1)
14638 delete arg1;
14639 }
14640 return resultobj;
14641 fail:
14642 {
14643 if (temp1)
14644 delete arg1;
14645 }
14646 return NULL;
14647 }
14648
14649
14650 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14651 PyObject *resultobj = 0;
14652 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14653 wxString *arg2 = 0 ;
14654 bool result;
14655 void *argp1 = 0 ;
14656 int res1 = 0 ;
14657 bool temp2 = false ;
14658 PyObject * obj0 = 0 ;
14659 PyObject * obj1 = 0 ;
14660 char * kwnames[] = {
14661 (char *) "self",(char *) "location", NULL
14662 };
14663
14664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14666 if (!SWIG_IsOK(res1)) {
14667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14668 }
14669 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14670 {
14671 arg2 = wxString_in_helper(obj1);
14672 if (arg2 == NULL) SWIG_fail;
14673 temp2 = true;
14674 }
14675 {
14676 PyThreadState* __tstate = wxPyBeginAllowThreads();
14677 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14678 wxPyEndAllowThreads(__tstate);
14679 if (PyErr_Occurred()) SWIG_fail;
14680 }
14681 {
14682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14683 }
14684 {
14685 if (temp2)
14686 delete arg2;
14687 }
14688 return resultobj;
14689 fail:
14690 {
14691 if (temp2)
14692 delete arg2;
14693 }
14694 return NULL;
14695 }
14696
14697
14698 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14699 PyObject *resultobj = 0;
14700 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14701 wxFileSystem *arg2 = 0 ;
14702 wxString *arg3 = 0 ;
14703 wxFSFile *result = 0 ;
14704 void *argp1 = 0 ;
14705 int res1 = 0 ;
14706 void *argp2 = 0 ;
14707 int res2 = 0 ;
14708 bool temp3 = false ;
14709 PyObject * obj0 = 0 ;
14710 PyObject * obj1 = 0 ;
14711 PyObject * obj2 = 0 ;
14712 char * kwnames[] = {
14713 (char *) "self",(char *) "fs",(char *) "location", NULL
14714 };
14715
14716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14718 if (!SWIG_IsOK(res1)) {
14719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14720 }
14721 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14723 if (!SWIG_IsOK(res2)) {
14724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14725 }
14726 if (!argp2) {
14727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14728 }
14729 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14730 {
14731 arg3 = wxString_in_helper(obj2);
14732 if (arg3 == NULL) SWIG_fail;
14733 temp3 = true;
14734 }
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 {
14742 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14743 }
14744 {
14745 if (temp3)
14746 delete arg3;
14747 }
14748 return resultobj;
14749 fail:
14750 {
14751 if (temp3)
14752 delete arg3;
14753 }
14754 return NULL;
14755 }
14756
14757
14758 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14759 PyObject *resultobj = 0;
14760 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14761 wxString *arg2 = 0 ;
14762 int arg3 = (int) 0 ;
14763 wxString result;
14764 void *argp1 = 0 ;
14765 int res1 = 0 ;
14766 bool temp2 = false ;
14767 int val3 ;
14768 int ecode3 = 0 ;
14769 PyObject * obj0 = 0 ;
14770 PyObject * obj1 = 0 ;
14771 PyObject * obj2 = 0 ;
14772 char * kwnames[] = {
14773 (char *) "self",(char *) "spec",(char *) "flags", NULL
14774 };
14775
14776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14778 if (!SWIG_IsOK(res1)) {
14779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14780 }
14781 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14782 {
14783 arg2 = wxString_in_helper(obj1);
14784 if (arg2 == NULL) SWIG_fail;
14785 temp2 = true;
14786 }
14787 if (obj2) {
14788 ecode3 = SWIG_AsVal_int(obj2, &val3);
14789 if (!SWIG_IsOK(ecode3)) {
14790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14791 }
14792 arg3 = static_cast< int >(val3);
14793 }
14794 {
14795 PyThreadState* __tstate = wxPyBeginAllowThreads();
14796 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14797 wxPyEndAllowThreads(__tstate);
14798 if (PyErr_Occurred()) SWIG_fail;
14799 }
14800 {
14801 #if wxUSE_UNICODE
14802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14803 #else
14804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14805 #endif
14806 }
14807 {
14808 if (temp2)
14809 delete arg2;
14810 }
14811 return resultobj;
14812 fail:
14813 {
14814 if (temp2)
14815 delete arg2;
14816 }
14817 return NULL;
14818 }
14819
14820
14821 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14822 PyObject *resultobj = 0;
14823 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14824 wxString result;
14825 void *argp1 = 0 ;
14826 int res1 = 0 ;
14827 PyObject *swig_obj[1] ;
14828
14829 if (!args) SWIG_fail;
14830 swig_obj[0] = args;
14831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14832 if (!SWIG_IsOK(res1)) {
14833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14834 }
14835 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 result = (arg1)->FindNext();
14839 wxPyEndAllowThreads(__tstate);
14840 if (PyErr_Occurred()) SWIG_fail;
14841 }
14842 {
14843 #if wxUSE_UNICODE
14844 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14845 #else
14846 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14847 #endif
14848 }
14849 return resultobj;
14850 fail:
14851 return NULL;
14852 }
14853
14854
14855 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14856 PyObject *obj;
14857 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14858 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14859 return SWIG_Py_Void();
14860 }
14861
14862 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 return SWIG_Python_InitShadowInstance(args);
14864 }
14865
14866 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14867 PyObject *resultobj = 0;
14868 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14869 wxString result;
14870 void *argp1 = 0 ;
14871 int res1 = 0 ;
14872 PyObject *swig_obj[1] ;
14873
14874 if (!args) SWIG_fail;
14875 swig_obj[0] = args;
14876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14877 if (!SWIG_IsOK(res1)) {
14878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14879 }
14880 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14881 {
14882 PyThreadState* __tstate = wxPyBeginAllowThreads();
14883 result = (arg1)->GetName();
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 {
14888 #if wxUSE_UNICODE
14889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14890 #else
14891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14892 #endif
14893 }
14894 return resultobj;
14895 fail:
14896 return NULL;
14897 }
14898
14899
14900 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14901 PyObject *resultobj = 0;
14902 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14903 wxString result;
14904 void *argp1 = 0 ;
14905 int res1 = 0 ;
14906 PyObject *swig_obj[1] ;
14907
14908 if (!args) SWIG_fail;
14909 swig_obj[0] = args;
14910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14911 if (!SWIG_IsOK(res1)) {
14912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14913 }
14914 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14915 {
14916 PyThreadState* __tstate = wxPyBeginAllowThreads();
14917 result = (arg1)->GetExtension();
14918 wxPyEndAllowThreads(__tstate);
14919 if (PyErr_Occurred()) SWIG_fail;
14920 }
14921 {
14922 #if wxUSE_UNICODE
14923 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14924 #else
14925 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14926 #endif
14927 }
14928 return resultobj;
14929 fail:
14930 return NULL;
14931 }
14932
14933
14934 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14935 PyObject *resultobj = 0;
14936 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14937 long result;
14938 void *argp1 = 0 ;
14939 int res1 = 0 ;
14940 PyObject *swig_obj[1] ;
14941
14942 if (!args) SWIG_fail;
14943 swig_obj[0] = args;
14944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14945 if (!SWIG_IsOK(res1)) {
14946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14947 }
14948 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14949 {
14950 PyThreadState* __tstate = wxPyBeginAllowThreads();
14951 result = (long)(arg1)->GetType();
14952 wxPyEndAllowThreads(__tstate);
14953 if (PyErr_Occurred()) SWIG_fail;
14954 }
14955 resultobj = SWIG_From_long(static_cast< long >(result));
14956 return resultobj;
14957 fail:
14958 return NULL;
14959 }
14960
14961
14962 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14963 PyObject *resultobj = 0;
14964 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14965 wxString result;
14966 void *argp1 = 0 ;
14967 int res1 = 0 ;
14968 PyObject *swig_obj[1] ;
14969
14970 if (!args) SWIG_fail;
14971 swig_obj[0] = args;
14972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14973 if (!SWIG_IsOK(res1)) {
14974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14975 }
14976 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14977 {
14978 PyThreadState* __tstate = wxPyBeginAllowThreads();
14979 result = (arg1)->GetMimeType();
14980 wxPyEndAllowThreads(__tstate);
14981 if (PyErr_Occurred()) SWIG_fail;
14982 }
14983 {
14984 #if wxUSE_UNICODE
14985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14986 #else
14987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14988 #endif
14989 }
14990 return resultobj;
14991 fail:
14992 return NULL;
14993 }
14994
14995
14996 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14997 PyObject *resultobj = 0;
14998 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14999 wxString *arg2 = 0 ;
15000 bool result;
15001 void *argp1 = 0 ;
15002 int res1 = 0 ;
15003 bool temp2 = false ;
15004 PyObject * obj0 = 0 ;
15005 PyObject * obj1 = 0 ;
15006 char * kwnames[] = {
15007 (char *) "self",(char *) "name", NULL
15008 };
15009
15010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
15011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15012 if (!SWIG_IsOK(res1)) {
15013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15014 }
15015 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15016 {
15017 arg2 = wxString_in_helper(obj1);
15018 if (arg2 == NULL) SWIG_fail;
15019 temp2 = true;
15020 }
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
15024 wxPyEndAllowThreads(__tstate);
15025 if (PyErr_Occurred()) SWIG_fail;
15026 }
15027 {
15028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15029 }
15030 {
15031 if (temp2)
15032 delete arg2;
15033 }
15034 return resultobj;
15035 fail:
15036 {
15037 if (temp2)
15038 delete arg2;
15039 }
15040 return NULL;
15041 }
15042
15043
15044 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15045 PyObject *resultobj = 0;
15046 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15047 wxInputStream *arg2 = 0 ;
15048 bool result;
15049 void *argp1 = 0 ;
15050 int res1 = 0 ;
15051 wxPyInputStream *temp2 ;
15052 bool created2 ;
15053 PyObject * obj0 = 0 ;
15054 PyObject * obj1 = 0 ;
15055 char * kwnames[] = {
15056 (char *) "self",(char *) "stream", NULL
15057 };
15058
15059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
15060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15061 if (!SWIG_IsOK(res1)) {
15062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15063 }
15064 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15065 {
15066 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15067 arg2 = temp2->m_wxis;
15068 created2 = false;
15069 } else {
15070 PyErr_Clear(); // clear the failure of the wxPyConvert above
15071 arg2 = wxPyCBInputStream_create(obj1, false);
15072 if (arg2 == NULL) {
15073 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15074 SWIG_fail;
15075 }
15076 created2 = true;
15077 }
15078 }
15079 {
15080 PyThreadState* __tstate = wxPyBeginAllowThreads();
15081 result = (bool)(arg1)->CanRead(*arg2);
15082 wxPyEndAllowThreads(__tstate);
15083 if (PyErr_Occurred()) SWIG_fail;
15084 }
15085 {
15086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15087 }
15088 {
15089 if (created2) delete arg2;
15090 }
15091 return resultobj;
15092 fail:
15093 {
15094 if (created2) delete arg2;
15095 }
15096 return NULL;
15097 }
15098
15099
15100 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15101 PyObject *resultobj = 0;
15102 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15103 wxString *arg2 = 0 ;
15104 void *argp1 = 0 ;
15105 int res1 = 0 ;
15106 bool temp2 = false ;
15107 PyObject * obj0 = 0 ;
15108 PyObject * obj1 = 0 ;
15109 char * kwnames[] = {
15110 (char *) "self",(char *) "name", NULL
15111 };
15112
15113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
15114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15115 if (!SWIG_IsOK(res1)) {
15116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15117 }
15118 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15119 {
15120 arg2 = wxString_in_helper(obj1);
15121 if (arg2 == NULL) SWIG_fail;
15122 temp2 = true;
15123 }
15124 {
15125 PyThreadState* __tstate = wxPyBeginAllowThreads();
15126 (arg1)->SetName((wxString const &)*arg2);
15127 wxPyEndAllowThreads(__tstate);
15128 if (PyErr_Occurred()) SWIG_fail;
15129 }
15130 resultobj = SWIG_Py_Void();
15131 {
15132 if (temp2)
15133 delete arg2;
15134 }
15135 return resultobj;
15136 fail:
15137 {
15138 if (temp2)
15139 delete arg2;
15140 }
15141 return NULL;
15142 }
15143
15144
15145 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15146 PyObject *resultobj = 0;
15147 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15148 wxString *arg2 = 0 ;
15149 void *argp1 = 0 ;
15150 int res1 = 0 ;
15151 bool temp2 = false ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 char * kwnames[] = {
15155 (char *) "self",(char *) "extension", NULL
15156 };
15157
15158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
15159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15160 if (!SWIG_IsOK(res1)) {
15161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15162 }
15163 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15164 {
15165 arg2 = wxString_in_helper(obj1);
15166 if (arg2 == NULL) SWIG_fail;
15167 temp2 = true;
15168 }
15169 {
15170 PyThreadState* __tstate = wxPyBeginAllowThreads();
15171 (arg1)->SetExtension((wxString const &)*arg2);
15172 wxPyEndAllowThreads(__tstate);
15173 if (PyErr_Occurred()) SWIG_fail;
15174 }
15175 resultobj = SWIG_Py_Void();
15176 {
15177 if (temp2)
15178 delete arg2;
15179 }
15180 return resultobj;
15181 fail:
15182 {
15183 if (temp2)
15184 delete arg2;
15185 }
15186 return NULL;
15187 }
15188
15189
15190 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15191 PyObject *resultobj = 0;
15192 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15193 long arg2 ;
15194 void *argp1 = 0 ;
15195 int res1 = 0 ;
15196 long val2 ;
15197 int ecode2 = 0 ;
15198 PyObject * obj0 = 0 ;
15199 PyObject * obj1 = 0 ;
15200 char * kwnames[] = {
15201 (char *) "self",(char *) "type", NULL
15202 };
15203
15204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
15205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15206 if (!SWIG_IsOK(res1)) {
15207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15208 }
15209 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15210 ecode2 = SWIG_AsVal_long(obj1, &val2);
15211 if (!SWIG_IsOK(ecode2)) {
15212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
15213 }
15214 arg2 = static_cast< long >(val2);
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 (arg1)->SetType(arg2);
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 resultobj = SWIG_Py_Void();
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj = 0;
15230 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
15231 wxString *arg2 = 0 ;
15232 void *argp1 = 0 ;
15233 int res1 = 0 ;
15234 bool temp2 = false ;
15235 PyObject * obj0 = 0 ;
15236 PyObject * obj1 = 0 ;
15237 char * kwnames[] = {
15238 (char *) "self",(char *) "mimetype", NULL
15239 };
15240
15241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
15242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
15243 if (!SWIG_IsOK(res1)) {
15244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
15245 }
15246 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
15247 {
15248 arg2 = wxString_in_helper(obj1);
15249 if (arg2 == NULL) SWIG_fail;
15250 temp2 = true;
15251 }
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 (arg1)->SetMimeType((wxString const &)*arg2);
15255 wxPyEndAllowThreads(__tstate);
15256 if (PyErr_Occurred()) SWIG_fail;
15257 }
15258 resultobj = SWIG_Py_Void();
15259 {
15260 if (temp2)
15261 delete arg2;
15262 }
15263 return resultobj;
15264 fail:
15265 {
15266 if (temp2)
15267 delete arg2;
15268 }
15269 return NULL;
15270 }
15271
15272
15273 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15274 PyObject *obj;
15275 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15276 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
15277 return SWIG_Py_Void();
15278 }
15279
15280 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15281 PyObject *resultobj = 0;
15282 wxPyImageHandler *result = 0 ;
15283
15284 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 result = (wxPyImageHandler *)new wxPyImageHandler();
15288 wxPyEndAllowThreads(__tstate);
15289 if (PyErr_Occurred()) SWIG_fail;
15290 }
15291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15299 PyObject *resultobj = 0;
15300 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
15301 PyObject *arg2 = (PyObject *) 0 ;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 PyObject * obj0 = 0 ;
15305 PyObject * obj1 = 0 ;
15306 char * kwnames[] = {
15307 (char *) "self",(char *) "self", NULL
15308 };
15309
15310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
15314 }
15315 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
15316 arg2 = obj1;
15317 {
15318 PyThreadState* __tstate = wxPyBeginAllowThreads();
15319 (arg1)->_SetSelf(arg2);
15320 wxPyEndAllowThreads(__tstate);
15321 if (PyErr_Occurred()) SWIG_fail;
15322 }
15323 resultobj = SWIG_Py_Void();
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331 PyObject *obj;
15332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15333 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
15334 return SWIG_Py_Void();
15335 }
15336
15337 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15338 return SWIG_Python_InitShadowInstance(args);
15339 }
15340
15341 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15342 PyObject *resultobj = 0;
15343 wxImageHistogram *result = 0 ;
15344
15345 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
15346 {
15347 PyThreadState* __tstate = wxPyBeginAllowThreads();
15348 result = (wxImageHistogram *)new wxImageHistogram();
15349 wxPyEndAllowThreads(__tstate);
15350 if (PyErr_Occurred()) SWIG_fail;
15351 }
15352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
15353 return resultobj;
15354 fail:
15355 return NULL;
15356 }
15357
15358
15359 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15360 PyObject *resultobj = 0;
15361 byte arg1 ;
15362 byte arg2 ;
15363 byte arg3 ;
15364 unsigned long result;
15365 unsigned char val1 ;
15366 int ecode1 = 0 ;
15367 unsigned char val2 ;
15368 int ecode2 = 0 ;
15369 unsigned char val3 ;
15370 int ecode3 = 0 ;
15371 PyObject * obj0 = 0 ;
15372 PyObject * obj1 = 0 ;
15373 PyObject * obj2 = 0 ;
15374 char * kwnames[] = {
15375 (char *) "r",(char *) "g",(char *) "b", NULL
15376 };
15377
15378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15379 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15380 if (!SWIG_IsOK(ecode1)) {
15381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
15382 }
15383 arg1 = static_cast< byte >(val1);
15384 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15385 if (!SWIG_IsOK(ecode2)) {
15386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
15387 }
15388 arg2 = static_cast< byte >(val2);
15389 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15390 if (!SWIG_IsOK(ecode3)) {
15391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
15392 }
15393 arg3 = static_cast< byte >(val3);
15394 {
15395 PyThreadState* __tstate = wxPyBeginAllowThreads();
15396 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
15397 wxPyEndAllowThreads(__tstate);
15398 if (PyErr_Occurred()) SWIG_fail;
15399 }
15400 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15401 return resultobj;
15402 fail:
15403 return NULL;
15404 }
15405
15406
15407 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15408 PyObject *resultobj = 0;
15409 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15410 byte *arg2 = (byte *) 0 ;
15411 byte *arg3 = (byte *) 0 ;
15412 byte *arg4 = (byte *) 0 ;
15413 byte arg5 = (byte) 1 ;
15414 byte arg6 = (byte) 0 ;
15415 byte arg7 = (byte) 0 ;
15416 bool result;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 byte temp2 ;
15420 int res2 = SWIG_TMPOBJ ;
15421 byte temp3 ;
15422 int res3 = SWIG_TMPOBJ ;
15423 byte temp4 ;
15424 int res4 = SWIG_TMPOBJ ;
15425 unsigned char val5 ;
15426 int ecode5 = 0 ;
15427 unsigned char val6 ;
15428 int ecode6 = 0 ;
15429 unsigned char val7 ;
15430 int ecode7 = 0 ;
15431 PyObject * obj0 = 0 ;
15432 PyObject * obj1 = 0 ;
15433 PyObject * obj2 = 0 ;
15434 PyObject * obj3 = 0 ;
15435 char * kwnames[] = {
15436 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
15437 };
15438
15439 arg2 = &temp2;
15440 arg3 = &temp3;
15441 arg4 = &temp4;
15442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15444 if (!SWIG_IsOK(res1)) {
15445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
15446 }
15447 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15448 if (obj1) {
15449 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
15450 if (!SWIG_IsOK(ecode5)) {
15451 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
15452 }
15453 arg5 = static_cast< byte >(val5);
15454 }
15455 if (obj2) {
15456 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
15457 if (!SWIG_IsOK(ecode6)) {
15458 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
15459 }
15460 arg6 = static_cast< byte >(val6);
15461 }
15462 if (obj3) {
15463 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
15464 if (!SWIG_IsOK(ecode7)) {
15465 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
15466 }
15467 arg7 = static_cast< byte >(val7);
15468 }
15469 {
15470 PyThreadState* __tstate = wxPyBeginAllowThreads();
15471 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
15472 wxPyEndAllowThreads(__tstate);
15473 if (PyErr_Occurred()) SWIG_fail;
15474 }
15475 {
15476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15477 }
15478 if (SWIG_IsTmpObj(res2)) {
15479 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15480 } else {
15481 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15482 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15483 }
15484 if (SWIG_IsTmpObj(res3)) {
15485 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15486 } else {
15487 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15488 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15489 }
15490 if (SWIG_IsTmpObj(res4)) {
15491 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15492 } else {
15493 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15494 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15495 }
15496 return resultobj;
15497 fail:
15498 return NULL;
15499 }
15500
15501
15502 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15503 PyObject *resultobj = 0;
15504 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15505 unsigned long arg2 ;
15506 unsigned long result;
15507 void *argp1 = 0 ;
15508 int res1 = 0 ;
15509 unsigned long val2 ;
15510 int ecode2 = 0 ;
15511 PyObject * obj0 = 0 ;
15512 PyObject * obj1 = 0 ;
15513 char * kwnames[] = {
15514 (char *) "self",(char *) "key", NULL
15515 };
15516
15517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
15518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15521 }
15522 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15523 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
15524 if (!SWIG_IsOK(ecode2)) {
15525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
15526 }
15527 arg2 = static_cast< unsigned long >(val2);
15528 {
15529 PyThreadState* __tstate = wxPyBeginAllowThreads();
15530 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
15531 wxPyEndAllowThreads(__tstate);
15532 if (PyErr_Occurred()) SWIG_fail;
15533 }
15534 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15535 return resultobj;
15536 fail:
15537 return NULL;
15538 }
15539
15540
15541 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15542 PyObject *resultobj = 0;
15543 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15544 byte arg2 ;
15545 byte arg3 ;
15546 byte arg4 ;
15547 unsigned long result;
15548 void *argp1 = 0 ;
15549 int res1 = 0 ;
15550 unsigned char val2 ;
15551 int ecode2 = 0 ;
15552 unsigned char val3 ;
15553 int ecode3 = 0 ;
15554 unsigned char val4 ;
15555 int ecode4 = 0 ;
15556 PyObject * obj0 = 0 ;
15557 PyObject * obj1 = 0 ;
15558 PyObject * obj2 = 0 ;
15559 PyObject * obj3 = 0 ;
15560 char * kwnames[] = {
15561 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15562 };
15563
15564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15566 if (!SWIG_IsOK(res1)) {
15567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15568 }
15569 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15570 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15571 if (!SWIG_IsOK(ecode2)) {
15572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
15573 }
15574 arg2 = static_cast< byte >(val2);
15575 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15576 if (!SWIG_IsOK(ecode3)) {
15577 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
15578 }
15579 arg3 = static_cast< byte >(val3);
15580 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15581 if (!SWIG_IsOK(ecode4)) {
15582 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
15583 }
15584 arg4 = static_cast< byte >(val4);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15599 PyObject *resultobj = 0;
15600 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
15601 wxColour *arg2 = 0 ;
15602 unsigned long result;
15603 void *argp1 = 0 ;
15604 int res1 = 0 ;
15605 wxColour temp2 ;
15606 PyObject * obj0 = 0 ;
15607 PyObject * obj1 = 0 ;
15608 char * kwnames[] = {
15609 (char *) "self",(char *) "colour", NULL
15610 };
15611
15612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15614 if (!SWIG_IsOK(res1)) {
15615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15616 }
15617 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15618 {
15619 arg2 = &temp2;
15620 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15621 }
15622 {
15623 PyThreadState* __tstate = wxPyBeginAllowThreads();
15624 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15625 wxPyEndAllowThreads(__tstate);
15626 if (PyErr_Occurred()) SWIG_fail;
15627 }
15628 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15629 return resultobj;
15630 fail:
15631 return NULL;
15632 }
15633
15634
15635 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15636 PyObject *obj;
15637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15638 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15639 return SWIG_Py_Void();
15640 }
15641
15642 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15643 return SWIG_Python_InitShadowInstance(args);
15644 }
15645
15646 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15647 PyObject *resultobj = 0;
15648 byte arg1 = (byte) 0 ;
15649 byte arg2 = (byte) 0 ;
15650 byte arg3 = (byte) 0 ;
15651 wxImage_RGBValue *result = 0 ;
15652 unsigned char val1 ;
15653 int ecode1 = 0 ;
15654 unsigned char val2 ;
15655 int ecode2 = 0 ;
15656 unsigned char val3 ;
15657 int ecode3 = 0 ;
15658 PyObject * obj0 = 0 ;
15659 PyObject * obj1 = 0 ;
15660 PyObject * obj2 = 0 ;
15661 char * kwnames[] = {
15662 (char *) "r",(char *) "g",(char *) "b", NULL
15663 };
15664
15665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15666 if (obj0) {
15667 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15668 if (!SWIG_IsOK(ecode1)) {
15669 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15670 }
15671 arg1 = static_cast< byte >(val1);
15672 }
15673 if (obj1) {
15674 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15675 if (!SWIG_IsOK(ecode2)) {
15676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15677 }
15678 arg2 = static_cast< byte >(val2);
15679 }
15680 if (obj2) {
15681 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15682 if (!SWIG_IsOK(ecode3)) {
15683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15684 }
15685 arg3 = static_cast< byte >(val3);
15686 }
15687 {
15688 PyThreadState* __tstate = wxPyBeginAllowThreads();
15689 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15690 wxPyEndAllowThreads(__tstate);
15691 if (PyErr_Occurred()) SWIG_fail;
15692 }
15693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15701 PyObject *resultobj = 0;
15702 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15703 byte arg2 ;
15704 void *argp1 = 0 ;
15705 int res1 = 0 ;
15706 unsigned char val2 ;
15707 int ecode2 = 0 ;
15708 PyObject *swig_obj[2] ;
15709
15710 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15712 if (!SWIG_IsOK(res1)) {
15713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15714 }
15715 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15716 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15717 if (!SWIG_IsOK(ecode2)) {
15718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15719 }
15720 arg2 = static_cast< byte >(val2);
15721 if (arg1) (arg1)->red = arg2;
15722
15723 resultobj = SWIG_Py_Void();
15724 return resultobj;
15725 fail:
15726 return NULL;
15727 }
15728
15729
15730 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15731 PyObject *resultobj = 0;
15732 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15733 byte result;
15734 void *argp1 = 0 ;
15735 int res1 = 0 ;
15736 PyObject *swig_obj[1] ;
15737
15738 if (!args) SWIG_fail;
15739 swig_obj[0] = args;
15740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15741 if (!SWIG_IsOK(res1)) {
15742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15743 }
15744 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15745 result = (byte) ((arg1)->red);
15746 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15747 return resultobj;
15748 fail:
15749 return NULL;
15750 }
15751
15752
15753 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15754 PyObject *resultobj = 0;
15755 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15756 byte arg2 ;
15757 void *argp1 = 0 ;
15758 int res1 = 0 ;
15759 unsigned char val2 ;
15760 int ecode2 = 0 ;
15761 PyObject *swig_obj[2] ;
15762
15763 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15765 if (!SWIG_IsOK(res1)) {
15766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15767 }
15768 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15769 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15770 if (!SWIG_IsOK(ecode2)) {
15771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15772 }
15773 arg2 = static_cast< byte >(val2);
15774 if (arg1) (arg1)->green = arg2;
15775
15776 resultobj = SWIG_Py_Void();
15777 return resultobj;
15778 fail:
15779 return NULL;
15780 }
15781
15782
15783 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15784 PyObject *resultobj = 0;
15785 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15786 byte result;
15787 void *argp1 = 0 ;
15788 int res1 = 0 ;
15789 PyObject *swig_obj[1] ;
15790
15791 if (!args) SWIG_fail;
15792 swig_obj[0] = args;
15793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15794 if (!SWIG_IsOK(res1)) {
15795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15796 }
15797 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15798 result = (byte) ((arg1)->green);
15799 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15800 return resultobj;
15801 fail:
15802 return NULL;
15803 }
15804
15805
15806 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15807 PyObject *resultobj = 0;
15808 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15809 byte arg2 ;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 unsigned char val2 ;
15813 int ecode2 = 0 ;
15814 PyObject *swig_obj[2] ;
15815
15816 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15818 if (!SWIG_IsOK(res1)) {
15819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15820 }
15821 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15822 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15823 if (!SWIG_IsOK(ecode2)) {
15824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15825 }
15826 arg2 = static_cast< byte >(val2);
15827 if (arg1) (arg1)->blue = arg2;
15828
15829 resultobj = SWIG_Py_Void();
15830 return resultobj;
15831 fail:
15832 return NULL;
15833 }
15834
15835
15836 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15837 PyObject *resultobj = 0;
15838 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15839 byte result;
15840 void *argp1 = 0 ;
15841 int res1 = 0 ;
15842 PyObject *swig_obj[1] ;
15843
15844 if (!args) SWIG_fail;
15845 swig_obj[0] = args;
15846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15847 if (!SWIG_IsOK(res1)) {
15848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15849 }
15850 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15851 result = (byte) ((arg1)->blue);
15852 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15853 return resultobj;
15854 fail:
15855 return NULL;
15856 }
15857
15858
15859 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15860 PyObject *obj;
15861 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15862 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15863 return SWIG_Py_Void();
15864 }
15865
15866 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15867 return SWIG_Python_InitShadowInstance(args);
15868 }
15869
15870 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15871 PyObject *resultobj = 0;
15872 double arg1 = (double) 0.0 ;
15873 double arg2 = (double) 0.0 ;
15874 double arg3 = (double) 0.0 ;
15875 wxImage_HSVValue *result = 0 ;
15876 double val1 ;
15877 int ecode1 = 0 ;
15878 double val2 ;
15879 int ecode2 = 0 ;
15880 double val3 ;
15881 int ecode3 = 0 ;
15882 PyObject * obj0 = 0 ;
15883 PyObject * obj1 = 0 ;
15884 PyObject * obj2 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "h",(char *) "s",(char *) "v", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15890 if (obj0) {
15891 ecode1 = SWIG_AsVal_double(obj0, &val1);
15892 if (!SWIG_IsOK(ecode1)) {
15893 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15894 }
15895 arg1 = static_cast< double >(val1);
15896 }
15897 if (obj1) {
15898 ecode2 = SWIG_AsVal_double(obj1, &val2);
15899 if (!SWIG_IsOK(ecode2)) {
15900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15901 }
15902 arg2 = static_cast< double >(val2);
15903 }
15904 if (obj2) {
15905 ecode3 = SWIG_AsVal_double(obj2, &val3);
15906 if (!SWIG_IsOK(ecode3)) {
15907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15908 }
15909 arg3 = static_cast< double >(val3);
15910 }
15911 {
15912 PyThreadState* __tstate = wxPyBeginAllowThreads();
15913 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15914 wxPyEndAllowThreads(__tstate);
15915 if (PyErr_Occurred()) SWIG_fail;
15916 }
15917 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15918 return resultobj;
15919 fail:
15920 return NULL;
15921 }
15922
15923
15924 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15925 PyObject *resultobj = 0;
15926 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15927 double arg2 ;
15928 void *argp1 = 0 ;
15929 int res1 = 0 ;
15930 double val2 ;
15931 int ecode2 = 0 ;
15932 PyObject *swig_obj[2] ;
15933
15934 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15936 if (!SWIG_IsOK(res1)) {
15937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15938 }
15939 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15940 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15941 if (!SWIG_IsOK(ecode2)) {
15942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15943 }
15944 arg2 = static_cast< double >(val2);
15945 if (arg1) (arg1)->hue = arg2;
15946
15947 resultobj = SWIG_Py_Void();
15948 return resultobj;
15949 fail:
15950 return NULL;
15951 }
15952
15953
15954 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15955 PyObject *resultobj = 0;
15956 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15957 double result;
15958 void *argp1 = 0 ;
15959 int res1 = 0 ;
15960 PyObject *swig_obj[1] ;
15961
15962 if (!args) SWIG_fail;
15963 swig_obj[0] = args;
15964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15965 if (!SWIG_IsOK(res1)) {
15966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15967 }
15968 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15969 result = (double) ((arg1)->hue);
15970 resultobj = SWIG_From_double(static_cast< double >(result));
15971 return resultobj;
15972 fail:
15973 return NULL;
15974 }
15975
15976
15977 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15978 PyObject *resultobj = 0;
15979 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15980 double arg2 ;
15981 void *argp1 = 0 ;
15982 int res1 = 0 ;
15983 double val2 ;
15984 int ecode2 = 0 ;
15985 PyObject *swig_obj[2] ;
15986
15987 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15991 }
15992 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15993 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15994 if (!SWIG_IsOK(ecode2)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15996 }
15997 arg2 = static_cast< double >(val2);
15998 if (arg1) (arg1)->saturation = arg2;
15999
16000 resultobj = SWIG_Py_Void();
16001 return resultobj;
16002 fail:
16003 return NULL;
16004 }
16005
16006
16007 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16008 PyObject *resultobj = 0;
16009 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16010 double result;
16011 void *argp1 = 0 ;
16012 int res1 = 0 ;
16013 PyObject *swig_obj[1] ;
16014
16015 if (!args) SWIG_fail;
16016 swig_obj[0] = args;
16017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16018 if (!SWIG_IsOK(res1)) {
16019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16020 }
16021 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16022 result = (double) ((arg1)->saturation);
16023 resultobj = SWIG_From_double(static_cast< double >(result));
16024 return resultobj;
16025 fail:
16026 return NULL;
16027 }
16028
16029
16030 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16031 PyObject *resultobj = 0;
16032 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16033 double arg2 ;
16034 void *argp1 = 0 ;
16035 int res1 = 0 ;
16036 double val2 ;
16037 int ecode2 = 0 ;
16038 PyObject *swig_obj[2] ;
16039
16040 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
16041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16042 if (!SWIG_IsOK(res1)) {
16043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16044 }
16045 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16046 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
16047 if (!SWIG_IsOK(ecode2)) {
16048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
16049 }
16050 arg2 = static_cast< double >(val2);
16051 if (arg1) (arg1)->value = arg2;
16052
16053 resultobj = SWIG_Py_Void();
16054 return resultobj;
16055 fail:
16056 return NULL;
16057 }
16058
16059
16060 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16061 PyObject *resultobj = 0;
16062 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
16063 double result;
16064 void *argp1 = 0 ;
16065 int res1 = 0 ;
16066 PyObject *swig_obj[1] ;
16067
16068 if (!args) SWIG_fail;
16069 swig_obj[0] = args;
16070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
16071 if (!SWIG_IsOK(res1)) {
16072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
16073 }
16074 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
16075 result = (double) ((arg1)->value);
16076 resultobj = SWIG_From_double(static_cast< double >(result));
16077 return resultobj;
16078 fail:
16079 return NULL;
16080 }
16081
16082
16083 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16084 PyObject *obj;
16085 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16086 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
16087 return SWIG_Py_Void();
16088 }
16089
16090 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16091 return SWIG_Python_InitShadowInstance(args);
16092 }
16093
16094 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16095 PyObject *resultobj = 0;
16096 wxString *arg1 = 0 ;
16097 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16098 int arg3 = (int) -1 ;
16099 wxImage *result = 0 ;
16100 bool temp1 = false ;
16101 long val2 ;
16102 int ecode2 = 0 ;
16103 int val3 ;
16104 int ecode3 = 0 ;
16105 PyObject * obj0 = 0 ;
16106 PyObject * obj1 = 0 ;
16107 PyObject * obj2 = 0 ;
16108 char * kwnames[] = {
16109 (char *) "name",(char *) "type",(char *) "index", NULL
16110 };
16111
16112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16113 {
16114 arg1 = wxString_in_helper(obj0);
16115 if (arg1 == NULL) SWIG_fail;
16116 temp1 = true;
16117 }
16118 if (obj1) {
16119 ecode2 = SWIG_AsVal_long(obj1, &val2);
16120 if (!SWIG_IsOK(ecode2)) {
16121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
16122 }
16123 arg2 = static_cast< long >(val2);
16124 }
16125 if (obj2) {
16126 ecode3 = SWIG_AsVal_int(obj2, &val3);
16127 if (!SWIG_IsOK(ecode3)) {
16128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
16129 }
16130 arg3 = static_cast< int >(val3);
16131 }
16132 {
16133 PyThreadState* __tstate = wxPyBeginAllowThreads();
16134 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
16135 wxPyEndAllowThreads(__tstate);
16136 if (PyErr_Occurred()) SWIG_fail;
16137 }
16138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
16139 {
16140 if (temp1)
16141 delete arg1;
16142 }
16143 return resultobj;
16144 fail:
16145 {
16146 if (temp1)
16147 delete arg1;
16148 }
16149 return NULL;
16150 }
16151
16152
16153 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16154 PyObject *resultobj = 0;
16155 wxImage *arg1 = (wxImage *) 0 ;
16156 void *argp1 = 0 ;
16157 int res1 = 0 ;
16158 PyObject *swig_obj[1] ;
16159
16160 if (!args) SWIG_fail;
16161 swig_obj[0] = args;
16162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
16163 if (!SWIG_IsOK(res1)) {
16164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
16165 }
16166 arg1 = reinterpret_cast< wxImage * >(argp1);
16167 {
16168 PyThreadState* __tstate = wxPyBeginAllowThreads();
16169 delete arg1;
16170
16171 wxPyEndAllowThreads(__tstate);
16172 if (PyErr_Occurred()) SWIG_fail;
16173 }
16174 resultobj = SWIG_Py_Void();
16175 return resultobj;
16176 fail:
16177 return NULL;
16178 }
16179
16180
16181 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj = 0;
16183 wxString *arg1 = 0 ;
16184 wxString *arg2 = 0 ;
16185 int arg3 = (int) -1 ;
16186 wxImage *result = 0 ;
16187 bool temp1 = false ;
16188 bool temp2 = false ;
16189 int val3 ;
16190 int ecode3 = 0 ;
16191 PyObject * obj0 = 0 ;
16192 PyObject * obj1 = 0 ;
16193 PyObject * obj2 = 0 ;
16194 char * kwnames[] = {
16195 (char *) "name",(char *) "mimetype",(char *) "index", NULL
16196 };
16197
16198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16199 {
16200 arg1 = wxString_in_helper(obj0);
16201 if (arg1 == NULL) SWIG_fail;
16202 temp1 = true;
16203 }
16204 {
16205 arg2 = wxString_in_helper(obj1);
16206 if (arg2 == NULL) SWIG_fail;
16207 temp2 = true;
16208 }
16209 if (obj2) {
16210 ecode3 = SWIG_AsVal_int(obj2, &val3);
16211 if (!SWIG_IsOK(ecode3)) {
16212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
16213 }
16214 arg3 = static_cast< int >(val3);
16215 }
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
16219 wxPyEndAllowThreads(__tstate);
16220 if (PyErr_Occurred()) SWIG_fail;
16221 }
16222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16223 {
16224 if (temp1)
16225 delete arg1;
16226 }
16227 {
16228 if (temp2)
16229 delete arg2;
16230 }
16231 return resultobj;
16232 fail:
16233 {
16234 if (temp1)
16235 delete arg1;
16236 }
16237 {
16238 if (temp2)
16239 delete arg2;
16240 }
16241 return NULL;
16242 }
16243
16244
16245 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16246 PyObject *resultobj = 0;
16247 wxInputStream *arg1 = 0 ;
16248 long arg2 = (long) wxBITMAP_TYPE_ANY ;
16249 int arg3 = (int) -1 ;
16250 wxImage *result = 0 ;
16251 wxPyInputStream *temp1 ;
16252 bool created1 ;
16253 long val2 ;
16254 int ecode2 = 0 ;
16255 int val3 ;
16256 int ecode3 = 0 ;
16257 PyObject * obj0 = 0 ;
16258 PyObject * obj1 = 0 ;
16259 PyObject * obj2 = 0 ;
16260 char * kwnames[] = {
16261 (char *) "stream",(char *) "type",(char *) "index", NULL
16262 };
16263
16264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16265 {
16266 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16267 arg1 = temp1->m_wxis;
16268 created1 = false;
16269 } else {
16270 PyErr_Clear(); // clear the failure of the wxPyConvert above
16271 arg1 = wxPyCBInputStream_create(obj0, false);
16272 if (arg1 == NULL) {
16273 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16274 SWIG_fail;
16275 }
16276 created1 = true;
16277 }
16278 }
16279 if (obj1) {
16280 ecode2 = SWIG_AsVal_long(obj1, &val2);
16281 if (!SWIG_IsOK(ecode2)) {
16282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
16283 }
16284 arg2 = static_cast< long >(val2);
16285 }
16286 if (obj2) {
16287 ecode3 = SWIG_AsVal_int(obj2, &val3);
16288 if (!SWIG_IsOK(ecode3)) {
16289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
16290 }
16291 arg3 = static_cast< int >(val3);
16292 }
16293 {
16294 PyThreadState* __tstate = wxPyBeginAllowThreads();
16295 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
16296 wxPyEndAllowThreads(__tstate);
16297 if (PyErr_Occurred()) SWIG_fail;
16298 }
16299 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16300 {
16301 if (created1) delete arg1;
16302 }
16303 return resultobj;
16304 fail:
16305 {
16306 if (created1) delete arg1;
16307 }
16308 return NULL;
16309 }
16310
16311
16312 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16313 PyObject *resultobj = 0;
16314 wxInputStream *arg1 = 0 ;
16315 wxString *arg2 = 0 ;
16316 int arg3 = (int) -1 ;
16317 wxImage *result = 0 ;
16318 wxPyInputStream *temp1 ;
16319 bool created1 ;
16320 bool temp2 = false ;
16321 int val3 ;
16322 int ecode3 = 0 ;
16323 PyObject * obj0 = 0 ;
16324 PyObject * obj1 = 0 ;
16325 PyObject * obj2 = 0 ;
16326 char * kwnames[] = {
16327 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
16328 };
16329
16330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16331 {
16332 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
16333 arg1 = temp1->m_wxis;
16334 created1 = false;
16335 } else {
16336 PyErr_Clear(); // clear the failure of the wxPyConvert above
16337 arg1 = wxPyCBInputStream_create(obj0, false);
16338 if (arg1 == NULL) {
16339 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
16340 SWIG_fail;
16341 }
16342 created1 = true;
16343 }
16344 }
16345 {
16346 arg2 = wxString_in_helper(obj1);
16347 if (arg2 == NULL) SWIG_fail;
16348 temp2 = true;
16349 }
16350 if (obj2) {
16351 ecode3 = SWIG_AsVal_int(obj2, &val3);
16352 if (!SWIG_IsOK(ecode3)) {
16353 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
16354 }
16355 arg3 = static_cast< int >(val3);
16356 }
16357 {
16358 PyThreadState* __tstate = wxPyBeginAllowThreads();
16359 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
16360 wxPyEndAllowThreads(__tstate);
16361 if (PyErr_Occurred()) SWIG_fail;
16362 }
16363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16364 {
16365 if (created1) delete arg1;
16366 }
16367 {
16368 if (temp2)
16369 delete arg2;
16370 }
16371 return resultobj;
16372 fail:
16373 {
16374 if (created1) delete arg1;
16375 }
16376 {
16377 if (temp2)
16378 delete arg2;
16379 }
16380 return NULL;
16381 }
16382
16383
16384 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16385 PyObject *resultobj = 0;
16386 int arg1 = (int) 0 ;
16387 int arg2 = (int) 0 ;
16388 bool arg3 = (bool) true ;
16389 wxImage *result = 0 ;
16390 int val1 ;
16391 int ecode1 = 0 ;
16392 int val2 ;
16393 int ecode2 = 0 ;
16394 bool val3 ;
16395 int ecode3 = 0 ;
16396 PyObject * obj0 = 0 ;
16397 PyObject * obj1 = 0 ;
16398 PyObject * obj2 = 0 ;
16399 char * kwnames[] = {
16400 (char *) "width",(char *) "height",(char *) "clear", NULL
16401 };
16402
16403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16404 if (obj0) {
16405 ecode1 = SWIG_AsVal_int(obj0, &val1);
16406 if (!SWIG_IsOK(ecode1)) {
16407 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
16408 }
16409 arg1 = static_cast< int >(val1);
16410 }
16411 if (obj1) {
16412 ecode2 = SWIG_AsVal_int(obj1, &val2);
16413 if (!SWIG_IsOK(ecode2)) {
16414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
16415 }
16416 arg2 = static_cast< int >(val2);
16417 }
16418 if (obj2) {
16419 ecode3 = SWIG_AsVal_bool(obj2, &val3);
16420 if (!SWIG_IsOK(ecode3)) {
16421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
16422 }
16423 arg3 = static_cast< bool >(val3);
16424 }
16425 {
16426 PyThreadState* __tstate = wxPyBeginAllowThreads();
16427 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
16428 wxPyEndAllowThreads(__tstate);
16429 if (PyErr_Occurred()) SWIG_fail;
16430 }
16431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16432 return resultobj;
16433 fail:
16434 return NULL;
16435 }
16436
16437
16438 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj = 0;
16440 wxBitmap *arg1 = 0 ;
16441 wxImage *result = 0 ;
16442 void *argp1 = 0 ;
16443 int res1 = 0 ;
16444 PyObject * obj0 = 0 ;
16445 char * kwnames[] = {
16446 (char *) "bitmap", NULL
16447 };
16448
16449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
16450 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
16451 if (!SWIG_IsOK(res1)) {
16452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16453 }
16454 if (!argp1) {
16455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
16456 }
16457 arg1 = reinterpret_cast< wxBitmap * >(argp1);
16458 {
16459 if (!wxPyCheckForApp()) SWIG_fail;
16460 PyThreadState* __tstate = wxPyBeginAllowThreads();
16461 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
16462 wxPyEndAllowThreads(__tstate);
16463 if (PyErr_Occurred()) SWIG_fail;
16464 }
16465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16466 return resultobj;
16467 fail:
16468 return NULL;
16469 }
16470
16471
16472 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16473 PyObject *resultobj = 0;
16474 int arg1 ;
16475 int arg2 ;
16476 buffer arg3 ;
16477 int arg4 ;
16478 wxImage *result = 0 ;
16479 int val1 ;
16480 int ecode1 = 0 ;
16481 int val2 ;
16482 int ecode2 = 0 ;
16483 Py_ssize_t temp3 ;
16484 PyObject * obj0 = 0 ;
16485 PyObject * obj1 = 0 ;
16486 PyObject * obj2 = 0 ;
16487 char * kwnames[] = {
16488 (char *) "width",(char *) "height",(char *) "data", NULL
16489 };
16490
16491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16492 ecode1 = SWIG_AsVal_int(obj0, &val1);
16493 if (!SWIG_IsOK(ecode1)) {
16494 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
16495 }
16496 arg1 = static_cast< int >(val1);
16497 ecode2 = SWIG_AsVal_int(obj1, &val2);
16498 if (!SWIG_IsOK(ecode2)) {
16499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
16500 }
16501 arg2 = static_cast< int >(val2);
16502 {
16503 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16504 arg4 = (int)temp3;
16505 }
16506 {
16507 PyThreadState* __tstate = wxPyBeginAllowThreads();
16508 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
16509 wxPyEndAllowThreads(__tstate);
16510 if (PyErr_Occurred()) SWIG_fail;
16511 }
16512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16513 return resultobj;
16514 fail:
16515 return NULL;
16516 }
16517
16518
16519 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16520 PyObject *resultobj = 0;
16521 int arg1 ;
16522 int arg2 ;
16523 buffer arg3 ;
16524 int arg4 ;
16525 buffer arg5 ;
16526 int arg6 ;
16527 wxImage *result = 0 ;
16528 int val1 ;
16529 int ecode1 = 0 ;
16530 int val2 ;
16531 int ecode2 = 0 ;
16532 Py_ssize_t temp3 ;
16533 Py_ssize_t temp5 ;
16534 PyObject * obj0 = 0 ;
16535 PyObject * obj1 = 0 ;
16536 PyObject * obj2 = 0 ;
16537 PyObject * obj3 = 0 ;
16538 char * kwnames[] = {
16539 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
16540 };
16541
16542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16543 ecode1 = SWIG_AsVal_int(obj0, &val1);
16544 if (!SWIG_IsOK(ecode1)) {
16545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
16546 }
16547 arg1 = static_cast< int >(val1);
16548 ecode2 = SWIG_AsVal_int(obj1, &val2);
16549 if (!SWIG_IsOK(ecode2)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
16551 }
16552 arg2 = static_cast< int >(val2);
16553 {
16554 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
16555 arg4 = (int)temp3;
16556 }
16557 {
16558 if (obj3 != Py_None) {
16559 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
16560 arg6 = (int)temp5;
16561 }
16562 }
16563 {
16564 PyThreadState* __tstate = wxPyBeginAllowThreads();
16565 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
16566 wxPyEndAllowThreads(__tstate);
16567 if (PyErr_Occurred()) SWIG_fail;
16568 }
16569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16570 return resultobj;
16571 fail:
16572 return NULL;
16573 }
16574
16575
16576 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16577 PyObject *resultobj = 0;
16578 wxImage *arg1 = (wxImage *) 0 ;
16579 int arg2 ;
16580 int arg3 ;
16581 bool arg4 = (bool) true ;
16582 void *argp1 = 0 ;
16583 int res1 = 0 ;
16584 int val2 ;
16585 int ecode2 = 0 ;
16586 int val3 ;
16587 int ecode3 = 0 ;
16588 bool val4 ;
16589 int ecode4 = 0 ;
16590 PyObject * obj0 = 0 ;
16591 PyObject * obj1 = 0 ;
16592 PyObject * obj2 = 0 ;
16593 PyObject * obj3 = 0 ;
16594 char * kwnames[] = {
16595 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
16596 };
16597
16598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16600 if (!SWIG_IsOK(res1)) {
16601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
16602 }
16603 arg1 = reinterpret_cast< wxImage * >(argp1);
16604 ecode2 = SWIG_AsVal_int(obj1, &val2);
16605 if (!SWIG_IsOK(ecode2)) {
16606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
16607 }
16608 arg2 = static_cast< int >(val2);
16609 ecode3 = SWIG_AsVal_int(obj2, &val3);
16610 if (!SWIG_IsOK(ecode3)) {
16611 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16612 }
16613 arg3 = static_cast< int >(val3);
16614 if (obj3) {
16615 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16616 if (!SWIG_IsOK(ecode4)) {
16617 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16618 }
16619 arg4 = static_cast< bool >(val4);
16620 }
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 (arg1)->Create(arg2,arg3,arg4);
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 resultobj = SWIG_Py_Void();
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16635 PyObject *resultobj = 0;
16636 wxImage *arg1 = (wxImage *) 0 ;
16637 void *argp1 = 0 ;
16638 int res1 = 0 ;
16639 PyObject *swig_obj[1] ;
16640
16641 if (!args) SWIG_fail;
16642 swig_obj[0] = args;
16643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16644 if (!SWIG_IsOK(res1)) {
16645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16646 }
16647 arg1 = reinterpret_cast< wxImage * >(argp1);
16648 {
16649 PyThreadState* __tstate = wxPyBeginAllowThreads();
16650 (arg1)->Destroy();
16651 wxPyEndAllowThreads(__tstate);
16652 if (PyErr_Occurred()) SWIG_fail;
16653 }
16654 resultobj = SWIG_Py_Void();
16655 return resultobj;
16656 fail:
16657 return NULL;
16658 }
16659
16660
16661 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16662 PyObject *resultobj = 0;
16663 wxImage *arg1 = (wxImage *) 0 ;
16664 int arg2 ;
16665 int arg3 ;
16666 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16667 SwigValueWrapper<wxImage > result;
16668 void *argp1 = 0 ;
16669 int res1 = 0 ;
16670 int val2 ;
16671 int ecode2 = 0 ;
16672 int val3 ;
16673 int ecode3 = 0 ;
16674 int val4 ;
16675 int ecode4 = 0 ;
16676 PyObject * obj0 = 0 ;
16677 PyObject * obj1 = 0 ;
16678 PyObject * obj2 = 0 ;
16679 PyObject * obj3 = 0 ;
16680 char * kwnames[] = {
16681 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16682 };
16683
16684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16686 if (!SWIG_IsOK(res1)) {
16687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16688 }
16689 arg1 = reinterpret_cast< wxImage * >(argp1);
16690 ecode2 = SWIG_AsVal_int(obj1, &val2);
16691 if (!SWIG_IsOK(ecode2)) {
16692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16693 }
16694 arg2 = static_cast< int >(val2);
16695 ecode3 = SWIG_AsVal_int(obj2, &val3);
16696 if (!SWIG_IsOK(ecode3)) {
16697 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16698 }
16699 arg3 = static_cast< int >(val3);
16700 if (obj3) {
16701 ecode4 = SWIG_AsVal_int(obj3, &val4);
16702 if (!SWIG_IsOK(ecode4)) {
16703 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16704 }
16705 arg4 = static_cast< int >(val4);
16706 }
16707 {
16708 PyThreadState* __tstate = wxPyBeginAllowThreads();
16709 result = (arg1)->Scale(arg2,arg3,arg4);
16710 wxPyEndAllowThreads(__tstate);
16711 if (PyErr_Occurred()) SWIG_fail;
16712 }
16713 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16714 return resultobj;
16715 fail:
16716 return NULL;
16717 }
16718
16719
16720 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16721 PyObject *resultobj = 0;
16722 wxImage *arg1 = (wxImage *) 0 ;
16723 int arg2 ;
16724 int arg3 ;
16725 SwigValueWrapper<wxImage > result;
16726 void *argp1 = 0 ;
16727 int res1 = 0 ;
16728 int val2 ;
16729 int ecode2 = 0 ;
16730 int val3 ;
16731 int ecode3 = 0 ;
16732 PyObject * obj0 = 0 ;
16733 PyObject * obj1 = 0 ;
16734 PyObject * obj2 = 0 ;
16735 char * kwnames[] = {
16736 (char *) "self",(char *) "width",(char *) "height", NULL
16737 };
16738
16739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16741 if (!SWIG_IsOK(res1)) {
16742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16743 }
16744 arg1 = reinterpret_cast< wxImage * >(argp1);
16745 ecode2 = SWIG_AsVal_int(obj1, &val2);
16746 if (!SWIG_IsOK(ecode2)) {
16747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16748 }
16749 arg2 = static_cast< int >(val2);
16750 ecode3 = SWIG_AsVal_int(obj2, &val3);
16751 if (!SWIG_IsOK(ecode3)) {
16752 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16753 }
16754 arg3 = static_cast< int >(val3);
16755 {
16756 PyThreadState* __tstate = wxPyBeginAllowThreads();
16757 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16758 wxPyEndAllowThreads(__tstate);
16759 if (PyErr_Occurred()) SWIG_fail;
16760 }
16761 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16762 return resultobj;
16763 fail:
16764 return NULL;
16765 }
16766
16767
16768 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16769 PyObject *resultobj = 0;
16770 wxImage *arg1 = (wxImage *) 0 ;
16771 int arg2 ;
16772 int arg3 ;
16773 SwigValueWrapper<wxImage > result;
16774 void *argp1 = 0 ;
16775 int res1 = 0 ;
16776 int val2 ;
16777 int ecode2 = 0 ;
16778 int val3 ;
16779 int ecode3 = 0 ;
16780 PyObject * obj0 = 0 ;
16781 PyObject * obj1 = 0 ;
16782 PyObject * obj2 = 0 ;
16783 char * kwnames[] = {
16784 (char *) "self",(char *) "width",(char *) "height", NULL
16785 };
16786
16787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16789 if (!SWIG_IsOK(res1)) {
16790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16791 }
16792 arg1 = reinterpret_cast< wxImage * >(argp1);
16793 ecode2 = SWIG_AsVal_int(obj1, &val2);
16794 if (!SWIG_IsOK(ecode2)) {
16795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16796 }
16797 arg2 = static_cast< int >(val2);
16798 ecode3 = SWIG_AsVal_int(obj2, &val3);
16799 if (!SWIG_IsOK(ecode3)) {
16800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16801 }
16802 arg3 = static_cast< int >(val3);
16803 {
16804 PyThreadState* __tstate = wxPyBeginAllowThreads();
16805 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16810 return resultobj;
16811 fail:
16812 return NULL;
16813 }
16814
16815
16816 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16817 PyObject *resultobj = 0;
16818 wxImage *arg1 = (wxImage *) 0 ;
16819 int arg2 ;
16820 SwigValueWrapper<wxImage > result;
16821 void *argp1 = 0 ;
16822 int res1 = 0 ;
16823 int val2 ;
16824 int ecode2 = 0 ;
16825 PyObject * obj0 = 0 ;
16826 PyObject * obj1 = 0 ;
16827 char * kwnames[] = {
16828 (char *) "self",(char *) "radius", NULL
16829 };
16830
16831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16833 if (!SWIG_IsOK(res1)) {
16834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16835 }
16836 arg1 = reinterpret_cast< wxImage * >(argp1);
16837 ecode2 = SWIG_AsVal_int(obj1, &val2);
16838 if (!SWIG_IsOK(ecode2)) {
16839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16840 }
16841 arg2 = static_cast< int >(val2);
16842 {
16843 PyThreadState* __tstate = wxPyBeginAllowThreads();
16844 result = (arg1)->Blur(arg2);
16845 wxPyEndAllowThreads(__tstate);
16846 if (PyErr_Occurred()) SWIG_fail;
16847 }
16848 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16849 return resultobj;
16850 fail:
16851 return NULL;
16852 }
16853
16854
16855 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16856 PyObject *resultobj = 0;
16857 wxImage *arg1 = (wxImage *) 0 ;
16858 int arg2 ;
16859 SwigValueWrapper<wxImage > result;
16860 void *argp1 = 0 ;
16861 int res1 = 0 ;
16862 int val2 ;
16863 int ecode2 = 0 ;
16864 PyObject * obj0 = 0 ;
16865 PyObject * obj1 = 0 ;
16866 char * kwnames[] = {
16867 (char *) "self",(char *) "radius", NULL
16868 };
16869
16870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16872 if (!SWIG_IsOK(res1)) {
16873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16874 }
16875 arg1 = reinterpret_cast< wxImage * >(argp1);
16876 ecode2 = SWIG_AsVal_int(obj1, &val2);
16877 if (!SWIG_IsOK(ecode2)) {
16878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16879 }
16880 arg2 = static_cast< int >(val2);
16881 {
16882 PyThreadState* __tstate = wxPyBeginAllowThreads();
16883 result = (arg1)->BlurHorizontal(arg2);
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16888 return resultobj;
16889 fail:
16890 return NULL;
16891 }
16892
16893
16894 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16895 PyObject *resultobj = 0;
16896 wxImage *arg1 = (wxImage *) 0 ;
16897 int arg2 ;
16898 SwigValueWrapper<wxImage > result;
16899 void *argp1 = 0 ;
16900 int res1 = 0 ;
16901 int val2 ;
16902 int ecode2 = 0 ;
16903 PyObject * obj0 = 0 ;
16904 PyObject * obj1 = 0 ;
16905 char * kwnames[] = {
16906 (char *) "self",(char *) "radius", NULL
16907 };
16908
16909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16911 if (!SWIG_IsOK(res1)) {
16912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16913 }
16914 arg1 = reinterpret_cast< wxImage * >(argp1);
16915 ecode2 = SWIG_AsVal_int(obj1, &val2);
16916 if (!SWIG_IsOK(ecode2)) {
16917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16918 }
16919 arg2 = static_cast< int >(val2);
16920 {
16921 PyThreadState* __tstate = wxPyBeginAllowThreads();
16922 result = (arg1)->BlurVertical(arg2);
16923 wxPyEndAllowThreads(__tstate);
16924 if (PyErr_Occurred()) SWIG_fail;
16925 }
16926 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16927 return resultobj;
16928 fail:
16929 return NULL;
16930 }
16931
16932
16933 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16934 PyObject *resultobj = 0;
16935 wxImage *arg1 = (wxImage *) 0 ;
16936 int arg2 ;
16937 int arg3 ;
16938 SwigValueWrapper<wxImage > result;
16939 void *argp1 = 0 ;
16940 int res1 = 0 ;
16941 int val2 ;
16942 int ecode2 = 0 ;
16943 int val3 ;
16944 int ecode3 = 0 ;
16945 PyObject * obj0 = 0 ;
16946 PyObject * obj1 = 0 ;
16947 PyObject * obj2 = 0 ;
16948 char * kwnames[] = {
16949 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16950 };
16951
16952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16954 if (!SWIG_IsOK(res1)) {
16955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16956 }
16957 arg1 = reinterpret_cast< wxImage * >(argp1);
16958 ecode2 = SWIG_AsVal_int(obj1, &val2);
16959 if (!SWIG_IsOK(ecode2)) {
16960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16961 }
16962 arg2 = static_cast< int >(val2);
16963 ecode3 = SWIG_AsVal_int(obj2, &val3);
16964 if (!SWIG_IsOK(ecode3)) {
16965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16966 }
16967 arg3 = static_cast< int >(val3);
16968 {
16969 PyThreadState* __tstate = wxPyBeginAllowThreads();
16970 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16971 wxPyEndAllowThreads(__tstate);
16972 if (PyErr_Occurred()) SWIG_fail;
16973 }
16974 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16975 return resultobj;
16976 fail:
16977 return NULL;
16978 }
16979
16980
16981 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16982 PyObject *resultobj = 0;
16983 wxImage *arg1 = (wxImage *) 0 ;
16984 int arg2 ;
16985 int arg3 ;
16986 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16987 wxImage *result = 0 ;
16988 void *argp1 = 0 ;
16989 int res1 = 0 ;
16990 int val2 ;
16991 int ecode2 = 0 ;
16992 int val3 ;
16993 int ecode3 = 0 ;
16994 int val4 ;
16995 int ecode4 = 0 ;
16996 PyObject * obj0 = 0 ;
16997 PyObject * obj1 = 0 ;
16998 PyObject * obj2 = 0 ;
16999 PyObject * obj3 = 0 ;
17000 char * kwnames[] = {
17001 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
17002 };
17003
17004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17006 if (!SWIG_IsOK(res1)) {
17007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
17008 }
17009 arg1 = reinterpret_cast< wxImage * >(argp1);
17010 ecode2 = SWIG_AsVal_int(obj1, &val2);
17011 if (!SWIG_IsOK(ecode2)) {
17012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
17013 }
17014 arg2 = static_cast< int >(val2);
17015 ecode3 = SWIG_AsVal_int(obj2, &val3);
17016 if (!SWIG_IsOK(ecode3)) {
17017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
17018 }
17019 arg3 = static_cast< int >(val3);
17020 if (obj3) {
17021 ecode4 = SWIG_AsVal_int(obj3, &val4);
17022 if (!SWIG_IsOK(ecode4)) {
17023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
17024 }
17025 arg4 = static_cast< int >(val4);
17026 }
17027 {
17028 PyThreadState* __tstate = wxPyBeginAllowThreads();
17029 {
17030 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
17031 result = (wxImage *) &_result_ref;
17032 }
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17037 return resultobj;
17038 fail:
17039 return NULL;
17040 }
17041
17042
17043 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17044 PyObject *resultobj = 0;
17045 wxImage *arg1 = (wxImage *) 0 ;
17046 wxSize *arg2 = 0 ;
17047 wxPoint *arg3 = 0 ;
17048 int arg4 = (int) -1 ;
17049 int arg5 = (int) -1 ;
17050 int arg6 = (int) -1 ;
17051 wxImage *result = 0 ;
17052 void *argp1 = 0 ;
17053 int res1 = 0 ;
17054 wxSize temp2 ;
17055 wxPoint temp3 ;
17056 int val4 ;
17057 int ecode4 = 0 ;
17058 int val5 ;
17059 int ecode5 = 0 ;
17060 int val6 ;
17061 int ecode6 = 0 ;
17062 PyObject * obj0 = 0 ;
17063 PyObject * obj1 = 0 ;
17064 PyObject * obj2 = 0 ;
17065 PyObject * obj3 = 0 ;
17066 PyObject * obj4 = 0 ;
17067 PyObject * obj5 = 0 ;
17068 char * kwnames[] = {
17069 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
17070 };
17071
17072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17074 if (!SWIG_IsOK(res1)) {
17075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
17076 }
17077 arg1 = reinterpret_cast< wxImage * >(argp1);
17078 {
17079 arg2 = &temp2;
17080 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
17081 }
17082 {
17083 arg3 = &temp3;
17084 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
17085 }
17086 if (obj3) {
17087 ecode4 = SWIG_AsVal_int(obj3, &val4);
17088 if (!SWIG_IsOK(ecode4)) {
17089 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
17090 }
17091 arg4 = static_cast< int >(val4);
17092 }
17093 if (obj4) {
17094 ecode5 = SWIG_AsVal_int(obj4, &val5);
17095 if (!SWIG_IsOK(ecode5)) {
17096 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
17097 }
17098 arg5 = static_cast< int >(val5);
17099 }
17100 if (obj5) {
17101 ecode6 = SWIG_AsVal_int(obj5, &val6);
17102 if (!SWIG_IsOK(ecode6)) {
17103 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
17104 }
17105 arg6 = static_cast< int >(val6);
17106 }
17107 {
17108 PyThreadState* __tstate = wxPyBeginAllowThreads();
17109 {
17110 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
17111 result = (wxImage *) &_result_ref;
17112 }
17113 wxPyEndAllowThreads(__tstate);
17114 if (PyErr_Occurred()) SWIG_fail;
17115 }
17116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
17117 return resultobj;
17118 fail:
17119 return NULL;
17120 }
17121
17122
17123 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17124 PyObject *resultobj = 0;
17125 wxImage *arg1 = (wxImage *) 0 ;
17126 int arg2 ;
17127 int arg3 ;
17128 byte arg4 ;
17129 byte arg5 ;
17130 byte arg6 ;
17131 void *argp1 = 0 ;
17132 int res1 = 0 ;
17133 int val2 ;
17134 int ecode2 = 0 ;
17135 int val3 ;
17136 int ecode3 = 0 ;
17137 unsigned char val4 ;
17138 int ecode4 = 0 ;
17139 unsigned char val5 ;
17140 int ecode5 = 0 ;
17141 unsigned char val6 ;
17142 int ecode6 = 0 ;
17143 PyObject * obj0 = 0 ;
17144 PyObject * obj1 = 0 ;
17145 PyObject * obj2 = 0 ;
17146 PyObject * obj3 = 0 ;
17147 PyObject * obj4 = 0 ;
17148 PyObject * obj5 = 0 ;
17149 char * kwnames[] = {
17150 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
17151 };
17152
17153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
17154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17155 if (!SWIG_IsOK(res1)) {
17156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
17157 }
17158 arg1 = reinterpret_cast< wxImage * >(argp1);
17159 ecode2 = SWIG_AsVal_int(obj1, &val2);
17160 if (!SWIG_IsOK(ecode2)) {
17161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
17162 }
17163 arg2 = static_cast< int >(val2);
17164 ecode3 = SWIG_AsVal_int(obj2, &val3);
17165 if (!SWIG_IsOK(ecode3)) {
17166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
17167 }
17168 arg3 = static_cast< int >(val3);
17169 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17170 if (!SWIG_IsOK(ecode4)) {
17171 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
17172 }
17173 arg4 = static_cast< byte >(val4);
17174 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17175 if (!SWIG_IsOK(ecode5)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
17177 }
17178 arg5 = static_cast< byte >(val5);
17179 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
17180 if (!SWIG_IsOK(ecode6)) {
17181 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
17182 }
17183 arg6 = static_cast< byte >(val6);
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
17187 wxPyEndAllowThreads(__tstate);
17188 if (PyErr_Occurred()) SWIG_fail;
17189 }
17190 resultobj = SWIG_Py_Void();
17191 return resultobj;
17192 fail:
17193 return NULL;
17194 }
17195
17196
17197 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj = 0;
17199 wxImage *arg1 = (wxImage *) 0 ;
17200 wxRect *arg2 = 0 ;
17201 byte arg3 ;
17202 byte arg4 ;
17203 byte arg5 ;
17204 void *argp1 = 0 ;
17205 int res1 = 0 ;
17206 wxRect temp2 ;
17207 unsigned char val3 ;
17208 int ecode3 = 0 ;
17209 unsigned char val4 ;
17210 int ecode4 = 0 ;
17211 unsigned char val5 ;
17212 int ecode5 = 0 ;
17213 PyObject * obj0 = 0 ;
17214 PyObject * obj1 = 0 ;
17215 PyObject * obj2 = 0 ;
17216 PyObject * obj3 = 0 ;
17217 PyObject * obj4 = 0 ;
17218 char * kwnames[] = {
17219 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
17220 };
17221
17222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17224 if (!SWIG_IsOK(res1)) {
17225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
17226 }
17227 arg1 = reinterpret_cast< wxImage * >(argp1);
17228 {
17229 arg2 = &temp2;
17230 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17231 }
17232 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17233 if (!SWIG_IsOK(ecode3)) {
17234 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
17235 }
17236 arg3 = static_cast< byte >(val3);
17237 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17238 if (!SWIG_IsOK(ecode4)) {
17239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
17240 }
17241 arg4 = static_cast< byte >(val4);
17242 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17243 if (!SWIG_IsOK(ecode5)) {
17244 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
17245 }
17246 arg5 = static_cast< byte >(val5);
17247 {
17248 PyThreadState* __tstate = wxPyBeginAllowThreads();
17249 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
17250 wxPyEndAllowThreads(__tstate);
17251 if (PyErr_Occurred()) SWIG_fail;
17252 }
17253 resultobj = SWIG_Py_Void();
17254 return resultobj;
17255 fail:
17256 return NULL;
17257 }
17258
17259
17260 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17261 PyObject *resultobj = 0;
17262 wxImage *arg1 = (wxImage *) 0 ;
17263 int arg2 ;
17264 int arg3 ;
17265 byte result;
17266 void *argp1 = 0 ;
17267 int res1 = 0 ;
17268 int val2 ;
17269 int ecode2 = 0 ;
17270 int val3 ;
17271 int ecode3 = 0 ;
17272 PyObject * obj0 = 0 ;
17273 PyObject * obj1 = 0 ;
17274 PyObject * obj2 = 0 ;
17275 char * kwnames[] = {
17276 (char *) "self",(char *) "x",(char *) "y", NULL
17277 };
17278
17279 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17280 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17281 if (!SWIG_IsOK(res1)) {
17282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
17283 }
17284 arg1 = reinterpret_cast< wxImage * >(argp1);
17285 ecode2 = SWIG_AsVal_int(obj1, &val2);
17286 if (!SWIG_IsOK(ecode2)) {
17287 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
17288 }
17289 arg2 = static_cast< int >(val2);
17290 ecode3 = SWIG_AsVal_int(obj2, &val3);
17291 if (!SWIG_IsOK(ecode3)) {
17292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
17293 }
17294 arg3 = static_cast< int >(val3);
17295 {
17296 PyThreadState* __tstate = wxPyBeginAllowThreads();
17297 result = (byte)(arg1)->GetRed(arg2,arg3);
17298 wxPyEndAllowThreads(__tstate);
17299 if (PyErr_Occurred()) SWIG_fail;
17300 }
17301 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17302 return resultobj;
17303 fail:
17304 return NULL;
17305 }
17306
17307
17308 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17309 PyObject *resultobj = 0;
17310 wxImage *arg1 = (wxImage *) 0 ;
17311 int arg2 ;
17312 int arg3 ;
17313 byte result;
17314 void *argp1 = 0 ;
17315 int res1 = 0 ;
17316 int val2 ;
17317 int ecode2 = 0 ;
17318 int val3 ;
17319 int ecode3 = 0 ;
17320 PyObject * obj0 = 0 ;
17321 PyObject * obj1 = 0 ;
17322 PyObject * obj2 = 0 ;
17323 char * kwnames[] = {
17324 (char *) "self",(char *) "x",(char *) "y", NULL
17325 };
17326
17327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17329 if (!SWIG_IsOK(res1)) {
17330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
17331 }
17332 arg1 = reinterpret_cast< wxImage * >(argp1);
17333 ecode2 = SWIG_AsVal_int(obj1, &val2);
17334 if (!SWIG_IsOK(ecode2)) {
17335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
17336 }
17337 arg2 = static_cast< int >(val2);
17338 ecode3 = SWIG_AsVal_int(obj2, &val3);
17339 if (!SWIG_IsOK(ecode3)) {
17340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
17341 }
17342 arg3 = static_cast< int >(val3);
17343 {
17344 PyThreadState* __tstate = wxPyBeginAllowThreads();
17345 result = (byte)(arg1)->GetGreen(arg2,arg3);
17346 wxPyEndAllowThreads(__tstate);
17347 if (PyErr_Occurred()) SWIG_fail;
17348 }
17349 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17350 return resultobj;
17351 fail:
17352 return NULL;
17353 }
17354
17355
17356 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17357 PyObject *resultobj = 0;
17358 wxImage *arg1 = (wxImage *) 0 ;
17359 int arg2 ;
17360 int arg3 ;
17361 byte result;
17362 void *argp1 = 0 ;
17363 int res1 = 0 ;
17364 int val2 ;
17365 int ecode2 = 0 ;
17366 int val3 ;
17367 int ecode3 = 0 ;
17368 PyObject * obj0 = 0 ;
17369 PyObject * obj1 = 0 ;
17370 PyObject * obj2 = 0 ;
17371 char * kwnames[] = {
17372 (char *) "self",(char *) "x",(char *) "y", NULL
17373 };
17374
17375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17377 if (!SWIG_IsOK(res1)) {
17378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
17379 }
17380 arg1 = reinterpret_cast< wxImage * >(argp1);
17381 ecode2 = SWIG_AsVal_int(obj1, &val2);
17382 if (!SWIG_IsOK(ecode2)) {
17383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
17384 }
17385 arg2 = static_cast< int >(val2);
17386 ecode3 = SWIG_AsVal_int(obj2, &val3);
17387 if (!SWIG_IsOK(ecode3)) {
17388 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
17389 }
17390 arg3 = static_cast< int >(val3);
17391 {
17392 PyThreadState* __tstate = wxPyBeginAllowThreads();
17393 result = (byte)(arg1)->GetBlue(arg2,arg3);
17394 wxPyEndAllowThreads(__tstate);
17395 if (PyErr_Occurred()) SWIG_fail;
17396 }
17397 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17398 return resultobj;
17399 fail:
17400 return NULL;
17401 }
17402
17403
17404 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17405 PyObject *resultobj = 0;
17406 wxImage *arg1 = (wxImage *) 0 ;
17407 int arg2 ;
17408 int arg3 ;
17409 byte arg4 ;
17410 void *argp1 = 0 ;
17411 int res1 = 0 ;
17412 int val2 ;
17413 int ecode2 = 0 ;
17414 int val3 ;
17415 int ecode3 = 0 ;
17416 unsigned char val4 ;
17417 int ecode4 = 0 ;
17418 PyObject * obj0 = 0 ;
17419 PyObject * obj1 = 0 ;
17420 PyObject * obj2 = 0 ;
17421 PyObject * obj3 = 0 ;
17422 char * kwnames[] = {
17423 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
17424 };
17425
17426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17428 if (!SWIG_IsOK(res1)) {
17429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17430 }
17431 arg1 = reinterpret_cast< wxImage * >(argp1);
17432 ecode2 = SWIG_AsVal_int(obj1, &val2);
17433 if (!SWIG_IsOK(ecode2)) {
17434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
17435 }
17436 arg2 = static_cast< int >(val2);
17437 ecode3 = SWIG_AsVal_int(obj2, &val3);
17438 if (!SWIG_IsOK(ecode3)) {
17439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
17440 }
17441 arg3 = static_cast< int >(val3);
17442 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17443 if (!SWIG_IsOK(ecode4)) {
17444 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
17445 }
17446 arg4 = static_cast< byte >(val4);
17447 {
17448 PyThreadState* __tstate = wxPyBeginAllowThreads();
17449 (arg1)->SetAlpha(arg2,arg3,arg4);
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 resultobj = SWIG_Py_Void();
17454 return resultobj;
17455 fail:
17456 return NULL;
17457 }
17458
17459
17460 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17461 PyObject *resultobj = 0;
17462 wxImage *arg1 = (wxImage *) 0 ;
17463 int arg2 ;
17464 int arg3 ;
17465 byte result;
17466 void *argp1 = 0 ;
17467 int res1 = 0 ;
17468 int val2 ;
17469 int ecode2 = 0 ;
17470 int val3 ;
17471 int ecode3 = 0 ;
17472 PyObject * obj0 = 0 ;
17473 PyObject * obj1 = 0 ;
17474 PyObject * obj2 = 0 ;
17475 char * kwnames[] = {
17476 (char *) "self",(char *) "x",(char *) "y", NULL
17477 };
17478
17479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17481 if (!SWIG_IsOK(res1)) {
17482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17483 }
17484 arg1 = reinterpret_cast< wxImage * >(argp1);
17485 ecode2 = SWIG_AsVal_int(obj1, &val2);
17486 if (!SWIG_IsOK(ecode2)) {
17487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
17488 }
17489 arg2 = static_cast< int >(val2);
17490 ecode3 = SWIG_AsVal_int(obj2, &val3);
17491 if (!SWIG_IsOK(ecode3)) {
17492 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
17493 }
17494 arg3 = static_cast< int >(val3);
17495 {
17496 PyThreadState* __tstate = wxPyBeginAllowThreads();
17497 result = (byte)(arg1)->GetAlpha(arg2,arg3);
17498 wxPyEndAllowThreads(__tstate);
17499 if (PyErr_Occurred()) SWIG_fail;
17500 }
17501 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
17502 return resultobj;
17503 fail:
17504 return NULL;
17505 }
17506
17507
17508 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17509 PyObject *resultobj = 0;
17510 wxImage *arg1 = (wxImage *) 0 ;
17511 bool result;
17512 void *argp1 = 0 ;
17513 int res1 = 0 ;
17514 PyObject *swig_obj[1] ;
17515
17516 if (!args) SWIG_fail;
17517 swig_obj[0] = args;
17518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17519 if (!SWIG_IsOK(res1)) {
17520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17521 }
17522 arg1 = reinterpret_cast< wxImage * >(argp1);
17523 {
17524 PyThreadState* __tstate = wxPyBeginAllowThreads();
17525 result = (bool)(arg1)->HasAlpha();
17526 wxPyEndAllowThreads(__tstate);
17527 if (PyErr_Occurred()) SWIG_fail;
17528 }
17529 {
17530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17531 }
17532 return resultobj;
17533 fail:
17534 return NULL;
17535 }
17536
17537
17538 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17539 PyObject *resultobj = 0;
17540 wxImage *arg1 = (wxImage *) 0 ;
17541 void *argp1 = 0 ;
17542 int res1 = 0 ;
17543 PyObject *swig_obj[1] ;
17544
17545 if (!args) SWIG_fail;
17546 swig_obj[0] = args;
17547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17548 if (!SWIG_IsOK(res1)) {
17549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17550 }
17551 arg1 = reinterpret_cast< wxImage * >(argp1);
17552 {
17553 PyThreadState* __tstate = wxPyBeginAllowThreads();
17554 (arg1)->InitAlpha();
17555 wxPyEndAllowThreads(__tstate);
17556 if (PyErr_Occurred()) SWIG_fail;
17557 }
17558 resultobj = SWIG_Py_Void();
17559 return resultobj;
17560 fail:
17561 return NULL;
17562 }
17563
17564
17565 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17566 PyObject *resultobj = 0;
17567 wxImage *arg1 = (wxImage *) 0 ;
17568 int arg2 ;
17569 int arg3 ;
17570 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17571 bool result;
17572 void *argp1 = 0 ;
17573 int res1 = 0 ;
17574 int val2 ;
17575 int ecode2 = 0 ;
17576 int val3 ;
17577 int ecode3 = 0 ;
17578 unsigned char val4 ;
17579 int ecode4 = 0 ;
17580 PyObject * obj0 = 0 ;
17581 PyObject * obj1 = 0 ;
17582 PyObject * obj2 = 0 ;
17583 PyObject * obj3 = 0 ;
17584 char * kwnames[] = {
17585 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
17586 };
17587
17588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) 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_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
17592 }
17593 arg1 = reinterpret_cast< wxImage * >(argp1);
17594 ecode2 = SWIG_AsVal_int(obj1, &val2);
17595 if (!SWIG_IsOK(ecode2)) {
17596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
17597 }
17598 arg2 = static_cast< int >(val2);
17599 ecode3 = SWIG_AsVal_int(obj2, &val3);
17600 if (!SWIG_IsOK(ecode3)) {
17601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
17602 }
17603 arg3 = static_cast< int >(val3);
17604 if (obj3) {
17605 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17606 if (!SWIG_IsOK(ecode4)) {
17607 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
17608 }
17609 arg4 = static_cast< byte >(val4);
17610 }
17611 {
17612 PyThreadState* __tstate = wxPyBeginAllowThreads();
17613 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17614 wxPyEndAllowThreads(__tstate);
17615 if (PyErr_Occurred()) SWIG_fail;
17616 }
17617 {
17618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17619 }
17620 return resultobj;
17621 fail:
17622 return NULL;
17623 }
17624
17625
17626 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17627 PyObject *resultobj = 0;
17628 wxImage *arg1 = (wxImage *) 0 ;
17629 byte *arg2 = (byte *) 0 ;
17630 byte *arg3 = (byte *) 0 ;
17631 byte *arg4 = (byte *) 0 ;
17632 byte arg5 = (byte) 0 ;
17633 byte arg6 = (byte) 0 ;
17634 byte arg7 = (byte) 0 ;
17635 bool result;
17636 void *argp1 = 0 ;
17637 int res1 = 0 ;
17638 byte temp2 ;
17639 int res2 = SWIG_TMPOBJ ;
17640 byte temp3 ;
17641 int res3 = SWIG_TMPOBJ ;
17642 byte temp4 ;
17643 int res4 = SWIG_TMPOBJ ;
17644 unsigned char val5 ;
17645 int ecode5 = 0 ;
17646 unsigned char val6 ;
17647 int ecode6 = 0 ;
17648 unsigned char val7 ;
17649 int ecode7 = 0 ;
17650 PyObject * obj0 = 0 ;
17651 PyObject * obj1 = 0 ;
17652 PyObject * obj2 = 0 ;
17653 PyObject * obj3 = 0 ;
17654 char * kwnames[] = {
17655 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17656 };
17657
17658 arg2 = &temp2;
17659 arg3 = &temp3;
17660 arg4 = &temp4;
17661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17663 if (!SWIG_IsOK(res1)) {
17664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17665 }
17666 arg1 = reinterpret_cast< wxImage * >(argp1);
17667 if (obj1) {
17668 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17669 if (!SWIG_IsOK(ecode5)) {
17670 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17671 }
17672 arg5 = static_cast< byte >(val5);
17673 }
17674 if (obj2) {
17675 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17676 if (!SWIG_IsOK(ecode6)) {
17677 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17678 }
17679 arg6 = static_cast< byte >(val6);
17680 }
17681 if (obj3) {
17682 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17683 if (!SWIG_IsOK(ecode7)) {
17684 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17685 }
17686 arg7 = static_cast< byte >(val7);
17687 }
17688 {
17689 PyThreadState* __tstate = wxPyBeginAllowThreads();
17690 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17691 wxPyEndAllowThreads(__tstate);
17692 if (PyErr_Occurred()) SWIG_fail;
17693 }
17694 {
17695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17696 }
17697 if (SWIG_IsTmpObj(res2)) {
17698 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17699 } else {
17700 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17701 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17702 }
17703 if (SWIG_IsTmpObj(res3)) {
17704 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17705 } else {
17706 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17708 }
17709 if (SWIG_IsTmpObj(res4)) {
17710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17711 } else {
17712 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17714 }
17715 return resultobj;
17716 fail:
17717 return NULL;
17718 }
17719
17720
17721 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17722 PyObject *resultobj = 0;
17723 wxImage *arg1 = (wxImage *) 0 ;
17724 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17725 bool result;
17726 void *argp1 = 0 ;
17727 int res1 = 0 ;
17728 unsigned char val2 ;
17729 int ecode2 = 0 ;
17730 PyObject * obj0 = 0 ;
17731 PyObject * obj1 = 0 ;
17732 char * kwnames[] = {
17733 (char *) "self",(char *) "threshold", NULL
17734 };
17735
17736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17738 if (!SWIG_IsOK(res1)) {
17739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17740 }
17741 arg1 = reinterpret_cast< wxImage * >(argp1);
17742 if (obj1) {
17743 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17744 if (!SWIG_IsOK(ecode2)) {
17745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17746 }
17747 arg2 = static_cast< byte >(val2);
17748 }
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17752 wxPyEndAllowThreads(__tstate);
17753 if (PyErr_Occurred()) SWIG_fail;
17754 }
17755 {
17756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17757 }
17758 return resultobj;
17759 fail:
17760 return NULL;
17761 }
17762
17763
17764 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17765 PyObject *resultobj = 0;
17766 wxImage *arg1 = (wxImage *) 0 ;
17767 byte arg2 ;
17768 byte arg3 ;
17769 byte arg4 ;
17770 bool result;
17771 void *argp1 = 0 ;
17772 int res1 = 0 ;
17773 unsigned char val2 ;
17774 int ecode2 = 0 ;
17775 unsigned char val3 ;
17776 int ecode3 = 0 ;
17777 unsigned char val4 ;
17778 int ecode4 = 0 ;
17779 PyObject * obj0 = 0 ;
17780 PyObject * obj1 = 0 ;
17781 PyObject * obj2 = 0 ;
17782 PyObject * obj3 = 0 ;
17783 char * kwnames[] = {
17784 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17785 };
17786
17787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17789 if (!SWIG_IsOK(res1)) {
17790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17791 }
17792 arg1 = reinterpret_cast< wxImage * >(argp1);
17793 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17794 if (!SWIG_IsOK(ecode2)) {
17795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17796 }
17797 arg2 = static_cast< byte >(val2);
17798 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17799 if (!SWIG_IsOK(ecode3)) {
17800 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17801 }
17802 arg3 = static_cast< byte >(val3);
17803 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17804 if (!SWIG_IsOK(ecode4)) {
17805 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17806 }
17807 arg4 = static_cast< byte >(val4);
17808 {
17809 PyThreadState* __tstate = wxPyBeginAllowThreads();
17810 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17811 wxPyEndAllowThreads(__tstate);
17812 if (PyErr_Occurred()) SWIG_fail;
17813 }
17814 {
17815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17816 }
17817 return resultobj;
17818 fail:
17819 return NULL;
17820 }
17821
17822
17823 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17824 PyObject *resultobj = 0;
17825 wxImage *arg1 = (wxImage *) 0 ;
17826 wxImage *arg2 = 0 ;
17827 byte arg3 ;
17828 byte arg4 ;
17829 byte arg5 ;
17830 bool result;
17831 void *argp1 = 0 ;
17832 int res1 = 0 ;
17833 void *argp2 = 0 ;
17834 int res2 = 0 ;
17835 unsigned char val3 ;
17836 int ecode3 = 0 ;
17837 unsigned char val4 ;
17838 int ecode4 = 0 ;
17839 unsigned char val5 ;
17840 int ecode5 = 0 ;
17841 PyObject * obj0 = 0 ;
17842 PyObject * obj1 = 0 ;
17843 PyObject * obj2 = 0 ;
17844 PyObject * obj3 = 0 ;
17845 PyObject * obj4 = 0 ;
17846 char * kwnames[] = {
17847 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17848 };
17849
17850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17852 if (!SWIG_IsOK(res1)) {
17853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17854 }
17855 arg1 = reinterpret_cast< wxImage * >(argp1);
17856 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17857 if (!SWIG_IsOK(res2)) {
17858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17859 }
17860 if (!argp2) {
17861 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17862 }
17863 arg2 = reinterpret_cast< wxImage * >(argp2);
17864 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17865 if (!SWIG_IsOK(ecode3)) {
17866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17867 }
17868 arg3 = static_cast< byte >(val3);
17869 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17870 if (!SWIG_IsOK(ecode4)) {
17871 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17872 }
17873 arg4 = static_cast< byte >(val4);
17874 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17875 if (!SWIG_IsOK(ecode5)) {
17876 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17877 }
17878 arg5 = static_cast< byte >(val5);
17879 {
17880 PyThreadState* __tstate = wxPyBeginAllowThreads();
17881 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17882 wxPyEndAllowThreads(__tstate);
17883 if (PyErr_Occurred()) SWIG_fail;
17884 }
17885 {
17886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17887 }
17888 return resultobj;
17889 fail:
17890 return NULL;
17891 }
17892
17893
17894 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17895 PyObject *resultobj = 0;
17896 wxString *arg1 = 0 ;
17897 bool result;
17898 bool temp1 = false ;
17899 PyObject * obj0 = 0 ;
17900 char * kwnames[] = {
17901 (char *) "filename", NULL
17902 };
17903
17904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17905 {
17906 arg1 = wxString_in_helper(obj0);
17907 if (arg1 == NULL) SWIG_fail;
17908 temp1 = true;
17909 }
17910 {
17911 PyThreadState* __tstate = wxPyBeginAllowThreads();
17912 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17913 wxPyEndAllowThreads(__tstate);
17914 if (PyErr_Occurred()) SWIG_fail;
17915 }
17916 {
17917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17918 }
17919 {
17920 if (temp1)
17921 delete arg1;
17922 }
17923 return resultobj;
17924 fail:
17925 {
17926 if (temp1)
17927 delete arg1;
17928 }
17929 return NULL;
17930 }
17931
17932
17933 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17934 PyObject *resultobj = 0;
17935 wxString *arg1 = 0 ;
17936 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17937 int result;
17938 bool temp1 = false ;
17939 long val2 ;
17940 int ecode2 = 0 ;
17941 PyObject * obj0 = 0 ;
17942 PyObject * obj1 = 0 ;
17943 char * kwnames[] = {
17944 (char *) "filename",(char *) "type", NULL
17945 };
17946
17947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17948 {
17949 arg1 = wxString_in_helper(obj0);
17950 if (arg1 == NULL) SWIG_fail;
17951 temp1 = true;
17952 }
17953 if (obj1) {
17954 ecode2 = SWIG_AsVal_long(obj1, &val2);
17955 if (!SWIG_IsOK(ecode2)) {
17956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17957 }
17958 arg2 = static_cast< long >(val2);
17959 }
17960 {
17961 PyThreadState* __tstate = wxPyBeginAllowThreads();
17962 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17963 wxPyEndAllowThreads(__tstate);
17964 if (PyErr_Occurred()) SWIG_fail;
17965 }
17966 resultobj = SWIG_From_int(static_cast< int >(result));
17967 {
17968 if (temp1)
17969 delete arg1;
17970 }
17971 return resultobj;
17972 fail:
17973 {
17974 if (temp1)
17975 delete arg1;
17976 }
17977 return NULL;
17978 }
17979
17980
17981 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17982 PyObject *resultobj = 0;
17983 wxImage *arg1 = (wxImage *) 0 ;
17984 wxString *arg2 = 0 ;
17985 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17986 int arg4 = (int) -1 ;
17987 bool result;
17988 void *argp1 = 0 ;
17989 int res1 = 0 ;
17990 bool temp2 = false ;
17991 long val3 ;
17992 int ecode3 = 0 ;
17993 int val4 ;
17994 int ecode4 = 0 ;
17995 PyObject * obj0 = 0 ;
17996 PyObject * obj1 = 0 ;
17997 PyObject * obj2 = 0 ;
17998 PyObject * obj3 = 0 ;
17999 char * kwnames[] = {
18000 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
18001 };
18002
18003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18005 if (!SWIG_IsOK(res1)) {
18006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
18007 }
18008 arg1 = reinterpret_cast< wxImage * >(argp1);
18009 {
18010 arg2 = wxString_in_helper(obj1);
18011 if (arg2 == NULL) SWIG_fail;
18012 temp2 = true;
18013 }
18014 if (obj2) {
18015 ecode3 = SWIG_AsVal_long(obj2, &val3);
18016 if (!SWIG_IsOK(ecode3)) {
18017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
18018 }
18019 arg3 = static_cast< long >(val3);
18020 }
18021 if (obj3) {
18022 ecode4 = SWIG_AsVal_int(obj3, &val4);
18023 if (!SWIG_IsOK(ecode4)) {
18024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
18025 }
18026 arg4 = static_cast< int >(val4);
18027 }
18028 {
18029 PyThreadState* __tstate = wxPyBeginAllowThreads();
18030 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
18031 wxPyEndAllowThreads(__tstate);
18032 if (PyErr_Occurred()) SWIG_fail;
18033 }
18034 {
18035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18036 }
18037 {
18038 if (temp2)
18039 delete arg2;
18040 }
18041 return resultobj;
18042 fail:
18043 {
18044 if (temp2)
18045 delete arg2;
18046 }
18047 return NULL;
18048 }
18049
18050
18051 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18052 PyObject *resultobj = 0;
18053 wxImage *arg1 = (wxImage *) 0 ;
18054 wxString *arg2 = 0 ;
18055 wxString *arg3 = 0 ;
18056 int arg4 = (int) -1 ;
18057 bool result;
18058 void *argp1 = 0 ;
18059 int res1 = 0 ;
18060 bool temp2 = false ;
18061 bool temp3 = false ;
18062 int val4 ;
18063 int ecode4 = 0 ;
18064 PyObject * obj0 = 0 ;
18065 PyObject * obj1 = 0 ;
18066 PyObject * obj2 = 0 ;
18067 PyObject * obj3 = 0 ;
18068 char * kwnames[] = {
18069 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
18070 };
18071
18072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18074 if (!SWIG_IsOK(res1)) {
18075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18076 }
18077 arg1 = reinterpret_cast< wxImage * >(argp1);
18078 {
18079 arg2 = wxString_in_helper(obj1);
18080 if (arg2 == NULL) SWIG_fail;
18081 temp2 = true;
18082 }
18083 {
18084 arg3 = wxString_in_helper(obj2);
18085 if (arg3 == NULL) SWIG_fail;
18086 temp3 = true;
18087 }
18088 if (obj3) {
18089 ecode4 = SWIG_AsVal_int(obj3, &val4);
18090 if (!SWIG_IsOK(ecode4)) {
18091 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
18092 }
18093 arg4 = static_cast< int >(val4);
18094 }
18095 {
18096 PyThreadState* __tstate = wxPyBeginAllowThreads();
18097 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
18098 wxPyEndAllowThreads(__tstate);
18099 if (PyErr_Occurred()) SWIG_fail;
18100 }
18101 {
18102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18103 }
18104 {
18105 if (temp2)
18106 delete arg2;
18107 }
18108 {
18109 if (temp3)
18110 delete arg3;
18111 }
18112 return resultobj;
18113 fail:
18114 {
18115 if (temp2)
18116 delete arg2;
18117 }
18118 {
18119 if (temp3)
18120 delete arg3;
18121 }
18122 return NULL;
18123 }
18124
18125
18126 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18127 PyObject *resultobj = 0;
18128 wxImage *arg1 = (wxImage *) 0 ;
18129 wxString *arg2 = 0 ;
18130 int arg3 ;
18131 bool result;
18132 void *argp1 = 0 ;
18133 int res1 = 0 ;
18134 bool temp2 = false ;
18135 int val3 ;
18136 int ecode3 = 0 ;
18137 PyObject * obj0 = 0 ;
18138 PyObject * obj1 = 0 ;
18139 PyObject * obj2 = 0 ;
18140 char * kwnames[] = {
18141 (char *) "self",(char *) "name",(char *) "type", NULL
18142 };
18143
18144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18146 if (!SWIG_IsOK(res1)) {
18147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
18148 }
18149 arg1 = reinterpret_cast< wxImage * >(argp1);
18150 {
18151 arg2 = wxString_in_helper(obj1);
18152 if (arg2 == NULL) SWIG_fail;
18153 temp2 = true;
18154 }
18155 ecode3 = SWIG_AsVal_int(obj2, &val3);
18156 if (!SWIG_IsOK(ecode3)) {
18157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
18158 }
18159 arg3 = static_cast< int >(val3);
18160 {
18161 PyThreadState* __tstate = wxPyBeginAllowThreads();
18162 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
18163 wxPyEndAllowThreads(__tstate);
18164 if (PyErr_Occurred()) SWIG_fail;
18165 }
18166 {
18167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18168 }
18169 {
18170 if (temp2)
18171 delete arg2;
18172 }
18173 return resultobj;
18174 fail:
18175 {
18176 if (temp2)
18177 delete arg2;
18178 }
18179 return NULL;
18180 }
18181
18182
18183 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18184 PyObject *resultobj = 0;
18185 wxImage *arg1 = (wxImage *) 0 ;
18186 wxString *arg2 = 0 ;
18187 wxString *arg3 = 0 ;
18188 bool result;
18189 void *argp1 = 0 ;
18190 int res1 = 0 ;
18191 bool temp2 = false ;
18192 bool temp3 = false ;
18193 PyObject * obj0 = 0 ;
18194 PyObject * obj1 = 0 ;
18195 PyObject * obj2 = 0 ;
18196 char * kwnames[] = {
18197 (char *) "self",(char *) "name",(char *) "mimetype", NULL
18198 };
18199
18200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) 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_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
18204 }
18205 arg1 = reinterpret_cast< wxImage * >(argp1);
18206 {
18207 arg2 = wxString_in_helper(obj1);
18208 if (arg2 == NULL) SWIG_fail;
18209 temp2 = true;
18210 }
18211 {
18212 arg3 = wxString_in_helper(obj2);
18213 if (arg3 == NULL) SWIG_fail;
18214 temp3 = true;
18215 }
18216 {
18217 PyThreadState* __tstate = wxPyBeginAllowThreads();
18218 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
18219 wxPyEndAllowThreads(__tstate);
18220 if (PyErr_Occurred()) SWIG_fail;
18221 }
18222 {
18223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18224 }
18225 {
18226 if (temp2)
18227 delete arg2;
18228 }
18229 {
18230 if (temp3)
18231 delete arg3;
18232 }
18233 return resultobj;
18234 fail:
18235 {
18236 if (temp2)
18237 delete arg2;
18238 }
18239 {
18240 if (temp3)
18241 delete arg3;
18242 }
18243 return NULL;
18244 }
18245
18246
18247 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj = 0;
18249 wxInputStream *arg1 = 0 ;
18250 bool result;
18251 wxPyInputStream *temp1 ;
18252 bool created1 ;
18253 PyObject * obj0 = 0 ;
18254 char * kwnames[] = {
18255 (char *) "stream", NULL
18256 };
18257
18258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
18259 {
18260 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
18261 arg1 = temp1->m_wxis;
18262 created1 = false;
18263 } else {
18264 PyErr_Clear(); // clear the failure of the wxPyConvert above
18265 arg1 = wxPyCBInputStream_create(obj0, false);
18266 if (arg1 == NULL) {
18267 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18268 SWIG_fail;
18269 }
18270 created1 = true;
18271 }
18272 }
18273 {
18274 PyThreadState* __tstate = wxPyBeginAllowThreads();
18275 result = (bool)wxImage::CanRead(*arg1);
18276 wxPyEndAllowThreads(__tstate);
18277 if (PyErr_Occurred()) SWIG_fail;
18278 }
18279 {
18280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18281 }
18282 {
18283 if (created1) delete arg1;
18284 }
18285 return resultobj;
18286 fail:
18287 {
18288 if (created1) delete arg1;
18289 }
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj = 0;
18296 wxImage *arg1 = (wxImage *) 0 ;
18297 wxInputStream *arg2 = 0 ;
18298 long arg3 = (long) wxBITMAP_TYPE_ANY ;
18299 int arg4 = (int) -1 ;
18300 bool result;
18301 void *argp1 = 0 ;
18302 int res1 = 0 ;
18303 wxPyInputStream *temp2 ;
18304 bool created2 ;
18305 long val3 ;
18306 int ecode3 = 0 ;
18307 int val4 ;
18308 int ecode4 = 0 ;
18309 PyObject * obj0 = 0 ;
18310 PyObject * obj1 = 0 ;
18311 PyObject * obj2 = 0 ;
18312 PyObject * obj3 = 0 ;
18313 char * kwnames[] = {
18314 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
18315 };
18316
18317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18319 if (!SWIG_IsOK(res1)) {
18320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
18321 }
18322 arg1 = reinterpret_cast< wxImage * >(argp1);
18323 {
18324 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18325 arg2 = temp2->m_wxis;
18326 created2 = false;
18327 } else {
18328 PyErr_Clear(); // clear the failure of the wxPyConvert above
18329 arg2 = wxPyCBInputStream_create(obj1, false);
18330 if (arg2 == NULL) {
18331 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18332 SWIG_fail;
18333 }
18334 created2 = true;
18335 }
18336 }
18337 if (obj2) {
18338 ecode3 = SWIG_AsVal_long(obj2, &val3);
18339 if (!SWIG_IsOK(ecode3)) {
18340 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
18341 }
18342 arg3 = static_cast< long >(val3);
18343 }
18344 if (obj3) {
18345 ecode4 = SWIG_AsVal_int(obj3, &val4);
18346 if (!SWIG_IsOK(ecode4)) {
18347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
18348 }
18349 arg4 = static_cast< int >(val4);
18350 }
18351 {
18352 PyThreadState* __tstate = wxPyBeginAllowThreads();
18353 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
18354 wxPyEndAllowThreads(__tstate);
18355 if (PyErr_Occurred()) SWIG_fail;
18356 }
18357 {
18358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18359 }
18360 {
18361 if (created2) delete arg2;
18362 }
18363 return resultobj;
18364 fail:
18365 {
18366 if (created2) delete arg2;
18367 }
18368 return NULL;
18369 }
18370
18371
18372 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18373 PyObject *resultobj = 0;
18374 wxImage *arg1 = (wxImage *) 0 ;
18375 wxInputStream *arg2 = 0 ;
18376 wxString *arg3 = 0 ;
18377 int arg4 = (int) -1 ;
18378 bool result;
18379 void *argp1 = 0 ;
18380 int res1 = 0 ;
18381 wxPyInputStream *temp2 ;
18382 bool created2 ;
18383 bool temp3 = false ;
18384 int val4 ;
18385 int ecode4 = 0 ;
18386 PyObject * obj0 = 0 ;
18387 PyObject * obj1 = 0 ;
18388 PyObject * obj2 = 0 ;
18389 PyObject * obj3 = 0 ;
18390 char * kwnames[] = {
18391 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
18392 };
18393
18394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18396 if (!SWIG_IsOK(res1)) {
18397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
18398 }
18399 arg1 = reinterpret_cast< wxImage * >(argp1);
18400 {
18401 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
18402 arg2 = temp2->m_wxis;
18403 created2 = false;
18404 } else {
18405 PyErr_Clear(); // clear the failure of the wxPyConvert above
18406 arg2 = wxPyCBInputStream_create(obj1, false);
18407 if (arg2 == NULL) {
18408 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
18409 SWIG_fail;
18410 }
18411 created2 = true;
18412 }
18413 }
18414 {
18415 arg3 = wxString_in_helper(obj2);
18416 if (arg3 == NULL) SWIG_fail;
18417 temp3 = true;
18418 }
18419 if (obj3) {
18420 ecode4 = SWIG_AsVal_int(obj3, &val4);
18421 if (!SWIG_IsOK(ecode4)) {
18422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
18423 }
18424 arg4 = static_cast< int >(val4);
18425 }
18426 {
18427 PyThreadState* __tstate = wxPyBeginAllowThreads();
18428 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
18429 wxPyEndAllowThreads(__tstate);
18430 if (PyErr_Occurred()) SWIG_fail;
18431 }
18432 {
18433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18434 }
18435 {
18436 if (created2) delete arg2;
18437 }
18438 {
18439 if (temp3)
18440 delete arg3;
18441 }
18442 return resultobj;
18443 fail:
18444 {
18445 if (created2) delete arg2;
18446 }
18447 {
18448 if (temp3)
18449 delete arg3;
18450 }
18451 return NULL;
18452 }
18453
18454
18455 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18456 PyObject *resultobj = 0;
18457 wxImage *arg1 = (wxImage *) 0 ;
18458 bool result;
18459 void *argp1 = 0 ;
18460 int res1 = 0 ;
18461 PyObject *swig_obj[1] ;
18462
18463 if (!args) SWIG_fail;
18464 swig_obj[0] = args;
18465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18466 if (!SWIG_IsOK(res1)) {
18467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
18468 }
18469 arg1 = reinterpret_cast< wxImage * >(argp1);
18470 {
18471 PyThreadState* __tstate = wxPyBeginAllowThreads();
18472 result = (bool)(arg1)->IsOk();
18473 wxPyEndAllowThreads(__tstate);
18474 if (PyErr_Occurred()) SWIG_fail;
18475 }
18476 {
18477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18478 }
18479 return resultobj;
18480 fail:
18481 return NULL;
18482 }
18483
18484
18485 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18486 PyObject *resultobj = 0;
18487 wxImage *arg1 = (wxImage *) 0 ;
18488 int result;
18489 void *argp1 = 0 ;
18490 int res1 = 0 ;
18491 PyObject *swig_obj[1] ;
18492
18493 if (!args) SWIG_fail;
18494 swig_obj[0] = args;
18495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18496 if (!SWIG_IsOK(res1)) {
18497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
18498 }
18499 arg1 = reinterpret_cast< wxImage * >(argp1);
18500 {
18501 PyThreadState* __tstate = wxPyBeginAllowThreads();
18502 result = (int)(arg1)->GetWidth();
18503 wxPyEndAllowThreads(__tstate);
18504 if (PyErr_Occurred()) SWIG_fail;
18505 }
18506 resultobj = SWIG_From_int(static_cast< int >(result));
18507 return resultobj;
18508 fail:
18509 return NULL;
18510 }
18511
18512
18513 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18514 PyObject *resultobj = 0;
18515 wxImage *arg1 = (wxImage *) 0 ;
18516 int result;
18517 void *argp1 = 0 ;
18518 int res1 = 0 ;
18519 PyObject *swig_obj[1] ;
18520
18521 if (!args) SWIG_fail;
18522 swig_obj[0] = args;
18523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18524 if (!SWIG_IsOK(res1)) {
18525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
18526 }
18527 arg1 = reinterpret_cast< wxImage * >(argp1);
18528 {
18529 PyThreadState* __tstate = wxPyBeginAllowThreads();
18530 result = (int)(arg1)->GetHeight();
18531 wxPyEndAllowThreads(__tstate);
18532 if (PyErr_Occurred()) SWIG_fail;
18533 }
18534 resultobj = SWIG_From_int(static_cast< int >(result));
18535 return resultobj;
18536 fail:
18537 return NULL;
18538 }
18539
18540
18541 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18542 PyObject *resultobj = 0;
18543 wxImage *arg1 = (wxImage *) 0 ;
18544 wxSize result;
18545 void *argp1 = 0 ;
18546 int res1 = 0 ;
18547 PyObject *swig_obj[1] ;
18548
18549 if (!args) SWIG_fail;
18550 swig_obj[0] = args;
18551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18552 if (!SWIG_IsOK(res1)) {
18553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
18554 }
18555 arg1 = reinterpret_cast< wxImage * >(argp1);
18556 {
18557 PyThreadState* __tstate = wxPyBeginAllowThreads();
18558 result = wxImage_GetSize(arg1);
18559 wxPyEndAllowThreads(__tstate);
18560 if (PyErr_Occurred()) SWIG_fail;
18561 }
18562 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
18563 return resultobj;
18564 fail:
18565 return NULL;
18566 }
18567
18568
18569 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18570 PyObject *resultobj = 0;
18571 wxImage *arg1 = (wxImage *) 0 ;
18572 wxRect *arg2 = 0 ;
18573 SwigValueWrapper<wxImage > result;
18574 void *argp1 = 0 ;
18575 int res1 = 0 ;
18576 wxRect temp2 ;
18577 PyObject * obj0 = 0 ;
18578 PyObject * obj1 = 0 ;
18579 char * kwnames[] = {
18580 (char *) "self",(char *) "rect", NULL
18581 };
18582
18583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
18584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18585 if (!SWIG_IsOK(res1)) {
18586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
18587 }
18588 arg1 = reinterpret_cast< wxImage * >(argp1);
18589 {
18590 arg2 = &temp2;
18591 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
18592 }
18593 {
18594 PyThreadState* __tstate = wxPyBeginAllowThreads();
18595 result = (arg1)->GetSubImage((wxRect const &)*arg2);
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18600 return resultobj;
18601 fail:
18602 return NULL;
18603 }
18604
18605
18606 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18607 PyObject *resultobj = 0;
18608 wxImage *arg1 = (wxImage *) 0 ;
18609 wxSize *arg2 = 0 ;
18610 wxPoint *arg3 = 0 ;
18611 int arg4 = (int) -1 ;
18612 int arg5 = (int) -1 ;
18613 int arg6 = (int) -1 ;
18614 SwigValueWrapper<wxImage > result;
18615 void *argp1 = 0 ;
18616 int res1 = 0 ;
18617 wxSize temp2 ;
18618 wxPoint temp3 ;
18619 int val4 ;
18620 int ecode4 = 0 ;
18621 int val5 ;
18622 int ecode5 = 0 ;
18623 int val6 ;
18624 int ecode6 = 0 ;
18625 PyObject * obj0 = 0 ;
18626 PyObject * obj1 = 0 ;
18627 PyObject * obj2 = 0 ;
18628 PyObject * obj3 = 0 ;
18629 PyObject * obj4 = 0 ;
18630 PyObject * obj5 = 0 ;
18631 char * kwnames[] = {
18632 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18633 };
18634
18635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18637 if (!SWIG_IsOK(res1)) {
18638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18639 }
18640 arg1 = reinterpret_cast< wxImage * >(argp1);
18641 {
18642 arg2 = &temp2;
18643 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18644 }
18645 {
18646 arg3 = &temp3;
18647 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18648 }
18649 if (obj3) {
18650 ecode4 = SWIG_AsVal_int(obj3, &val4);
18651 if (!SWIG_IsOK(ecode4)) {
18652 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18653 }
18654 arg4 = static_cast< int >(val4);
18655 }
18656 if (obj4) {
18657 ecode5 = SWIG_AsVal_int(obj4, &val5);
18658 if (!SWIG_IsOK(ecode5)) {
18659 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18660 }
18661 arg5 = static_cast< int >(val5);
18662 }
18663 if (obj5) {
18664 ecode6 = SWIG_AsVal_int(obj5, &val6);
18665 if (!SWIG_IsOK(ecode6)) {
18666 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18667 }
18668 arg6 = static_cast< int >(val6);
18669 }
18670 {
18671 PyThreadState* __tstate = wxPyBeginAllowThreads();
18672 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18673 wxPyEndAllowThreads(__tstate);
18674 if (PyErr_Occurred()) SWIG_fail;
18675 }
18676 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18677 return resultobj;
18678 fail:
18679 return NULL;
18680 }
18681
18682
18683 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18684 PyObject *resultobj = 0;
18685 wxImage *arg1 = (wxImage *) 0 ;
18686 SwigValueWrapper<wxImage > result;
18687 void *argp1 = 0 ;
18688 int res1 = 0 ;
18689 PyObject *swig_obj[1] ;
18690
18691 if (!args) SWIG_fail;
18692 swig_obj[0] = args;
18693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18694 if (!SWIG_IsOK(res1)) {
18695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18696 }
18697 arg1 = reinterpret_cast< wxImage * >(argp1);
18698 {
18699 PyThreadState* __tstate = wxPyBeginAllowThreads();
18700 result = (arg1)->Copy();
18701 wxPyEndAllowThreads(__tstate);
18702 if (PyErr_Occurred()) SWIG_fail;
18703 }
18704 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18705 return resultobj;
18706 fail:
18707 return NULL;
18708 }
18709
18710
18711 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18712 PyObject *resultobj = 0;
18713 wxImage *arg1 = (wxImage *) 0 ;
18714 wxImage *arg2 = 0 ;
18715 int arg3 ;
18716 int arg4 ;
18717 void *argp1 = 0 ;
18718 int res1 = 0 ;
18719 void *argp2 = 0 ;
18720 int res2 = 0 ;
18721 int val3 ;
18722 int ecode3 = 0 ;
18723 int val4 ;
18724 int ecode4 = 0 ;
18725 PyObject * obj0 = 0 ;
18726 PyObject * obj1 = 0 ;
18727 PyObject * obj2 = 0 ;
18728 PyObject * obj3 = 0 ;
18729 char * kwnames[] = {
18730 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18731 };
18732
18733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18735 if (!SWIG_IsOK(res1)) {
18736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18737 }
18738 arg1 = reinterpret_cast< wxImage * >(argp1);
18739 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18740 if (!SWIG_IsOK(res2)) {
18741 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18742 }
18743 if (!argp2) {
18744 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18745 }
18746 arg2 = reinterpret_cast< wxImage * >(argp2);
18747 ecode3 = SWIG_AsVal_int(obj2, &val3);
18748 if (!SWIG_IsOK(ecode3)) {
18749 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18750 }
18751 arg3 = static_cast< int >(val3);
18752 ecode4 = SWIG_AsVal_int(obj3, &val4);
18753 if (!SWIG_IsOK(ecode4)) {
18754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18755 }
18756 arg4 = static_cast< int >(val4);
18757 {
18758 PyThreadState* __tstate = wxPyBeginAllowThreads();
18759 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18760 wxPyEndAllowThreads(__tstate);
18761 if (PyErr_Occurred()) SWIG_fail;
18762 }
18763 resultobj = SWIG_Py_Void();
18764 return resultobj;
18765 fail:
18766 return NULL;
18767 }
18768
18769
18770 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18771 PyObject *resultobj = 0;
18772 wxImage *arg1 = (wxImage *) 0 ;
18773 PyObject *result = 0 ;
18774 void *argp1 = 0 ;
18775 int res1 = 0 ;
18776 PyObject *swig_obj[1] ;
18777
18778 if (!args) SWIG_fail;
18779 swig_obj[0] = args;
18780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18781 if (!SWIG_IsOK(res1)) {
18782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18783 }
18784 arg1 = reinterpret_cast< wxImage * >(argp1);
18785 {
18786 PyThreadState* __tstate = wxPyBeginAllowThreads();
18787 result = (PyObject *)wxImage_GetData(arg1);
18788 wxPyEndAllowThreads(__tstate);
18789 if (PyErr_Occurred()) SWIG_fail;
18790 }
18791 resultobj = result;
18792 return resultobj;
18793 fail:
18794 return NULL;
18795 }
18796
18797
18798 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18799 PyObject *resultobj = 0;
18800 wxImage *arg1 = (wxImage *) 0 ;
18801 buffer arg2 ;
18802 int arg3 ;
18803 void *argp1 = 0 ;
18804 int res1 = 0 ;
18805 Py_ssize_t temp2 ;
18806 PyObject * obj0 = 0 ;
18807 PyObject * obj1 = 0 ;
18808 char * kwnames[] = {
18809 (char *) "self",(char *) "data", NULL
18810 };
18811
18812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18814 if (!SWIG_IsOK(res1)) {
18815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18816 }
18817 arg1 = reinterpret_cast< wxImage * >(argp1);
18818 {
18819 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18820 arg3 = (int)temp2;
18821 }
18822 {
18823 PyThreadState* __tstate = wxPyBeginAllowThreads();
18824 wxImage_SetData(arg1,arg2,arg3);
18825 wxPyEndAllowThreads(__tstate);
18826 if (PyErr_Occurred()) SWIG_fail;
18827 }
18828 resultobj = SWIG_Py_Void();
18829 return resultobj;
18830 fail:
18831 return NULL;
18832 }
18833
18834
18835 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18836 PyObject *resultobj = 0;
18837 wxImage *arg1 = (wxImage *) 0 ;
18838 PyObject *result = 0 ;
18839 void *argp1 = 0 ;
18840 int res1 = 0 ;
18841 PyObject *swig_obj[1] ;
18842
18843 if (!args) SWIG_fail;
18844 swig_obj[0] = args;
18845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18846 if (!SWIG_IsOK(res1)) {
18847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18848 }
18849 arg1 = reinterpret_cast< wxImage * >(argp1);
18850 {
18851 PyThreadState* __tstate = wxPyBeginAllowThreads();
18852 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18853 wxPyEndAllowThreads(__tstate);
18854 if (PyErr_Occurred()) SWIG_fail;
18855 }
18856 resultobj = result;
18857 return resultobj;
18858 fail:
18859 return NULL;
18860 }
18861
18862
18863 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18864 PyObject *resultobj = 0;
18865 wxImage *arg1 = (wxImage *) 0 ;
18866 buffer arg2 ;
18867 int arg3 ;
18868 void *argp1 = 0 ;
18869 int res1 = 0 ;
18870 Py_ssize_t temp2 ;
18871 PyObject * obj0 = 0 ;
18872 PyObject * obj1 = 0 ;
18873 char * kwnames[] = {
18874 (char *) "self",(char *) "data", NULL
18875 };
18876
18877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18879 if (!SWIG_IsOK(res1)) {
18880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18881 }
18882 arg1 = reinterpret_cast< wxImage * >(argp1);
18883 {
18884 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18885 arg3 = (int)temp2;
18886 }
18887 {
18888 PyThreadState* __tstate = wxPyBeginAllowThreads();
18889 wxImage_SetDataBuffer(arg1,arg2,arg3);
18890 wxPyEndAllowThreads(__tstate);
18891 if (PyErr_Occurred()) SWIG_fail;
18892 }
18893 resultobj = SWIG_Py_Void();
18894 return resultobj;
18895 fail:
18896 return NULL;
18897 }
18898
18899
18900 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18901 PyObject *resultobj = 0;
18902 wxImage *arg1 = (wxImage *) 0 ;
18903 PyObject *result = 0 ;
18904 void *argp1 = 0 ;
18905 int res1 = 0 ;
18906 PyObject *swig_obj[1] ;
18907
18908 if (!args) SWIG_fail;
18909 swig_obj[0] = args;
18910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18911 if (!SWIG_IsOK(res1)) {
18912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18913 }
18914 arg1 = reinterpret_cast< wxImage * >(argp1);
18915 {
18916 PyThreadState* __tstate = wxPyBeginAllowThreads();
18917 result = (PyObject *)wxImage_GetAlphaData(arg1);
18918 wxPyEndAllowThreads(__tstate);
18919 if (PyErr_Occurred()) SWIG_fail;
18920 }
18921 resultobj = result;
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj = 0;
18930 wxImage *arg1 = (wxImage *) 0 ;
18931 buffer arg2 ;
18932 int arg3 ;
18933 void *argp1 = 0 ;
18934 int res1 = 0 ;
18935 Py_ssize_t temp2 ;
18936 PyObject * obj0 = 0 ;
18937 PyObject * obj1 = 0 ;
18938 char * kwnames[] = {
18939 (char *) "self",(char *) "alpha", NULL
18940 };
18941
18942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18944 if (!SWIG_IsOK(res1)) {
18945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18946 }
18947 arg1 = reinterpret_cast< wxImage * >(argp1);
18948 {
18949 if (obj1 != Py_None) {
18950 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18951 arg3 = (int)temp2;
18952 }
18953 }
18954 {
18955 PyThreadState* __tstate = wxPyBeginAllowThreads();
18956 wxImage_SetAlphaData(arg1,arg2,arg3);
18957 wxPyEndAllowThreads(__tstate);
18958 if (PyErr_Occurred()) SWIG_fail;
18959 }
18960 resultobj = SWIG_Py_Void();
18961 return resultobj;
18962 fail:
18963 return NULL;
18964 }
18965
18966
18967 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18968 PyObject *resultobj = 0;
18969 wxImage *arg1 = (wxImage *) 0 ;
18970 PyObject *result = 0 ;
18971 void *argp1 = 0 ;
18972 int res1 = 0 ;
18973 PyObject *swig_obj[1] ;
18974
18975 if (!args) SWIG_fail;
18976 swig_obj[0] = args;
18977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18978 if (!SWIG_IsOK(res1)) {
18979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18980 }
18981 arg1 = reinterpret_cast< wxImage * >(argp1);
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18985 wxPyEndAllowThreads(__tstate);
18986 if (PyErr_Occurred()) SWIG_fail;
18987 }
18988 resultobj = result;
18989 return resultobj;
18990 fail:
18991 return NULL;
18992 }
18993
18994
18995 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18996 PyObject *resultobj = 0;
18997 wxImage *arg1 = (wxImage *) 0 ;
18998 buffer arg2 ;
18999 int arg3 ;
19000 void *argp1 = 0 ;
19001 int res1 = 0 ;
19002 Py_ssize_t temp2 ;
19003 PyObject * obj0 = 0 ;
19004 PyObject * obj1 = 0 ;
19005 char * kwnames[] = {
19006 (char *) "self",(char *) "alpha", NULL
19007 };
19008
19009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
19010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19011 if (!SWIG_IsOK(res1)) {
19012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
19013 }
19014 arg1 = reinterpret_cast< wxImage * >(argp1);
19015 {
19016 if (obj1 != Py_None) {
19017 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
19018 arg3 = (int)temp2;
19019 }
19020 }
19021 {
19022 PyThreadState* __tstate = wxPyBeginAllowThreads();
19023 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
19024 wxPyEndAllowThreads(__tstate);
19025 if (PyErr_Occurred()) SWIG_fail;
19026 }
19027 resultobj = SWIG_Py_Void();
19028 return resultobj;
19029 fail:
19030 return NULL;
19031 }
19032
19033
19034 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19035 PyObject *resultobj = 0;
19036 wxImage *arg1 = (wxImage *) 0 ;
19037 byte arg2 ;
19038 byte arg3 ;
19039 byte arg4 ;
19040 void *argp1 = 0 ;
19041 int res1 = 0 ;
19042 unsigned char val2 ;
19043 int ecode2 = 0 ;
19044 unsigned char val3 ;
19045 int ecode3 = 0 ;
19046 unsigned char val4 ;
19047 int ecode4 = 0 ;
19048 PyObject * obj0 = 0 ;
19049 PyObject * obj1 = 0 ;
19050 PyObject * obj2 = 0 ;
19051 PyObject * obj3 = 0 ;
19052 char * kwnames[] = {
19053 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19054 };
19055
19056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19058 if (!SWIG_IsOK(res1)) {
19059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
19060 }
19061 arg1 = reinterpret_cast< wxImage * >(argp1);
19062 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19063 if (!SWIG_IsOK(ecode2)) {
19064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
19065 }
19066 arg2 = static_cast< byte >(val2);
19067 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19068 if (!SWIG_IsOK(ecode3)) {
19069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
19070 }
19071 arg3 = static_cast< byte >(val3);
19072 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19073 if (!SWIG_IsOK(ecode4)) {
19074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
19075 }
19076 arg4 = static_cast< byte >(val4);
19077 {
19078 PyThreadState* __tstate = wxPyBeginAllowThreads();
19079 (arg1)->SetMaskColour(arg2,arg3,arg4);
19080 wxPyEndAllowThreads(__tstate);
19081 if (PyErr_Occurred()) SWIG_fail;
19082 }
19083 resultobj = SWIG_Py_Void();
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19091 PyObject *resultobj = 0;
19092 wxImage *arg1 = (wxImage *) 0 ;
19093 byte *arg2 = (byte *) 0 ;
19094 byte *arg3 = (byte *) 0 ;
19095 byte *arg4 = (byte *) 0 ;
19096 void *argp1 = 0 ;
19097 int res1 = 0 ;
19098 byte temp2 ;
19099 int res2 = SWIG_TMPOBJ ;
19100 byte temp3 ;
19101 int res3 = SWIG_TMPOBJ ;
19102 byte temp4 ;
19103 int res4 = SWIG_TMPOBJ ;
19104 PyObject *swig_obj[1] ;
19105
19106 arg2 = &temp2;
19107 arg3 = &temp3;
19108 arg4 = &temp4;
19109 if (!args) SWIG_fail;
19110 swig_obj[0] = args;
19111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19112 if (!SWIG_IsOK(res1)) {
19113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
19114 }
19115 arg1 = reinterpret_cast< wxImage * >(argp1);
19116 {
19117 PyThreadState* __tstate = wxPyBeginAllowThreads();
19118 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
19119 wxPyEndAllowThreads(__tstate);
19120 if (PyErr_Occurred()) SWIG_fail;
19121 }
19122 resultobj = SWIG_Py_Void();
19123 if (SWIG_IsTmpObj(res2)) {
19124 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
19125 } else {
19126 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
19128 }
19129 if (SWIG_IsTmpObj(res3)) {
19130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
19131 } else {
19132 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
19134 }
19135 if (SWIG_IsTmpObj(res4)) {
19136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
19137 } else {
19138 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
19139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
19140 }
19141 return resultobj;
19142 fail:
19143 return NULL;
19144 }
19145
19146
19147 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19148 PyObject *resultobj = 0;
19149 wxImage *arg1 = (wxImage *) 0 ;
19150 byte result;
19151 void *argp1 = 0 ;
19152 int res1 = 0 ;
19153 PyObject *swig_obj[1] ;
19154
19155 if (!args) SWIG_fail;
19156 swig_obj[0] = args;
19157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19158 if (!SWIG_IsOK(res1)) {
19159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
19160 }
19161 arg1 = reinterpret_cast< wxImage * >(argp1);
19162 {
19163 PyThreadState* __tstate = wxPyBeginAllowThreads();
19164 result = (byte)(arg1)->GetMaskRed();
19165 wxPyEndAllowThreads(__tstate);
19166 if (PyErr_Occurred()) SWIG_fail;
19167 }
19168 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19169 return resultobj;
19170 fail:
19171 return NULL;
19172 }
19173
19174
19175 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19176 PyObject *resultobj = 0;
19177 wxImage *arg1 = (wxImage *) 0 ;
19178 byte result;
19179 void *argp1 = 0 ;
19180 int res1 = 0 ;
19181 PyObject *swig_obj[1] ;
19182
19183 if (!args) SWIG_fail;
19184 swig_obj[0] = args;
19185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19186 if (!SWIG_IsOK(res1)) {
19187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
19188 }
19189 arg1 = reinterpret_cast< wxImage * >(argp1);
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 result = (byte)(arg1)->GetMaskGreen();
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19204 PyObject *resultobj = 0;
19205 wxImage *arg1 = (wxImage *) 0 ;
19206 byte result;
19207 void *argp1 = 0 ;
19208 int res1 = 0 ;
19209 PyObject *swig_obj[1] ;
19210
19211 if (!args) SWIG_fail;
19212 swig_obj[0] = args;
19213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19214 if (!SWIG_IsOK(res1)) {
19215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
19216 }
19217 arg1 = reinterpret_cast< wxImage * >(argp1);
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 result = (byte)(arg1)->GetMaskBlue();
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
19225 return resultobj;
19226 fail:
19227 return NULL;
19228 }
19229
19230
19231 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19232 PyObject *resultobj = 0;
19233 wxImage *arg1 = (wxImage *) 0 ;
19234 bool arg2 = (bool) true ;
19235 void *argp1 = 0 ;
19236 int res1 = 0 ;
19237 bool val2 ;
19238 int ecode2 = 0 ;
19239 PyObject * obj0 = 0 ;
19240 PyObject * obj1 = 0 ;
19241 char * kwnames[] = {
19242 (char *) "self",(char *) "mask", NULL
19243 };
19244
19245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
19246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19247 if (!SWIG_IsOK(res1)) {
19248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
19249 }
19250 arg1 = reinterpret_cast< wxImage * >(argp1);
19251 if (obj1) {
19252 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19253 if (!SWIG_IsOK(ecode2)) {
19254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
19255 }
19256 arg2 = static_cast< bool >(val2);
19257 }
19258 {
19259 PyThreadState* __tstate = wxPyBeginAllowThreads();
19260 (arg1)->SetMask(arg2);
19261 wxPyEndAllowThreads(__tstate);
19262 if (PyErr_Occurred()) SWIG_fail;
19263 }
19264 resultobj = SWIG_Py_Void();
19265 return resultobj;
19266 fail:
19267 return NULL;
19268 }
19269
19270
19271 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19272 PyObject *resultobj = 0;
19273 wxImage *arg1 = (wxImage *) 0 ;
19274 bool result;
19275 void *argp1 = 0 ;
19276 int res1 = 0 ;
19277 PyObject *swig_obj[1] ;
19278
19279 if (!args) SWIG_fail;
19280 swig_obj[0] = args;
19281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19282 if (!SWIG_IsOK(res1)) {
19283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
19284 }
19285 arg1 = reinterpret_cast< wxImage * >(argp1);
19286 {
19287 PyThreadState* __tstate = wxPyBeginAllowThreads();
19288 result = (bool)(arg1)->HasMask();
19289 wxPyEndAllowThreads(__tstate);
19290 if (PyErr_Occurred()) SWIG_fail;
19291 }
19292 {
19293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19294 }
19295 return resultobj;
19296 fail:
19297 return NULL;
19298 }
19299
19300
19301 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19302 PyObject *resultobj = 0;
19303 wxImage *arg1 = (wxImage *) 0 ;
19304 double arg2 ;
19305 wxPoint *arg3 = 0 ;
19306 bool arg4 = (bool) true ;
19307 wxPoint *arg5 = (wxPoint *) NULL ;
19308 SwigValueWrapper<wxImage > result;
19309 void *argp1 = 0 ;
19310 int res1 = 0 ;
19311 double val2 ;
19312 int ecode2 = 0 ;
19313 wxPoint temp3 ;
19314 bool val4 ;
19315 int ecode4 = 0 ;
19316 void *argp5 = 0 ;
19317 int res5 = 0 ;
19318 PyObject * obj0 = 0 ;
19319 PyObject * obj1 = 0 ;
19320 PyObject * obj2 = 0 ;
19321 PyObject * obj3 = 0 ;
19322 PyObject * obj4 = 0 ;
19323 char * kwnames[] = {
19324 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
19325 };
19326
19327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
19328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19329 if (!SWIG_IsOK(res1)) {
19330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
19331 }
19332 arg1 = reinterpret_cast< wxImage * >(argp1);
19333 ecode2 = SWIG_AsVal_double(obj1, &val2);
19334 if (!SWIG_IsOK(ecode2)) {
19335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
19336 }
19337 arg2 = static_cast< double >(val2);
19338 {
19339 arg3 = &temp3;
19340 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
19341 }
19342 if (obj3) {
19343 ecode4 = SWIG_AsVal_bool(obj3, &val4);
19344 if (!SWIG_IsOK(ecode4)) {
19345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
19346 }
19347 arg4 = static_cast< bool >(val4);
19348 }
19349 if (obj4) {
19350 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
19351 if (!SWIG_IsOK(res5)) {
19352 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
19353 }
19354 arg5 = reinterpret_cast< wxPoint * >(argp5);
19355 }
19356 {
19357 PyThreadState* __tstate = wxPyBeginAllowThreads();
19358 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
19359 wxPyEndAllowThreads(__tstate);
19360 if (PyErr_Occurred()) SWIG_fail;
19361 }
19362 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19363 return resultobj;
19364 fail:
19365 return NULL;
19366 }
19367
19368
19369 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19370 PyObject *resultobj = 0;
19371 wxImage *arg1 = (wxImage *) 0 ;
19372 bool arg2 = (bool) true ;
19373 SwigValueWrapper<wxImage > result;
19374 void *argp1 = 0 ;
19375 int res1 = 0 ;
19376 bool val2 ;
19377 int ecode2 = 0 ;
19378 PyObject * obj0 = 0 ;
19379 PyObject * obj1 = 0 ;
19380 char * kwnames[] = {
19381 (char *) "self",(char *) "clockwise", NULL
19382 };
19383
19384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
19385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19386 if (!SWIG_IsOK(res1)) {
19387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
19388 }
19389 arg1 = reinterpret_cast< wxImage * >(argp1);
19390 if (obj1) {
19391 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19392 if (!SWIG_IsOK(ecode2)) {
19393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
19394 }
19395 arg2 = static_cast< bool >(val2);
19396 }
19397 {
19398 PyThreadState* __tstate = wxPyBeginAllowThreads();
19399 result = (arg1)->Rotate90(arg2);
19400 wxPyEndAllowThreads(__tstate);
19401 if (PyErr_Occurred()) SWIG_fail;
19402 }
19403 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19404 return resultobj;
19405 fail:
19406 return NULL;
19407 }
19408
19409
19410 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19411 PyObject *resultobj = 0;
19412 wxImage *arg1 = (wxImage *) 0 ;
19413 bool arg2 = (bool) true ;
19414 SwigValueWrapper<wxImage > result;
19415 void *argp1 = 0 ;
19416 int res1 = 0 ;
19417 bool val2 ;
19418 int ecode2 = 0 ;
19419 PyObject * obj0 = 0 ;
19420 PyObject * obj1 = 0 ;
19421 char * kwnames[] = {
19422 (char *) "self",(char *) "horizontally", NULL
19423 };
19424
19425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
19426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19427 if (!SWIG_IsOK(res1)) {
19428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
19429 }
19430 arg1 = reinterpret_cast< wxImage * >(argp1);
19431 if (obj1) {
19432 ecode2 = SWIG_AsVal_bool(obj1, &val2);
19433 if (!SWIG_IsOK(ecode2)) {
19434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
19435 }
19436 arg2 = static_cast< bool >(val2);
19437 }
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = (arg1)->Mirror(arg2);
19441 wxPyEndAllowThreads(__tstate);
19442 if (PyErr_Occurred()) SWIG_fail;
19443 }
19444 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19445 return resultobj;
19446 fail:
19447 return NULL;
19448 }
19449
19450
19451 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19452 PyObject *resultobj = 0;
19453 wxImage *arg1 = (wxImage *) 0 ;
19454 byte arg2 ;
19455 byte arg3 ;
19456 byte arg4 ;
19457 byte arg5 ;
19458 byte arg6 ;
19459 byte arg7 ;
19460 void *argp1 = 0 ;
19461 int res1 = 0 ;
19462 unsigned char val2 ;
19463 int ecode2 = 0 ;
19464 unsigned char val3 ;
19465 int ecode3 = 0 ;
19466 unsigned char val4 ;
19467 int ecode4 = 0 ;
19468 unsigned char val5 ;
19469 int ecode5 = 0 ;
19470 unsigned char val6 ;
19471 int ecode6 = 0 ;
19472 unsigned char val7 ;
19473 int ecode7 = 0 ;
19474 PyObject * obj0 = 0 ;
19475 PyObject * obj1 = 0 ;
19476 PyObject * obj2 = 0 ;
19477 PyObject * obj3 = 0 ;
19478 PyObject * obj4 = 0 ;
19479 PyObject * obj5 = 0 ;
19480 PyObject * obj6 = 0 ;
19481 char * kwnames[] = {
19482 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
19483 };
19484
19485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
19486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19487 if (!SWIG_IsOK(res1)) {
19488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
19489 }
19490 arg1 = reinterpret_cast< wxImage * >(argp1);
19491 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19492 if (!SWIG_IsOK(ecode2)) {
19493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
19494 }
19495 arg2 = static_cast< byte >(val2);
19496 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19497 if (!SWIG_IsOK(ecode3)) {
19498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
19499 }
19500 arg3 = static_cast< byte >(val3);
19501 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19502 if (!SWIG_IsOK(ecode4)) {
19503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
19504 }
19505 arg4 = static_cast< byte >(val4);
19506 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
19507 if (!SWIG_IsOK(ecode5)) {
19508 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
19509 }
19510 arg5 = static_cast< byte >(val5);
19511 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
19512 if (!SWIG_IsOK(ecode6)) {
19513 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
19514 }
19515 arg6 = static_cast< byte >(val6);
19516 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
19517 if (!SWIG_IsOK(ecode7)) {
19518 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
19519 }
19520 arg7 = static_cast< byte >(val7);
19521 {
19522 PyThreadState* __tstate = wxPyBeginAllowThreads();
19523 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 resultobj = SWIG_Py_Void();
19528 return resultobj;
19529 fail:
19530 return NULL;
19531 }
19532
19533
19534 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19535 PyObject *resultobj = 0;
19536 wxImage *arg1 = (wxImage *) 0 ;
19537 double arg2 = (double) 0.299 ;
19538 double arg3 = (double) 0.587 ;
19539 double arg4 = (double) 0.114 ;
19540 SwigValueWrapper<wxImage > result;
19541 void *argp1 = 0 ;
19542 int res1 = 0 ;
19543 double val2 ;
19544 int ecode2 = 0 ;
19545 double val3 ;
19546 int ecode3 = 0 ;
19547 double val4 ;
19548 int ecode4 = 0 ;
19549 PyObject * obj0 = 0 ;
19550 PyObject * obj1 = 0 ;
19551 PyObject * obj2 = 0 ;
19552 PyObject * obj3 = 0 ;
19553 char * kwnames[] = {
19554 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
19555 };
19556
19557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19559 if (!SWIG_IsOK(res1)) {
19560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
19561 }
19562 arg1 = reinterpret_cast< wxImage * >(argp1);
19563 if (obj1) {
19564 ecode2 = SWIG_AsVal_double(obj1, &val2);
19565 if (!SWIG_IsOK(ecode2)) {
19566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
19567 }
19568 arg2 = static_cast< double >(val2);
19569 }
19570 if (obj2) {
19571 ecode3 = SWIG_AsVal_double(obj2, &val3);
19572 if (!SWIG_IsOK(ecode3)) {
19573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
19574 }
19575 arg3 = static_cast< double >(val3);
19576 }
19577 if (obj3) {
19578 ecode4 = SWIG_AsVal_double(obj3, &val4);
19579 if (!SWIG_IsOK(ecode4)) {
19580 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
19581 }
19582 arg4 = static_cast< double >(val4);
19583 }
19584 {
19585 PyThreadState* __tstate = wxPyBeginAllowThreads();
19586 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
19587 wxPyEndAllowThreads(__tstate);
19588 if (PyErr_Occurred()) SWIG_fail;
19589 }
19590 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19591 return resultobj;
19592 fail:
19593 return NULL;
19594 }
19595
19596
19597 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19598 PyObject *resultobj = 0;
19599 wxImage *arg1 = (wxImage *) 0 ;
19600 byte arg2 ;
19601 byte arg3 ;
19602 byte arg4 ;
19603 SwigValueWrapper<wxImage > result;
19604 void *argp1 = 0 ;
19605 int res1 = 0 ;
19606 unsigned char val2 ;
19607 int ecode2 = 0 ;
19608 unsigned char val3 ;
19609 int ecode3 = 0 ;
19610 unsigned char val4 ;
19611 int ecode4 = 0 ;
19612 PyObject * obj0 = 0 ;
19613 PyObject * obj1 = 0 ;
19614 PyObject * obj2 = 0 ;
19615 PyObject * obj3 = 0 ;
19616 char * kwnames[] = {
19617 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19618 };
19619
19620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19622 if (!SWIG_IsOK(res1)) {
19623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19624 }
19625 arg1 = reinterpret_cast< wxImage * >(argp1);
19626 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19627 if (!SWIG_IsOK(ecode2)) {
19628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19629 }
19630 arg2 = static_cast< byte >(val2);
19631 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19632 if (!SWIG_IsOK(ecode3)) {
19633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19634 }
19635 arg3 = static_cast< byte >(val3);
19636 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19637 if (!SWIG_IsOK(ecode4)) {
19638 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19639 }
19640 arg4 = static_cast< byte >(val4);
19641 {
19642 PyThreadState* __tstate = wxPyBeginAllowThreads();
19643 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19644 wxPyEndAllowThreads(__tstate);
19645 if (PyErr_Occurred()) SWIG_fail;
19646 }
19647 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19648 return resultobj;
19649 fail:
19650 return NULL;
19651 }
19652
19653
19654 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19655 PyObject *resultobj = 0;
19656 wxImage *arg1 = (wxImage *) 0 ;
19657 wxString *arg2 = 0 ;
19658 wxString *arg3 = 0 ;
19659 void *argp1 = 0 ;
19660 int res1 = 0 ;
19661 bool temp2 = false ;
19662 bool temp3 = false ;
19663 PyObject * obj0 = 0 ;
19664 PyObject * obj1 = 0 ;
19665 PyObject * obj2 = 0 ;
19666 char * kwnames[] = {
19667 (char *) "self",(char *) "name",(char *) "value", NULL
19668 };
19669
19670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19672 if (!SWIG_IsOK(res1)) {
19673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19674 }
19675 arg1 = reinterpret_cast< wxImage * >(argp1);
19676 {
19677 arg2 = wxString_in_helper(obj1);
19678 if (arg2 == NULL) SWIG_fail;
19679 temp2 = true;
19680 }
19681 {
19682 arg3 = wxString_in_helper(obj2);
19683 if (arg3 == NULL) SWIG_fail;
19684 temp3 = true;
19685 }
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19689 wxPyEndAllowThreads(__tstate);
19690 if (PyErr_Occurred()) SWIG_fail;
19691 }
19692 resultobj = SWIG_Py_Void();
19693 {
19694 if (temp2)
19695 delete arg2;
19696 }
19697 {
19698 if (temp3)
19699 delete arg3;
19700 }
19701 return resultobj;
19702 fail:
19703 {
19704 if (temp2)
19705 delete arg2;
19706 }
19707 {
19708 if (temp3)
19709 delete arg3;
19710 }
19711 return NULL;
19712 }
19713
19714
19715 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19716 PyObject *resultobj = 0;
19717 wxImage *arg1 = (wxImage *) 0 ;
19718 wxString *arg2 = 0 ;
19719 int arg3 ;
19720 void *argp1 = 0 ;
19721 int res1 = 0 ;
19722 bool temp2 = false ;
19723 int val3 ;
19724 int ecode3 = 0 ;
19725 PyObject * obj0 = 0 ;
19726 PyObject * obj1 = 0 ;
19727 PyObject * obj2 = 0 ;
19728 char * kwnames[] = {
19729 (char *) "self",(char *) "name",(char *) "value", NULL
19730 };
19731
19732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19734 if (!SWIG_IsOK(res1)) {
19735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19736 }
19737 arg1 = reinterpret_cast< wxImage * >(argp1);
19738 {
19739 arg2 = wxString_in_helper(obj1);
19740 if (arg2 == NULL) SWIG_fail;
19741 temp2 = true;
19742 }
19743 ecode3 = SWIG_AsVal_int(obj2, &val3);
19744 if (!SWIG_IsOK(ecode3)) {
19745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19746 }
19747 arg3 = static_cast< int >(val3);
19748 {
19749 PyThreadState* __tstate = wxPyBeginAllowThreads();
19750 (arg1)->SetOption((wxString const &)*arg2,arg3);
19751 wxPyEndAllowThreads(__tstate);
19752 if (PyErr_Occurred()) SWIG_fail;
19753 }
19754 resultobj = SWIG_Py_Void();
19755 {
19756 if (temp2)
19757 delete arg2;
19758 }
19759 return resultobj;
19760 fail:
19761 {
19762 if (temp2)
19763 delete arg2;
19764 }
19765 return NULL;
19766 }
19767
19768
19769 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19770 PyObject *resultobj = 0;
19771 wxImage *arg1 = (wxImage *) 0 ;
19772 wxString *arg2 = 0 ;
19773 wxString result;
19774 void *argp1 = 0 ;
19775 int res1 = 0 ;
19776 bool temp2 = false ;
19777 PyObject * obj0 = 0 ;
19778 PyObject * obj1 = 0 ;
19779 char * kwnames[] = {
19780 (char *) "self",(char *) "name", NULL
19781 };
19782
19783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19785 if (!SWIG_IsOK(res1)) {
19786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19787 }
19788 arg1 = reinterpret_cast< wxImage * >(argp1);
19789 {
19790 arg2 = wxString_in_helper(obj1);
19791 if (arg2 == NULL) SWIG_fail;
19792 temp2 = true;
19793 }
19794 {
19795 PyThreadState* __tstate = wxPyBeginAllowThreads();
19796 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19797 wxPyEndAllowThreads(__tstate);
19798 if (PyErr_Occurred()) SWIG_fail;
19799 }
19800 {
19801 #if wxUSE_UNICODE
19802 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19803 #else
19804 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19805 #endif
19806 }
19807 {
19808 if (temp2)
19809 delete arg2;
19810 }
19811 return resultobj;
19812 fail:
19813 {
19814 if (temp2)
19815 delete arg2;
19816 }
19817 return NULL;
19818 }
19819
19820
19821 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19822 PyObject *resultobj = 0;
19823 wxImage *arg1 = (wxImage *) 0 ;
19824 wxString *arg2 = 0 ;
19825 int result;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 bool temp2 = false ;
19829 PyObject * obj0 = 0 ;
19830 PyObject * obj1 = 0 ;
19831 char * kwnames[] = {
19832 (char *) "self",(char *) "name", NULL
19833 };
19834
19835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19837 if (!SWIG_IsOK(res1)) {
19838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19839 }
19840 arg1 = reinterpret_cast< wxImage * >(argp1);
19841 {
19842 arg2 = wxString_in_helper(obj1);
19843 if (arg2 == NULL) SWIG_fail;
19844 temp2 = true;
19845 }
19846 {
19847 PyThreadState* __tstate = wxPyBeginAllowThreads();
19848 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19849 wxPyEndAllowThreads(__tstate);
19850 if (PyErr_Occurred()) SWIG_fail;
19851 }
19852 resultobj = SWIG_From_int(static_cast< int >(result));
19853 {
19854 if (temp2)
19855 delete arg2;
19856 }
19857 return resultobj;
19858 fail:
19859 {
19860 if (temp2)
19861 delete arg2;
19862 }
19863 return NULL;
19864 }
19865
19866
19867 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19868 PyObject *resultobj = 0;
19869 wxImage *arg1 = (wxImage *) 0 ;
19870 wxString *arg2 = 0 ;
19871 bool result;
19872 void *argp1 = 0 ;
19873 int res1 = 0 ;
19874 bool temp2 = false ;
19875 PyObject * obj0 = 0 ;
19876 PyObject * obj1 = 0 ;
19877 char * kwnames[] = {
19878 (char *) "self",(char *) "name", NULL
19879 };
19880
19881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19883 if (!SWIG_IsOK(res1)) {
19884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19885 }
19886 arg1 = reinterpret_cast< wxImage * >(argp1);
19887 {
19888 arg2 = wxString_in_helper(obj1);
19889 if (arg2 == NULL) SWIG_fail;
19890 temp2 = true;
19891 }
19892 {
19893 PyThreadState* __tstate = wxPyBeginAllowThreads();
19894 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19895 wxPyEndAllowThreads(__tstate);
19896 if (PyErr_Occurred()) SWIG_fail;
19897 }
19898 {
19899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19900 }
19901 {
19902 if (temp2)
19903 delete arg2;
19904 }
19905 return resultobj;
19906 fail:
19907 {
19908 if (temp2)
19909 delete arg2;
19910 }
19911 return NULL;
19912 }
19913
19914
19915 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19916 PyObject *resultobj = 0;
19917 wxImage *arg1 = (wxImage *) 0 ;
19918 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19919 unsigned long result;
19920 void *argp1 = 0 ;
19921 int res1 = 0 ;
19922 unsigned long val2 ;
19923 int ecode2 = 0 ;
19924 PyObject * obj0 = 0 ;
19925 PyObject * obj1 = 0 ;
19926 char * kwnames[] = {
19927 (char *) "self",(char *) "stopafter", NULL
19928 };
19929
19930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19932 if (!SWIG_IsOK(res1)) {
19933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19934 }
19935 arg1 = reinterpret_cast< wxImage * >(argp1);
19936 if (obj1) {
19937 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19938 if (!SWIG_IsOK(ecode2)) {
19939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19940 }
19941 arg2 = static_cast< unsigned long >(val2);
19942 }
19943 {
19944 PyThreadState* __tstate = wxPyBeginAllowThreads();
19945 result = (unsigned long)(arg1)->CountColours(arg2);
19946 wxPyEndAllowThreads(__tstate);
19947 if (PyErr_Occurred()) SWIG_fail;
19948 }
19949 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19950 return resultobj;
19951 fail:
19952 return NULL;
19953 }
19954
19955
19956 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19957 PyObject *resultobj = 0;
19958 wxImage *arg1 = (wxImage *) 0 ;
19959 wxImageHistogram *arg2 = 0 ;
19960 unsigned long result;
19961 void *argp1 = 0 ;
19962 int res1 = 0 ;
19963 void *argp2 = 0 ;
19964 int res2 = 0 ;
19965 PyObject * obj0 = 0 ;
19966 PyObject * obj1 = 0 ;
19967 char * kwnames[] = {
19968 (char *) "self",(char *) "h", NULL
19969 };
19970
19971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19973 if (!SWIG_IsOK(res1)) {
19974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19975 }
19976 arg1 = reinterpret_cast< wxImage * >(argp1);
19977 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19978 if (!SWIG_IsOK(res2)) {
19979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19980 }
19981 if (!argp2) {
19982 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19983 }
19984 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19985 {
19986 PyThreadState* __tstate = wxPyBeginAllowThreads();
19987 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19988 wxPyEndAllowThreads(__tstate);
19989 if (PyErr_Occurred()) SWIG_fail;
19990 }
19991 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19992 return resultobj;
19993 fail:
19994 return NULL;
19995 }
19996
19997
19998 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19999 PyObject *resultobj = 0;
20000 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20001 void *argp1 = 0 ;
20002 int res1 = 0 ;
20003 PyObject * obj0 = 0 ;
20004 char * kwnames[] = {
20005 (char *) "handler", NULL
20006 };
20007
20008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
20009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20010 if (!SWIG_IsOK(res1)) {
20011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20012 }
20013 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20014 {
20015 PyThreadState* __tstate = wxPyBeginAllowThreads();
20016 wxImage::AddHandler(arg1);
20017 wxPyEndAllowThreads(__tstate);
20018 if (PyErr_Occurred()) SWIG_fail;
20019 }
20020 resultobj = SWIG_Py_Void();
20021 return resultobj;
20022 fail:
20023 return NULL;
20024 }
20025
20026
20027 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20028 PyObject *resultobj = 0;
20029 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
20030 void *argp1 = 0 ;
20031 int res1 = 0 ;
20032 PyObject * obj0 = 0 ;
20033 char * kwnames[] = {
20034 (char *) "handler", NULL
20035 };
20036
20037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
20038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
20039 if (!SWIG_IsOK(res1)) {
20040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
20041 }
20042 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
20043 {
20044 PyThreadState* __tstate = wxPyBeginAllowThreads();
20045 wxImage::InsertHandler(arg1);
20046 wxPyEndAllowThreads(__tstate);
20047 if (PyErr_Occurred()) SWIG_fail;
20048 }
20049 resultobj = SWIG_Py_Void();
20050 return resultobj;
20051 fail:
20052 return NULL;
20053 }
20054
20055
20056 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20057 PyObject *resultobj = 0;
20058 wxString *arg1 = 0 ;
20059 bool result;
20060 bool temp1 = false ;
20061 PyObject * obj0 = 0 ;
20062 char * kwnames[] = {
20063 (char *) "name", NULL
20064 };
20065
20066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
20067 {
20068 arg1 = wxString_in_helper(obj0);
20069 if (arg1 == NULL) SWIG_fail;
20070 temp1 = true;
20071 }
20072 {
20073 PyThreadState* __tstate = wxPyBeginAllowThreads();
20074 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
20075 wxPyEndAllowThreads(__tstate);
20076 if (PyErr_Occurred()) SWIG_fail;
20077 }
20078 {
20079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20080 }
20081 {
20082 if (temp1)
20083 delete arg1;
20084 }
20085 return resultobj;
20086 fail:
20087 {
20088 if (temp1)
20089 delete arg1;
20090 }
20091 return NULL;
20092 }
20093
20094
20095 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20096 PyObject *resultobj = 0;
20097 PyObject *result = 0 ;
20098
20099 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
20100 {
20101 PyThreadState* __tstate = wxPyBeginAllowThreads();
20102 result = (PyObject *)wxImage_GetHandlers();
20103 wxPyEndAllowThreads(__tstate);
20104 if (PyErr_Occurred()) SWIG_fail;
20105 }
20106 resultobj = result;
20107 return resultobj;
20108 fail:
20109 return NULL;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20114 PyObject *resultobj = 0;
20115 wxString result;
20116
20117 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 result = wxImage::GetImageExtWildcard();
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 {
20125 #if wxUSE_UNICODE
20126 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20127 #else
20128 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20129 #endif
20130 }
20131 return resultobj;
20132 fail:
20133 return NULL;
20134 }
20135
20136
20137 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20138 PyObject *resultobj = 0;
20139 wxImage *arg1 = (wxImage *) 0 ;
20140 int arg2 = (int) -1 ;
20141 wxBitmap result;
20142 void *argp1 = 0 ;
20143 int res1 = 0 ;
20144 int val2 ;
20145 int ecode2 = 0 ;
20146 PyObject * obj0 = 0 ;
20147 PyObject * obj1 = 0 ;
20148 char * kwnames[] = {
20149 (char *) "self",(char *) "depth", NULL
20150 };
20151
20152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
20153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20154 if (!SWIG_IsOK(res1)) {
20155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20156 }
20157 arg1 = reinterpret_cast< wxImage * >(argp1);
20158 if (obj1) {
20159 ecode2 = SWIG_AsVal_int(obj1, &val2);
20160 if (!SWIG_IsOK(ecode2)) {
20161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
20162 }
20163 arg2 = static_cast< int >(val2);
20164 }
20165 {
20166 if (!wxPyCheckForApp()) SWIG_fail;
20167 PyThreadState* __tstate = wxPyBeginAllowThreads();
20168 result = wxImage_ConvertToBitmap(arg1,arg2);
20169 wxPyEndAllowThreads(__tstate);
20170 if (PyErr_Occurred()) SWIG_fail;
20171 }
20172 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20173 return resultobj;
20174 fail:
20175 return NULL;
20176 }
20177
20178
20179 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20180 PyObject *resultobj = 0;
20181 wxImage *arg1 = (wxImage *) 0 ;
20182 byte arg2 ;
20183 byte arg3 ;
20184 byte arg4 ;
20185 wxBitmap result;
20186 void *argp1 = 0 ;
20187 int res1 = 0 ;
20188 unsigned char val2 ;
20189 int ecode2 = 0 ;
20190 unsigned char val3 ;
20191 int ecode3 = 0 ;
20192 unsigned char val4 ;
20193 int ecode4 = 0 ;
20194 PyObject * obj0 = 0 ;
20195 PyObject * obj1 = 0 ;
20196 PyObject * obj2 = 0 ;
20197 PyObject * obj3 = 0 ;
20198 char * kwnames[] = {
20199 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
20200 };
20201
20202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20204 if (!SWIG_IsOK(res1)) {
20205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
20206 }
20207 arg1 = reinterpret_cast< wxImage * >(argp1);
20208 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
20209 if (!SWIG_IsOK(ecode2)) {
20210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
20211 }
20212 arg2 = static_cast< byte >(val2);
20213 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
20214 if (!SWIG_IsOK(ecode3)) {
20215 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
20216 }
20217 arg3 = static_cast< byte >(val3);
20218 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
20219 if (!SWIG_IsOK(ecode4)) {
20220 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
20221 }
20222 arg4 = static_cast< byte >(val4);
20223 {
20224 if (!wxPyCheckForApp()) SWIG_fail;
20225 PyThreadState* __tstate = wxPyBeginAllowThreads();
20226 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
20227 wxPyEndAllowThreads(__tstate);
20228 if (PyErr_Occurred()) SWIG_fail;
20229 }
20230 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
20231 return resultobj;
20232 fail:
20233 return NULL;
20234 }
20235
20236
20237 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20238 PyObject *resultobj = 0;
20239 wxImage *arg1 = (wxImage *) 0 ;
20240 double arg2 ;
20241 void *argp1 = 0 ;
20242 int res1 = 0 ;
20243 double val2 ;
20244 int ecode2 = 0 ;
20245 PyObject * obj0 = 0 ;
20246 PyObject * obj1 = 0 ;
20247 char * kwnames[] = {
20248 (char *) "self",(char *) "angle", NULL
20249 };
20250
20251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
20252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
20253 if (!SWIG_IsOK(res1)) {
20254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
20255 }
20256 arg1 = reinterpret_cast< wxImage * >(argp1);
20257 ecode2 = SWIG_AsVal_double(obj1, &val2);
20258 if (!SWIG_IsOK(ecode2)) {
20259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
20260 }
20261 arg2 = static_cast< double >(val2);
20262 {
20263 PyThreadState* __tstate = wxPyBeginAllowThreads();
20264 (arg1)->RotateHue(arg2);
20265 wxPyEndAllowThreads(__tstate);
20266 if (PyErr_Occurred()) SWIG_fail;
20267 }
20268 resultobj = SWIG_Py_Void();
20269 return resultobj;
20270 fail:
20271 return NULL;
20272 }
20273
20274
20275 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20276 PyObject *resultobj = 0;
20277 wxImage_RGBValue arg1 ;
20278 wxImage_HSVValue result;
20279 void *argp1 ;
20280 int res1 = 0 ;
20281 PyObject * obj0 = 0 ;
20282 char * kwnames[] = {
20283 (char *) "rgb", NULL
20284 };
20285
20286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
20287 {
20288 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
20289 if (!SWIG_IsOK(res1)) {
20290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20291 }
20292 if (!argp1) {
20293 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
20294 } else {
20295 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
20296 arg1 = *temp;
20297 if (SWIG_IsNewObj(res1)) delete temp;
20298 }
20299 }
20300 {
20301 PyThreadState* __tstate = wxPyBeginAllowThreads();
20302 result = wxImage::RGBtoHSV(arg1);
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20314 PyObject *resultobj = 0;
20315 wxImage_HSVValue arg1 ;
20316 wxImage_RGBValue result;
20317 void *argp1 ;
20318 int res1 = 0 ;
20319 PyObject * obj0 = 0 ;
20320 char * kwnames[] = {
20321 (char *) "hsv", NULL
20322 };
20323
20324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
20325 {
20326 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
20327 if (!SWIG_IsOK(res1)) {
20328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20329 }
20330 if (!argp1) {
20331 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
20332 } else {
20333 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
20334 arg1 = *temp;
20335 if (SWIG_IsNewObj(res1)) delete temp;
20336 }
20337 }
20338 {
20339 PyThreadState* __tstate = wxPyBeginAllowThreads();
20340 result = wxImage::HSVtoRGB(arg1);
20341 wxPyEndAllowThreads(__tstate);
20342 if (PyErr_Occurred()) SWIG_fail;
20343 }
20344 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
20345 return resultobj;
20346 fail:
20347 return NULL;
20348 }
20349
20350
20351 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20352 PyObject *obj;
20353 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20354 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
20355 return SWIG_Py_Void();
20356 }
20357
20358 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20359 return SWIG_Python_InitShadowInstance(args);
20360 }
20361
20362 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20363 PyObject *resultobj = 0;
20364 int arg1 ;
20365 int arg2 ;
20366 buffer arg3 ;
20367 int arg4 ;
20368 buffer arg5 = (buffer) NULL ;
20369 int arg6 = (int) 0 ;
20370 wxImage *result = 0 ;
20371 int val1 ;
20372 int ecode1 = 0 ;
20373 int val2 ;
20374 int ecode2 = 0 ;
20375 Py_ssize_t temp3 ;
20376 Py_ssize_t temp5 ;
20377 PyObject * obj0 = 0 ;
20378 PyObject * obj1 = 0 ;
20379 PyObject * obj2 = 0 ;
20380 PyObject * obj3 = 0 ;
20381 char * kwnames[] = {
20382 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
20383 };
20384
20385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20386 ecode1 = SWIG_AsVal_int(obj0, &val1);
20387 if (!SWIG_IsOK(ecode1)) {
20388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
20389 }
20390 arg1 = static_cast< int >(val1);
20391 ecode2 = SWIG_AsVal_int(obj1, &val2);
20392 if (!SWIG_IsOK(ecode2)) {
20393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
20394 }
20395 arg2 = static_cast< int >(val2);
20396 {
20397 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
20398 arg4 = (int)temp3;
20399 }
20400 if (obj3) {
20401 {
20402 if (obj3 != Py_None) {
20403 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
20404 arg6 = (int)temp5;
20405 }
20406 }
20407 }
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 {
20415 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
20416 }
20417 return resultobj;
20418 fail:
20419 return NULL;
20420 }
20421
20422
20423 SWIGINTERN int NullImage_set(PyObject *) {
20424 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
20425 return 1;
20426 }
20427
20428
20429 SWIGINTERN PyObject *NullImage_get(void) {
20430 PyObject *pyobj = 0;
20431
20432 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
20433 return pyobj;
20434 }
20435
20436
20437 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
20438 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
20439 return 1;
20440 }
20441
20442
20443 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
20444 PyObject *pyobj = 0;
20445
20446 {
20447 #if wxUSE_UNICODE
20448 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20449 #else
20450 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
20451 #endif
20452 }
20453 return pyobj;
20454 }
20455
20456
20457 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
20458 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
20459 return 1;
20460 }
20461
20462
20463 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
20464 PyObject *pyobj = 0;
20465
20466 {
20467 #if wxUSE_UNICODE
20468 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20469 #else
20470 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
20471 #endif
20472 }
20473 return pyobj;
20474 }
20475
20476
20477 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
20478 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
20479 return 1;
20480 }
20481
20482
20483 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
20484 PyObject *pyobj = 0;
20485
20486 {
20487 #if wxUSE_UNICODE
20488 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20489 #else
20490 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
20491 #endif
20492 }
20493 return pyobj;
20494 }
20495
20496
20497 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
20498 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
20499 return 1;
20500 }
20501
20502
20503 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
20504 PyObject *pyobj = 0;
20505
20506 {
20507 #if wxUSE_UNICODE
20508 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20509 #else
20510 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
20511 #endif
20512 }
20513 return pyobj;
20514 }
20515
20516
20517 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
20518 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
20519 return 1;
20520 }
20521
20522
20523 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
20524 PyObject *pyobj = 0;
20525
20526 {
20527 #if wxUSE_UNICODE
20528 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20529 #else
20530 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
20531 #endif
20532 }
20533 return pyobj;
20534 }
20535
20536
20537 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
20538 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
20539 return 1;
20540 }
20541
20542
20543 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
20544 PyObject *pyobj = 0;
20545
20546 {
20547 #if wxUSE_UNICODE
20548 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20549 #else
20550 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
20551 #endif
20552 }
20553 return pyobj;
20554 }
20555
20556
20557 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
20558 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
20559 return 1;
20560 }
20561
20562
20563 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
20564 PyObject *pyobj = 0;
20565
20566 {
20567 #if wxUSE_UNICODE
20568 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20569 #else
20570 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
20571 #endif
20572 }
20573 return pyobj;
20574 }
20575
20576
20577 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
20578 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
20579 return 1;
20580 }
20581
20582
20583 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
20584 PyObject *pyobj = 0;
20585
20586 {
20587 #if wxUSE_UNICODE
20588 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20589 #else
20590 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
20591 #endif
20592 }
20593 return pyobj;
20594 }
20595
20596
20597 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
20598 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
20599 return 1;
20600 }
20601
20602
20603 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
20604 PyObject *pyobj = 0;
20605
20606 {
20607 #if wxUSE_UNICODE
20608 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20609 #else
20610 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20611 #endif
20612 }
20613 return pyobj;
20614 }
20615
20616
20617 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20618 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20619 return 1;
20620 }
20621
20622
20623 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20624 PyObject *pyobj = 0;
20625
20626 {
20627 #if wxUSE_UNICODE
20628 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20629 #else
20630 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20631 #endif
20632 }
20633 return pyobj;
20634 }
20635
20636
20637 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20638 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20639 return 1;
20640 }
20641
20642
20643 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20644 PyObject *pyobj = 0;
20645
20646 {
20647 #if wxUSE_UNICODE
20648 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20649 #else
20650 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20651 #endif
20652 }
20653 return pyobj;
20654 }
20655
20656
20657 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20658 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20659 return 1;
20660 }
20661
20662
20663 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20664 PyObject *pyobj = 0;
20665
20666 {
20667 #if wxUSE_UNICODE
20668 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20669 #else
20670 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20671 #endif
20672 }
20673 return pyobj;
20674 }
20675
20676
20677 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20678 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20679 return 1;
20680 }
20681
20682
20683 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20684 PyObject *pyobj = 0;
20685
20686 {
20687 #if wxUSE_UNICODE
20688 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20689 #else
20690 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20691 #endif
20692 }
20693 return pyobj;
20694 }
20695
20696
20697 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20698 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20699 return 1;
20700 }
20701
20702
20703 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20704 PyObject *pyobj = 0;
20705
20706 {
20707 #if wxUSE_UNICODE
20708 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20709 #else
20710 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20711 #endif
20712 }
20713 return pyobj;
20714 }
20715
20716
20717 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20718 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20719 return 1;
20720 }
20721
20722
20723 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20724 PyObject *pyobj = 0;
20725
20726 {
20727 #if wxUSE_UNICODE
20728 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20729 #else
20730 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20731 #endif
20732 }
20733 return pyobj;
20734 }
20735
20736
20737 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20738 PyObject *resultobj = 0;
20739 wxBMPHandler *result = 0 ;
20740
20741 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 result = (wxBMPHandler *)new wxBMPHandler();
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20749 return resultobj;
20750 fail:
20751 return NULL;
20752 }
20753
20754
20755 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20756 PyObject *obj;
20757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20758 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20759 return SWIG_Py_Void();
20760 }
20761
20762 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20763 return SWIG_Python_InitShadowInstance(args);
20764 }
20765
20766 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20767 PyObject *resultobj = 0;
20768 wxICOHandler *result = 0 ;
20769
20770 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20771 {
20772 PyThreadState* __tstate = wxPyBeginAllowThreads();
20773 result = (wxICOHandler *)new wxICOHandler();
20774 wxPyEndAllowThreads(__tstate);
20775 if (PyErr_Occurred()) SWIG_fail;
20776 }
20777 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20778 return resultobj;
20779 fail:
20780 return NULL;
20781 }
20782
20783
20784 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20785 PyObject *obj;
20786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20787 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20788 return SWIG_Py_Void();
20789 }
20790
20791 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20792 return SWIG_Python_InitShadowInstance(args);
20793 }
20794
20795 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20796 PyObject *resultobj = 0;
20797 wxCURHandler *result = 0 ;
20798
20799 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20800 {
20801 PyThreadState* __tstate = wxPyBeginAllowThreads();
20802 result = (wxCURHandler *)new wxCURHandler();
20803 wxPyEndAllowThreads(__tstate);
20804 if (PyErr_Occurred()) SWIG_fail;
20805 }
20806 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20807 return resultobj;
20808 fail:
20809 return NULL;
20810 }
20811
20812
20813 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20814 PyObject *obj;
20815 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20816 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20817 return SWIG_Py_Void();
20818 }
20819
20820 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20821 return SWIG_Python_InitShadowInstance(args);
20822 }
20823
20824 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20825 PyObject *resultobj = 0;
20826 wxANIHandler *result = 0 ;
20827
20828 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 result = (wxANIHandler *)new wxANIHandler();
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 PyObject *obj;
20844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20845 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20846 return SWIG_Py_Void();
20847 }
20848
20849 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20850 return SWIG_Python_InitShadowInstance(args);
20851 }
20852
20853 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20854 PyObject *resultobj = 0;
20855 wxPNGHandler *result = 0 ;
20856
20857 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 result = (wxPNGHandler *)new wxPNGHandler();
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20872 PyObject *obj;
20873 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20874 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20875 return SWIG_Py_Void();
20876 }
20877
20878 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20879 return SWIG_Python_InitShadowInstance(args);
20880 }
20881
20882 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20883 PyObject *resultobj = 0;
20884 wxGIFHandler *result = 0 ;
20885
20886 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20887 {
20888 PyThreadState* __tstate = wxPyBeginAllowThreads();
20889 result = (wxGIFHandler *)new wxGIFHandler();
20890 wxPyEndAllowThreads(__tstate);
20891 if (PyErr_Occurred()) SWIG_fail;
20892 }
20893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20894 return resultobj;
20895 fail:
20896 return NULL;
20897 }
20898
20899
20900 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20901 PyObject *obj;
20902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20903 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20904 return SWIG_Py_Void();
20905 }
20906
20907 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20908 return SWIG_Python_InitShadowInstance(args);
20909 }
20910
20911 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912 PyObject *resultobj = 0;
20913 wxPCXHandler *result = 0 ;
20914
20915 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20916 {
20917 PyThreadState* __tstate = wxPyBeginAllowThreads();
20918 result = (wxPCXHandler *)new wxPCXHandler();
20919 wxPyEndAllowThreads(__tstate);
20920 if (PyErr_Occurred()) SWIG_fail;
20921 }
20922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20923 return resultobj;
20924 fail:
20925 return NULL;
20926 }
20927
20928
20929 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20930 PyObject *obj;
20931 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20932 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20933 return SWIG_Py_Void();
20934 }
20935
20936 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20937 return SWIG_Python_InitShadowInstance(args);
20938 }
20939
20940 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20941 PyObject *resultobj = 0;
20942 wxJPEGHandler *result = 0 ;
20943
20944 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20945 {
20946 PyThreadState* __tstate = wxPyBeginAllowThreads();
20947 result = (wxJPEGHandler *)new wxJPEGHandler();
20948 wxPyEndAllowThreads(__tstate);
20949 if (PyErr_Occurred()) SWIG_fail;
20950 }
20951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20952 return resultobj;
20953 fail:
20954 return NULL;
20955 }
20956
20957
20958 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20959 PyObject *obj;
20960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20961 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20962 return SWIG_Py_Void();
20963 }
20964
20965 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20966 return SWIG_Python_InitShadowInstance(args);
20967 }
20968
20969 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20970 PyObject *resultobj = 0;
20971 wxPNMHandler *result = 0 ;
20972
20973 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20974 {
20975 PyThreadState* __tstate = wxPyBeginAllowThreads();
20976 result = (wxPNMHandler *)new wxPNMHandler();
20977 wxPyEndAllowThreads(__tstate);
20978 if (PyErr_Occurred()) SWIG_fail;
20979 }
20980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20981 return resultobj;
20982 fail:
20983 return NULL;
20984 }
20985
20986
20987 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20988 PyObject *obj;
20989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20990 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20991 return SWIG_Py_Void();
20992 }
20993
20994 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20995 return SWIG_Python_InitShadowInstance(args);
20996 }
20997
20998 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20999 PyObject *resultobj = 0;
21000 wxXPMHandler *result = 0 ;
21001
21002 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
21003 {
21004 PyThreadState* __tstate = wxPyBeginAllowThreads();
21005 result = (wxXPMHandler *)new wxXPMHandler();
21006 wxPyEndAllowThreads(__tstate);
21007 if (PyErr_Occurred()) SWIG_fail;
21008 }
21009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21017 PyObject *obj;
21018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21019 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
21020 return SWIG_Py_Void();
21021 }
21022
21023 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21024 return SWIG_Python_InitShadowInstance(args);
21025 }
21026
21027 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21028 PyObject *resultobj = 0;
21029 wxTIFFHandler *result = 0 ;
21030
21031 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
21032 {
21033 PyThreadState* __tstate = wxPyBeginAllowThreads();
21034 result = (wxTIFFHandler *)new wxTIFFHandler();
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *obj;
21047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21048 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
21049 return SWIG_Py_Void();
21050 }
21051
21052 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21053 return SWIG_Python_InitShadowInstance(args);
21054 }
21055
21056 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21057 PyObject *resultobj = 0;
21058 wxTGAHandler *result = 0 ;
21059
21060 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 result = (wxTGAHandler *)new wxTGAHandler();
21064 wxPyEndAllowThreads(__tstate);
21065 if (PyErr_Occurred()) SWIG_fail;
21066 }
21067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
21068 return resultobj;
21069 fail:
21070 return NULL;
21071 }
21072
21073
21074 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21075 PyObject *obj;
21076 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21077 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
21078 return SWIG_Py_Void();
21079 }
21080
21081 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21082 return SWIG_Python_InitShadowInstance(args);
21083 }
21084
21085 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21086 PyObject *resultobj = 0;
21087 wxImage *arg1 = 0 ;
21088 wxImage *arg2 = 0 ;
21089 int arg3 = (int) 236 ;
21090 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
21091 bool result;
21092 void *argp1 = 0 ;
21093 int res1 = 0 ;
21094 void *argp2 = 0 ;
21095 int res2 = 0 ;
21096 int val3 ;
21097 int ecode3 = 0 ;
21098 int val4 ;
21099 int ecode4 = 0 ;
21100 PyObject * obj0 = 0 ;
21101 PyObject * obj1 = 0 ;
21102 PyObject * obj2 = 0 ;
21103 PyObject * obj3 = 0 ;
21104 char * kwnames[] = {
21105 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
21106 };
21107
21108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21109 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
21110 if (!SWIG_IsOK(res1)) {
21111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21112 }
21113 if (!argp1) {
21114 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
21115 }
21116 arg1 = reinterpret_cast< wxImage * >(argp1);
21117 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
21118 if (!SWIG_IsOK(res2)) {
21119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21120 }
21121 if (!argp2) {
21122 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
21123 }
21124 arg2 = reinterpret_cast< wxImage * >(argp2);
21125 if (obj2) {
21126 ecode3 = SWIG_AsVal_int(obj2, &val3);
21127 if (!SWIG_IsOK(ecode3)) {
21128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
21129 }
21130 arg3 = static_cast< int >(val3);
21131 }
21132 if (obj3) {
21133 ecode4 = SWIG_AsVal_int(obj3, &val4);
21134 if (!SWIG_IsOK(ecode4)) {
21135 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
21136 }
21137 arg4 = static_cast< int >(val4);
21138 }
21139 {
21140 PyThreadState* __tstate = wxPyBeginAllowThreads();
21141 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
21142 wxPyEndAllowThreads(__tstate);
21143 if (PyErr_Occurred()) SWIG_fail;
21144 }
21145 {
21146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21147 }
21148 return resultobj;
21149 fail:
21150 return NULL;
21151 }
21152
21153
21154 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21155 PyObject *obj;
21156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21157 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
21158 return SWIG_Py_Void();
21159 }
21160
21161 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21162 PyObject *resultobj = 0;
21163 wxEvtHandler *result = 0 ;
21164
21165 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
21166 {
21167 PyThreadState* __tstate = wxPyBeginAllowThreads();
21168 result = (wxEvtHandler *)new wxEvtHandler();
21169 wxPyEndAllowThreads(__tstate);
21170 if (PyErr_Occurred()) SWIG_fail;
21171 }
21172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
21173 return resultobj;
21174 fail:
21175 return NULL;
21176 }
21177
21178
21179 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21180 PyObject *resultobj = 0;
21181 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21182 wxEvtHandler *result = 0 ;
21183 void *argp1 = 0 ;
21184 int res1 = 0 ;
21185 PyObject *swig_obj[1] ;
21186
21187 if (!args) SWIG_fail;
21188 swig_obj[0] = args;
21189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21190 if (!SWIG_IsOK(res1)) {
21191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21192 }
21193 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21194 {
21195 PyThreadState* __tstate = wxPyBeginAllowThreads();
21196 result = (wxEvtHandler *)(arg1)->GetNextHandler();
21197 wxPyEndAllowThreads(__tstate);
21198 if (PyErr_Occurred()) SWIG_fail;
21199 }
21200 {
21201 resultobj = wxPyMake_wxObject(result, 0);
21202 }
21203 return resultobj;
21204 fail:
21205 return NULL;
21206 }
21207
21208
21209 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21210 PyObject *resultobj = 0;
21211 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21212 wxEvtHandler *result = 0 ;
21213 void *argp1 = 0 ;
21214 int res1 = 0 ;
21215 PyObject *swig_obj[1] ;
21216
21217 if (!args) SWIG_fail;
21218 swig_obj[0] = args;
21219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21220 if (!SWIG_IsOK(res1)) {
21221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21222 }
21223 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21224 {
21225 PyThreadState* __tstate = wxPyBeginAllowThreads();
21226 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
21227 wxPyEndAllowThreads(__tstate);
21228 if (PyErr_Occurred()) SWIG_fail;
21229 }
21230 {
21231 resultobj = wxPyMake_wxObject(result, 0);
21232 }
21233 return resultobj;
21234 fail:
21235 return NULL;
21236 }
21237
21238
21239 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21240 PyObject *resultobj = 0;
21241 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21242 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21243 void *argp1 = 0 ;
21244 int res1 = 0 ;
21245 void *argp2 = 0 ;
21246 int res2 = 0 ;
21247 PyObject * obj0 = 0 ;
21248 PyObject * obj1 = 0 ;
21249 char * kwnames[] = {
21250 (char *) "self",(char *) "handler", NULL
21251 };
21252
21253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21255 if (!SWIG_IsOK(res1)) {
21256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21257 }
21258 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21259 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21260 if (!SWIG_IsOK(res2)) {
21261 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21262 }
21263 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21264 {
21265 PyThreadState* __tstate = wxPyBeginAllowThreads();
21266 (arg1)->SetNextHandler(arg2);
21267 wxPyEndAllowThreads(__tstate);
21268 if (PyErr_Occurred()) SWIG_fail;
21269 }
21270 resultobj = SWIG_Py_Void();
21271 return resultobj;
21272 fail:
21273 return NULL;
21274 }
21275
21276
21277 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21278 PyObject *resultobj = 0;
21279 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21280 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
21281 void *argp1 = 0 ;
21282 int res1 = 0 ;
21283 void *argp2 = 0 ;
21284 int res2 = 0 ;
21285 PyObject * obj0 = 0 ;
21286 PyObject * obj1 = 0 ;
21287 char * kwnames[] = {
21288 (char *) "self",(char *) "handler", NULL
21289 };
21290
21291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
21292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21293 if (!SWIG_IsOK(res1)) {
21294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21295 }
21296 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21297 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21298 if (!SWIG_IsOK(res2)) {
21299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
21300 }
21301 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
21302 {
21303 PyThreadState* __tstate = wxPyBeginAllowThreads();
21304 (arg1)->SetPreviousHandler(arg2);
21305 wxPyEndAllowThreads(__tstate);
21306 if (PyErr_Occurred()) SWIG_fail;
21307 }
21308 resultobj = SWIG_Py_Void();
21309 return resultobj;
21310 fail:
21311 return NULL;
21312 }
21313
21314
21315 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21316 PyObject *resultobj = 0;
21317 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21318 bool result;
21319 void *argp1 = 0 ;
21320 int res1 = 0 ;
21321 PyObject *swig_obj[1] ;
21322
21323 if (!args) SWIG_fail;
21324 swig_obj[0] = args;
21325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21326 if (!SWIG_IsOK(res1)) {
21327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21328 }
21329 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21330 {
21331 PyThreadState* __tstate = wxPyBeginAllowThreads();
21332 result = (bool)(arg1)->GetEvtHandlerEnabled();
21333 wxPyEndAllowThreads(__tstate);
21334 if (PyErr_Occurred()) SWIG_fail;
21335 }
21336 {
21337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21338 }
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21346 PyObject *resultobj = 0;
21347 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21348 bool arg2 ;
21349 void *argp1 = 0 ;
21350 int res1 = 0 ;
21351 bool val2 ;
21352 int ecode2 = 0 ;
21353 PyObject * obj0 = 0 ;
21354 PyObject * obj1 = 0 ;
21355 char * kwnames[] = {
21356 (char *) "self",(char *) "enabled", NULL
21357 };
21358
21359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
21360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21361 if (!SWIG_IsOK(res1)) {
21362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21363 }
21364 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21365 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21366 if (!SWIG_IsOK(ecode2)) {
21367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
21368 }
21369 arg2 = static_cast< bool >(val2);
21370 {
21371 PyThreadState* __tstate = wxPyBeginAllowThreads();
21372 (arg1)->SetEvtHandlerEnabled(arg2);
21373 wxPyEndAllowThreads(__tstate);
21374 if (PyErr_Occurred()) SWIG_fail;
21375 }
21376 resultobj = SWIG_Py_Void();
21377 return resultobj;
21378 fail:
21379 return NULL;
21380 }
21381
21382
21383 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21384 PyObject *resultobj = 0;
21385 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21386 wxEvent *arg2 = 0 ;
21387 bool result;
21388 void *argp1 = 0 ;
21389 int res1 = 0 ;
21390 void *argp2 = 0 ;
21391 int res2 = 0 ;
21392 PyObject * obj0 = 0 ;
21393 PyObject * obj1 = 0 ;
21394 char * kwnames[] = {
21395 (char *) "self",(char *) "event", NULL
21396 };
21397
21398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21400 if (!SWIG_IsOK(res1)) {
21401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21402 }
21403 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21404 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21405 if (!SWIG_IsOK(res2)) {
21406 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21407 }
21408 if (!argp2) {
21409 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21410 }
21411 arg2 = reinterpret_cast< wxEvent * >(argp2);
21412 {
21413 PyThreadState* __tstate = wxPyBeginAllowThreads();
21414 result = (bool)(arg1)->ProcessEvent(*arg2);
21415 wxPyEndAllowThreads(__tstate);
21416 if (PyErr_Occurred()) SWIG_fail;
21417 }
21418 {
21419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21420 }
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21428 PyObject *resultobj = 0;
21429 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21430 wxEvent *arg2 = 0 ;
21431 void *argp1 = 0 ;
21432 int res1 = 0 ;
21433 void *argp2 = 0 ;
21434 int res2 = 0 ;
21435 PyObject * obj0 = 0 ;
21436 PyObject * obj1 = 0 ;
21437 char * kwnames[] = {
21438 (char *) "self",(char *) "event", NULL
21439 };
21440
21441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21443 if (!SWIG_IsOK(res1)) {
21444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21445 }
21446 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21447 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
21448 if (!SWIG_IsOK(res2)) {
21449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21450 }
21451 if (!argp2) {
21452 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
21453 }
21454 arg2 = reinterpret_cast< wxEvent * >(argp2);
21455 {
21456 PyThreadState* __tstate = wxPyBeginAllowThreads();
21457 (arg1)->AddPendingEvent(*arg2);
21458 wxPyEndAllowThreads(__tstate);
21459 if (PyErr_Occurred()) SWIG_fail;
21460 }
21461 resultobj = SWIG_Py_Void();
21462 return resultobj;
21463 fail:
21464 return NULL;
21465 }
21466
21467
21468 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21469 PyObject *resultobj = 0;
21470 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21471 void *argp1 = 0 ;
21472 int res1 = 0 ;
21473 PyObject *swig_obj[1] ;
21474
21475 if (!args) SWIG_fail;
21476 swig_obj[0] = args;
21477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21480 }
21481 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21482 {
21483 PyThreadState* __tstate = wxPyBeginAllowThreads();
21484 (arg1)->ProcessPendingEvents();
21485 wxPyEndAllowThreads(__tstate);
21486 if (PyErr_Occurred()) SWIG_fail;
21487 }
21488 resultobj = SWIG_Py_Void();
21489 return resultobj;
21490 fail:
21491 return NULL;
21492 }
21493
21494
21495 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21496 PyObject *resultobj = 0;
21497 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21498 int arg2 ;
21499 int arg3 ;
21500 int arg4 ;
21501 PyObject *arg5 = (PyObject *) 0 ;
21502 void *argp1 = 0 ;
21503 int res1 = 0 ;
21504 int val2 ;
21505 int ecode2 = 0 ;
21506 int val3 ;
21507 int ecode3 = 0 ;
21508 int val4 ;
21509 int ecode4 = 0 ;
21510 PyObject * obj0 = 0 ;
21511 PyObject * obj1 = 0 ;
21512 PyObject * obj2 = 0 ;
21513 PyObject * obj3 = 0 ;
21514 PyObject * obj4 = 0 ;
21515 char * kwnames[] = {
21516 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
21517 };
21518
21519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
21520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21521 if (!SWIG_IsOK(res1)) {
21522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21523 }
21524 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21525 ecode2 = SWIG_AsVal_int(obj1, &val2);
21526 if (!SWIG_IsOK(ecode2)) {
21527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21528 }
21529 arg2 = static_cast< int >(val2);
21530 ecode3 = SWIG_AsVal_int(obj2, &val3);
21531 if (!SWIG_IsOK(ecode3)) {
21532 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21533 }
21534 arg3 = static_cast< int >(val3);
21535 ecode4 = SWIG_AsVal_int(obj3, &val4);
21536 if (!SWIG_IsOK(ecode4)) {
21537 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21538 }
21539 arg4 = static_cast< int >(val4);
21540 arg5 = obj4;
21541 {
21542 PyThreadState* __tstate = wxPyBeginAllowThreads();
21543 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21544 wxPyEndAllowThreads(__tstate);
21545 if (PyErr_Occurred()) SWIG_fail;
21546 }
21547 resultobj = SWIG_Py_Void();
21548 return resultobj;
21549 fail:
21550 return NULL;
21551 }
21552
21553
21554 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21555 PyObject *resultobj = 0;
21556 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21557 int arg2 ;
21558 int arg3 = (int) -1 ;
21559 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21560 bool result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 int val2 ;
21564 int ecode2 = 0 ;
21565 int val3 ;
21566 int ecode3 = 0 ;
21567 int val4 ;
21568 int ecode4 = 0 ;
21569 PyObject * obj0 = 0 ;
21570 PyObject * obj1 = 0 ;
21571 PyObject * obj2 = 0 ;
21572 PyObject * obj3 = 0 ;
21573 char * kwnames[] = {
21574 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21575 };
21576
21577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21579 if (!SWIG_IsOK(res1)) {
21580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21581 }
21582 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21583 ecode2 = SWIG_AsVal_int(obj1, &val2);
21584 if (!SWIG_IsOK(ecode2)) {
21585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21586 }
21587 arg2 = static_cast< int >(val2);
21588 if (obj2) {
21589 ecode3 = SWIG_AsVal_int(obj2, &val3);
21590 if (!SWIG_IsOK(ecode3)) {
21591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21592 }
21593 arg3 = static_cast< int >(val3);
21594 }
21595 if (obj3) {
21596 ecode4 = SWIG_AsVal_int(obj3, &val4);
21597 if (!SWIG_IsOK(ecode4)) {
21598 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21599 }
21600 arg4 = static_cast< wxEventType >(val4);
21601 }
21602 {
21603 PyThreadState* __tstate = wxPyBeginAllowThreads();
21604 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21605 wxPyEndAllowThreads(__tstate);
21606 if (PyErr_Occurred()) SWIG_fail;
21607 }
21608 {
21609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21610 }
21611 return resultobj;
21612 fail:
21613 return NULL;
21614 }
21615
21616
21617 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21618 PyObject *resultobj = 0;
21619 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21620 PyObject *arg2 = (PyObject *) 0 ;
21621 bool arg3 = (bool) true ;
21622 void *argp1 = 0 ;
21623 int res1 = 0 ;
21624 bool val3 ;
21625 int ecode3 = 0 ;
21626 PyObject * obj0 = 0 ;
21627 PyObject * obj1 = 0 ;
21628 PyObject * obj2 = 0 ;
21629 char * kwnames[] = {
21630 (char *) "self",(char *) "_self",(char *) "incref", NULL
21631 };
21632
21633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21637 }
21638 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21639 arg2 = obj1;
21640 if (obj2) {
21641 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21642 if (!SWIG_IsOK(ecode3)) {
21643 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21644 }
21645 arg3 = static_cast< bool >(val3);
21646 }
21647 {
21648 PyThreadState* __tstate = wxPyBeginAllowThreads();
21649 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21650 wxPyEndAllowThreads(__tstate);
21651 if (PyErr_Occurred()) SWIG_fail;
21652 }
21653 resultobj = SWIG_Py_Void();
21654 return resultobj;
21655 fail:
21656 return NULL;
21657 }
21658
21659
21660 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21661 PyObject *obj;
21662 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21663 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21664 return SWIG_Py_Void();
21665 }
21666
21667 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21668 return SWIG_Python_InitShadowInstance(args);
21669 }
21670
21671 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21672 PyObject *resultobj = 0;
21673 wxEventType result;
21674
21675 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21676 {
21677 PyThreadState* __tstate = wxPyBeginAllowThreads();
21678 result = (wxEventType)wxNewEventType();
21679 wxPyEndAllowThreads(__tstate);
21680 if (PyErr_Occurred()) SWIG_fail;
21681 }
21682 resultobj = SWIG_From_int(static_cast< int >(result));
21683 return resultobj;
21684 fail:
21685 return NULL;
21686 }
21687
21688
21689 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21690 PyObject *resultobj = 0;
21691 wxEvent *arg1 = (wxEvent *) 0 ;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 PyObject *swig_obj[1] ;
21695
21696 if (!args) SWIG_fail;
21697 swig_obj[0] = args;
21698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21699 if (!SWIG_IsOK(res1)) {
21700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21701 }
21702 arg1 = reinterpret_cast< wxEvent * >(argp1);
21703 {
21704 PyThreadState* __tstate = wxPyBeginAllowThreads();
21705 delete arg1;
21706
21707 wxPyEndAllowThreads(__tstate);
21708 if (PyErr_Occurred()) SWIG_fail;
21709 }
21710 resultobj = SWIG_Py_Void();
21711 return resultobj;
21712 fail:
21713 return NULL;
21714 }
21715
21716
21717 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21718 PyObject *resultobj = 0;
21719 wxEvent *arg1 = (wxEvent *) 0 ;
21720 wxEventType arg2 ;
21721 void *argp1 = 0 ;
21722 int res1 = 0 ;
21723 int val2 ;
21724 int ecode2 = 0 ;
21725 PyObject * obj0 = 0 ;
21726 PyObject * obj1 = 0 ;
21727 char * kwnames[] = {
21728 (char *) "self",(char *) "typ", NULL
21729 };
21730
21731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21733 if (!SWIG_IsOK(res1)) {
21734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21735 }
21736 arg1 = reinterpret_cast< wxEvent * >(argp1);
21737 ecode2 = SWIG_AsVal_int(obj1, &val2);
21738 if (!SWIG_IsOK(ecode2)) {
21739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21740 }
21741 arg2 = static_cast< wxEventType >(val2);
21742 {
21743 PyThreadState* __tstate = wxPyBeginAllowThreads();
21744 (arg1)->SetEventType(arg2);
21745 wxPyEndAllowThreads(__tstate);
21746 if (PyErr_Occurred()) SWIG_fail;
21747 }
21748 resultobj = SWIG_Py_Void();
21749 return resultobj;
21750 fail:
21751 return NULL;
21752 }
21753
21754
21755 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21756 PyObject *resultobj = 0;
21757 wxEvent *arg1 = (wxEvent *) 0 ;
21758 wxEventType result;
21759 void *argp1 = 0 ;
21760 int res1 = 0 ;
21761 PyObject *swig_obj[1] ;
21762
21763 if (!args) SWIG_fail;
21764 swig_obj[0] = args;
21765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21766 if (!SWIG_IsOK(res1)) {
21767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21768 }
21769 arg1 = reinterpret_cast< wxEvent * >(argp1);
21770 {
21771 PyThreadState* __tstate = wxPyBeginAllowThreads();
21772 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21773 wxPyEndAllowThreads(__tstate);
21774 if (PyErr_Occurred()) SWIG_fail;
21775 }
21776 resultobj = SWIG_From_int(static_cast< int >(result));
21777 return resultobj;
21778 fail:
21779 return NULL;
21780 }
21781
21782
21783 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21784 PyObject *resultobj = 0;
21785 wxEvent *arg1 = (wxEvent *) 0 ;
21786 wxObject *result = 0 ;
21787 void *argp1 = 0 ;
21788 int res1 = 0 ;
21789 PyObject *swig_obj[1] ;
21790
21791 if (!args) SWIG_fail;
21792 swig_obj[0] = args;
21793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21794 if (!SWIG_IsOK(res1)) {
21795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21796 }
21797 arg1 = reinterpret_cast< wxEvent * >(argp1);
21798 {
21799 PyThreadState* __tstate = wxPyBeginAllowThreads();
21800 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 {
21805 resultobj = wxPyMake_wxObject(result, (bool)0);
21806 }
21807 return resultobj;
21808 fail:
21809 return NULL;
21810 }
21811
21812
21813 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21814 PyObject *resultobj = 0;
21815 wxEvent *arg1 = (wxEvent *) 0 ;
21816 wxObject *arg2 = (wxObject *) 0 ;
21817 void *argp1 = 0 ;
21818 int res1 = 0 ;
21819 void *argp2 = 0 ;
21820 int res2 = 0 ;
21821 PyObject * obj0 = 0 ;
21822 PyObject * obj1 = 0 ;
21823 char * kwnames[] = {
21824 (char *) "self",(char *) "obj", NULL
21825 };
21826
21827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21829 if (!SWIG_IsOK(res1)) {
21830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21831 }
21832 arg1 = reinterpret_cast< wxEvent * >(argp1);
21833 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21834 if (!SWIG_IsOK(res2)) {
21835 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21836 }
21837 arg2 = reinterpret_cast< wxObject * >(argp2);
21838 {
21839 PyThreadState* __tstate = wxPyBeginAllowThreads();
21840 (arg1)->SetEventObject(arg2);
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 resultobj = SWIG_Py_Void();
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21852 PyObject *resultobj = 0;
21853 wxEvent *arg1 = (wxEvent *) 0 ;
21854 long result;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 PyObject *swig_obj[1] ;
21858
21859 if (!args) SWIG_fail;
21860 swig_obj[0] = args;
21861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21862 if (!SWIG_IsOK(res1)) {
21863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21864 }
21865 arg1 = reinterpret_cast< wxEvent * >(argp1);
21866 {
21867 PyThreadState* __tstate = wxPyBeginAllowThreads();
21868 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21869 wxPyEndAllowThreads(__tstate);
21870 if (PyErr_Occurred()) SWIG_fail;
21871 }
21872 resultobj = SWIG_From_long(static_cast< long >(result));
21873 return resultobj;
21874 fail:
21875 return NULL;
21876 }
21877
21878
21879 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21880 PyObject *resultobj = 0;
21881 wxEvent *arg1 = (wxEvent *) 0 ;
21882 long arg2 = (long) 0 ;
21883 void *argp1 = 0 ;
21884 int res1 = 0 ;
21885 long val2 ;
21886 int ecode2 = 0 ;
21887 PyObject * obj0 = 0 ;
21888 PyObject * obj1 = 0 ;
21889 char * kwnames[] = {
21890 (char *) "self",(char *) "ts", NULL
21891 };
21892
21893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21895 if (!SWIG_IsOK(res1)) {
21896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21897 }
21898 arg1 = reinterpret_cast< wxEvent * >(argp1);
21899 if (obj1) {
21900 ecode2 = SWIG_AsVal_long(obj1, &val2);
21901 if (!SWIG_IsOK(ecode2)) {
21902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21903 }
21904 arg2 = static_cast< long >(val2);
21905 }
21906 {
21907 PyThreadState* __tstate = wxPyBeginAllowThreads();
21908 (arg1)->SetTimestamp(arg2);
21909 wxPyEndAllowThreads(__tstate);
21910 if (PyErr_Occurred()) SWIG_fail;
21911 }
21912 resultobj = SWIG_Py_Void();
21913 return resultobj;
21914 fail:
21915 return NULL;
21916 }
21917
21918
21919 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21920 PyObject *resultobj = 0;
21921 wxEvent *arg1 = (wxEvent *) 0 ;
21922 int result;
21923 void *argp1 = 0 ;
21924 int res1 = 0 ;
21925 PyObject *swig_obj[1] ;
21926
21927 if (!args) SWIG_fail;
21928 swig_obj[0] = args;
21929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21930 if (!SWIG_IsOK(res1)) {
21931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21932 }
21933 arg1 = reinterpret_cast< wxEvent * >(argp1);
21934 {
21935 PyThreadState* __tstate = wxPyBeginAllowThreads();
21936 result = (int)((wxEvent const *)arg1)->GetId();
21937 wxPyEndAllowThreads(__tstate);
21938 if (PyErr_Occurred()) SWIG_fail;
21939 }
21940 resultobj = SWIG_From_int(static_cast< int >(result));
21941 return resultobj;
21942 fail:
21943 return NULL;
21944 }
21945
21946
21947 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21948 PyObject *resultobj = 0;
21949 wxEvent *arg1 = (wxEvent *) 0 ;
21950 int arg2 ;
21951 void *argp1 = 0 ;
21952 int res1 = 0 ;
21953 int val2 ;
21954 int ecode2 = 0 ;
21955 PyObject * obj0 = 0 ;
21956 PyObject * obj1 = 0 ;
21957 char * kwnames[] = {
21958 (char *) "self",(char *) "Id", NULL
21959 };
21960
21961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21963 if (!SWIG_IsOK(res1)) {
21964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21965 }
21966 arg1 = reinterpret_cast< wxEvent * >(argp1);
21967 ecode2 = SWIG_AsVal_int(obj1, &val2);
21968 if (!SWIG_IsOK(ecode2)) {
21969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21970 }
21971 arg2 = static_cast< int >(val2);
21972 {
21973 PyThreadState* __tstate = wxPyBeginAllowThreads();
21974 (arg1)->SetId(arg2);
21975 wxPyEndAllowThreads(__tstate);
21976 if (PyErr_Occurred()) SWIG_fail;
21977 }
21978 resultobj = SWIG_Py_Void();
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21986 PyObject *resultobj = 0;
21987 wxEvent *arg1 = (wxEvent *) 0 ;
21988 bool result;
21989 void *argp1 = 0 ;
21990 int res1 = 0 ;
21991 PyObject *swig_obj[1] ;
21992
21993 if (!args) SWIG_fail;
21994 swig_obj[0] = args;
21995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21996 if (!SWIG_IsOK(res1)) {
21997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21998 }
21999 arg1 = reinterpret_cast< wxEvent * >(argp1);
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 {
22007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22008 }
22009 return resultobj;
22010 fail:
22011 return NULL;
22012 }
22013
22014
22015 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22016 PyObject *resultobj = 0;
22017 wxEvent *arg1 = (wxEvent *) 0 ;
22018 bool arg2 = (bool) true ;
22019 void *argp1 = 0 ;
22020 int res1 = 0 ;
22021 bool val2 ;
22022 int ecode2 = 0 ;
22023 PyObject * obj0 = 0 ;
22024 PyObject * obj1 = 0 ;
22025 char * kwnames[] = {
22026 (char *) "self",(char *) "skip", NULL
22027 };
22028
22029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
22030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22031 if (!SWIG_IsOK(res1)) {
22032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
22033 }
22034 arg1 = reinterpret_cast< wxEvent * >(argp1);
22035 if (obj1) {
22036 ecode2 = SWIG_AsVal_bool(obj1, &val2);
22037 if (!SWIG_IsOK(ecode2)) {
22038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
22039 }
22040 arg2 = static_cast< bool >(val2);
22041 }
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 (arg1)->Skip(arg2);
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 resultobj = SWIG_Py_Void();
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22056 PyObject *resultobj = 0;
22057 wxEvent *arg1 = (wxEvent *) 0 ;
22058 bool result;
22059 void *argp1 = 0 ;
22060 int res1 = 0 ;
22061 PyObject *swig_obj[1] ;
22062
22063 if (!args) SWIG_fail;
22064 swig_obj[0] = args;
22065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22066 if (!SWIG_IsOK(res1)) {
22067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
22068 }
22069 arg1 = reinterpret_cast< wxEvent * >(argp1);
22070 {
22071 PyThreadState* __tstate = wxPyBeginAllowThreads();
22072 result = (bool)((wxEvent const *)arg1)->GetSkipped();
22073 wxPyEndAllowThreads(__tstate);
22074 if (PyErr_Occurred()) SWIG_fail;
22075 }
22076 {
22077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22078 }
22079 return resultobj;
22080 fail:
22081 return NULL;
22082 }
22083
22084
22085 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22086 PyObject *resultobj = 0;
22087 wxEvent *arg1 = (wxEvent *) 0 ;
22088 bool result;
22089 void *argp1 = 0 ;
22090 int res1 = 0 ;
22091 PyObject *swig_obj[1] ;
22092
22093 if (!args) SWIG_fail;
22094 swig_obj[0] = args;
22095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22096 if (!SWIG_IsOK(res1)) {
22097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
22098 }
22099 arg1 = reinterpret_cast< wxEvent * >(argp1);
22100 {
22101 PyThreadState* __tstate = wxPyBeginAllowThreads();
22102 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
22103 wxPyEndAllowThreads(__tstate);
22104 if (PyErr_Occurred()) SWIG_fail;
22105 }
22106 {
22107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22108 }
22109 return resultobj;
22110 fail:
22111 return NULL;
22112 }
22113
22114
22115 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22116 PyObject *resultobj = 0;
22117 wxEvent *arg1 = (wxEvent *) 0 ;
22118 int result;
22119 void *argp1 = 0 ;
22120 int res1 = 0 ;
22121 PyObject *swig_obj[1] ;
22122
22123 if (!args) SWIG_fail;
22124 swig_obj[0] = args;
22125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22126 if (!SWIG_IsOK(res1)) {
22127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22128 }
22129 arg1 = reinterpret_cast< wxEvent * >(argp1);
22130 {
22131 PyThreadState* __tstate = wxPyBeginAllowThreads();
22132 result = (int)(arg1)->StopPropagation();
22133 wxPyEndAllowThreads(__tstate);
22134 if (PyErr_Occurred()) SWIG_fail;
22135 }
22136 resultobj = SWIG_From_int(static_cast< int >(result));
22137 return resultobj;
22138 fail:
22139 return NULL;
22140 }
22141
22142
22143 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22144 PyObject *resultobj = 0;
22145 wxEvent *arg1 = (wxEvent *) 0 ;
22146 int arg2 ;
22147 void *argp1 = 0 ;
22148 int res1 = 0 ;
22149 int val2 ;
22150 int ecode2 = 0 ;
22151 PyObject * obj0 = 0 ;
22152 PyObject * obj1 = 0 ;
22153 char * kwnames[] = {
22154 (char *) "self",(char *) "propagationLevel", NULL
22155 };
22156
22157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
22158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22159 if (!SWIG_IsOK(res1)) {
22160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
22161 }
22162 arg1 = reinterpret_cast< wxEvent * >(argp1);
22163 ecode2 = SWIG_AsVal_int(obj1, &val2);
22164 if (!SWIG_IsOK(ecode2)) {
22165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
22166 }
22167 arg2 = static_cast< int >(val2);
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 (arg1)->ResumePropagation(arg2);
22171 wxPyEndAllowThreads(__tstate);
22172 if (PyErr_Occurred()) SWIG_fail;
22173 }
22174 resultobj = SWIG_Py_Void();
22175 return resultobj;
22176 fail:
22177 return NULL;
22178 }
22179
22180
22181 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22182 PyObject *resultobj = 0;
22183 wxEvent *arg1 = (wxEvent *) 0 ;
22184 wxEvent *result = 0 ;
22185 void *argp1 = 0 ;
22186 int res1 = 0 ;
22187 PyObject *swig_obj[1] ;
22188
22189 if (!args) SWIG_fail;
22190 swig_obj[0] = args;
22191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
22192 if (!SWIG_IsOK(res1)) {
22193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
22194 }
22195 arg1 = reinterpret_cast< wxEvent * >(argp1);
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (wxEvent *)(arg1)->Clone();
22199 wxPyEndAllowThreads(__tstate);
22200 if (PyErr_Occurred()) SWIG_fail;
22201 }
22202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22203 return resultobj;
22204 fail:
22205 return NULL;
22206 }
22207
22208
22209 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22210 PyObject *obj;
22211 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22212 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
22213 return SWIG_Py_Void();
22214 }
22215
22216 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22217 PyObject *resultobj = 0;
22218 wxEvent *arg1 = 0 ;
22219 wxPropagationDisabler *result = 0 ;
22220 void *argp1 = 0 ;
22221 int res1 = 0 ;
22222 PyObject * obj0 = 0 ;
22223 char * kwnames[] = {
22224 (char *) "event", NULL
22225 };
22226
22227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
22228 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22229 if (!SWIG_IsOK(res1)) {
22230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22231 }
22232 if (!argp1) {
22233 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
22234 }
22235 arg1 = reinterpret_cast< wxEvent * >(argp1);
22236 {
22237 PyThreadState* __tstate = wxPyBeginAllowThreads();
22238 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
22239 wxPyEndAllowThreads(__tstate);
22240 if (PyErr_Occurred()) SWIG_fail;
22241 }
22242 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
22243 return resultobj;
22244 fail:
22245 return NULL;
22246 }
22247
22248
22249 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22250 PyObject *resultobj = 0;
22251 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
22252 void *argp1 = 0 ;
22253 int res1 = 0 ;
22254 PyObject *swig_obj[1] ;
22255
22256 if (!args) SWIG_fail;
22257 swig_obj[0] = args;
22258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
22259 if (!SWIG_IsOK(res1)) {
22260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
22261 }
22262 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
22263 {
22264 PyThreadState* __tstate = wxPyBeginAllowThreads();
22265 delete arg1;
22266
22267 wxPyEndAllowThreads(__tstate);
22268 if (PyErr_Occurred()) SWIG_fail;
22269 }
22270 resultobj = SWIG_Py_Void();
22271 return resultobj;
22272 fail:
22273 return NULL;
22274 }
22275
22276
22277 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22278 PyObject *obj;
22279 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22280 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
22281 return SWIG_Py_Void();
22282 }
22283
22284 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22285 return SWIG_Python_InitShadowInstance(args);
22286 }
22287
22288 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22289 PyObject *resultobj = 0;
22290 wxEvent *arg1 = 0 ;
22291 wxPropagateOnce *result = 0 ;
22292 void *argp1 = 0 ;
22293 int res1 = 0 ;
22294 PyObject * obj0 = 0 ;
22295 char * kwnames[] = {
22296 (char *) "event", NULL
22297 };
22298
22299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
22300 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
22301 if (!SWIG_IsOK(res1)) {
22302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22303 }
22304 if (!argp1) {
22305 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
22306 }
22307 arg1 = reinterpret_cast< wxEvent * >(argp1);
22308 {
22309 PyThreadState* __tstate = wxPyBeginAllowThreads();
22310 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
22311 wxPyEndAllowThreads(__tstate);
22312 if (PyErr_Occurred()) SWIG_fail;
22313 }
22314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
22315 return resultobj;
22316 fail:
22317 return NULL;
22318 }
22319
22320
22321 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22322 PyObject *resultobj = 0;
22323 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
22324 void *argp1 = 0 ;
22325 int res1 = 0 ;
22326 PyObject *swig_obj[1] ;
22327
22328 if (!args) SWIG_fail;
22329 swig_obj[0] = args;
22330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
22331 if (!SWIG_IsOK(res1)) {
22332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
22333 }
22334 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
22335 {
22336 PyThreadState* __tstate = wxPyBeginAllowThreads();
22337 delete arg1;
22338
22339 wxPyEndAllowThreads(__tstate);
22340 if (PyErr_Occurred()) SWIG_fail;
22341 }
22342 resultobj = SWIG_Py_Void();
22343 return resultobj;
22344 fail:
22345 return NULL;
22346 }
22347
22348
22349 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22350 PyObject *obj;
22351 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22352 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
22353 return SWIG_Py_Void();
22354 }
22355
22356 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22357 return SWIG_Python_InitShadowInstance(args);
22358 }
22359
22360 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22361 PyObject *resultobj = 0;
22362 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22363 int arg2 = (int) 0 ;
22364 wxCommandEvent *result = 0 ;
22365 int val1 ;
22366 int ecode1 = 0 ;
22367 int val2 ;
22368 int ecode2 = 0 ;
22369 PyObject * obj0 = 0 ;
22370 PyObject * obj1 = 0 ;
22371 char * kwnames[] = {
22372 (char *) "commandType",(char *) "winid", NULL
22373 };
22374
22375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22376 if (obj0) {
22377 ecode1 = SWIG_AsVal_int(obj0, &val1);
22378 if (!SWIG_IsOK(ecode1)) {
22379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22380 }
22381 arg1 = static_cast< wxEventType >(val1);
22382 }
22383 if (obj1) {
22384 ecode2 = SWIG_AsVal_int(obj1, &val2);
22385 if (!SWIG_IsOK(ecode2)) {
22386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
22387 }
22388 arg2 = static_cast< int >(val2);
22389 }
22390 {
22391 PyThreadState* __tstate = wxPyBeginAllowThreads();
22392 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
22393 wxPyEndAllowThreads(__tstate);
22394 if (PyErr_Occurred()) SWIG_fail;
22395 }
22396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
22397 return resultobj;
22398 fail:
22399 return NULL;
22400 }
22401
22402
22403 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22404 PyObject *resultobj = 0;
22405 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22406 int result;
22407 void *argp1 = 0 ;
22408 int res1 = 0 ;
22409 PyObject *swig_obj[1] ;
22410
22411 if (!args) SWIG_fail;
22412 swig_obj[0] = args;
22413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22414 if (!SWIG_IsOK(res1)) {
22415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22416 }
22417 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
22421 wxPyEndAllowThreads(__tstate);
22422 if (PyErr_Occurred()) SWIG_fail;
22423 }
22424 resultobj = SWIG_From_int(static_cast< int >(result));
22425 return resultobj;
22426 fail:
22427 return NULL;
22428 }
22429
22430
22431 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22432 PyObject *resultobj = 0;
22433 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22434 wxString *arg2 = 0 ;
22435 void *argp1 = 0 ;
22436 int res1 = 0 ;
22437 bool temp2 = false ;
22438 PyObject * obj0 = 0 ;
22439 PyObject * obj1 = 0 ;
22440 char * kwnames[] = {
22441 (char *) "self",(char *) "s", NULL
22442 };
22443
22444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
22445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22446 if (!SWIG_IsOK(res1)) {
22447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22448 }
22449 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22450 {
22451 arg2 = wxString_in_helper(obj1);
22452 if (arg2 == NULL) SWIG_fail;
22453 temp2 = true;
22454 }
22455 {
22456 PyThreadState* __tstate = wxPyBeginAllowThreads();
22457 (arg1)->SetString((wxString const &)*arg2);
22458 wxPyEndAllowThreads(__tstate);
22459 if (PyErr_Occurred()) SWIG_fail;
22460 }
22461 resultobj = SWIG_Py_Void();
22462 {
22463 if (temp2)
22464 delete arg2;
22465 }
22466 return resultobj;
22467 fail:
22468 {
22469 if (temp2)
22470 delete arg2;
22471 }
22472 return NULL;
22473 }
22474
22475
22476 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22477 PyObject *resultobj = 0;
22478 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22479 wxString result;
22480 void *argp1 = 0 ;
22481 int res1 = 0 ;
22482 PyObject *swig_obj[1] ;
22483
22484 if (!args) SWIG_fail;
22485 swig_obj[0] = args;
22486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22487 if (!SWIG_IsOK(res1)) {
22488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22489 }
22490 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22491 {
22492 PyThreadState* __tstate = wxPyBeginAllowThreads();
22493 result = ((wxCommandEvent const *)arg1)->GetString();
22494 wxPyEndAllowThreads(__tstate);
22495 if (PyErr_Occurred()) SWIG_fail;
22496 }
22497 {
22498 #if wxUSE_UNICODE
22499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22500 #else
22501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22502 #endif
22503 }
22504 return resultobj;
22505 fail:
22506 return NULL;
22507 }
22508
22509
22510 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22511 PyObject *resultobj = 0;
22512 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22513 bool result;
22514 void *argp1 = 0 ;
22515 int res1 = 0 ;
22516 PyObject *swig_obj[1] ;
22517
22518 if (!args) SWIG_fail;
22519 swig_obj[0] = args;
22520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22521 if (!SWIG_IsOK(res1)) {
22522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22523 }
22524 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22525 {
22526 PyThreadState* __tstate = wxPyBeginAllowThreads();
22527 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22528 wxPyEndAllowThreads(__tstate);
22529 if (PyErr_Occurred()) SWIG_fail;
22530 }
22531 {
22532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22533 }
22534 return resultobj;
22535 fail:
22536 return NULL;
22537 }
22538
22539
22540 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22541 PyObject *resultobj = 0;
22542 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22543 bool result;
22544 void *argp1 = 0 ;
22545 int res1 = 0 ;
22546 PyObject *swig_obj[1] ;
22547
22548 if (!args) SWIG_fail;
22549 swig_obj[0] = args;
22550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22551 if (!SWIG_IsOK(res1)) {
22552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22553 }
22554 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 {
22562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22563 }
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj = 0;
22572 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22573 long arg2 ;
22574 void *argp1 = 0 ;
22575 int res1 = 0 ;
22576 long val2 ;
22577 int ecode2 = 0 ;
22578 PyObject * obj0 = 0 ;
22579 PyObject * obj1 = 0 ;
22580 char * kwnames[] = {
22581 (char *) "self",(char *) "extraLong", NULL
22582 };
22583
22584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22586 if (!SWIG_IsOK(res1)) {
22587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22588 }
22589 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22590 ecode2 = SWIG_AsVal_long(obj1, &val2);
22591 if (!SWIG_IsOK(ecode2)) {
22592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22593 }
22594 arg2 = static_cast< long >(val2);
22595 {
22596 PyThreadState* __tstate = wxPyBeginAllowThreads();
22597 (arg1)->SetExtraLong(arg2);
22598 wxPyEndAllowThreads(__tstate);
22599 if (PyErr_Occurred()) SWIG_fail;
22600 }
22601 resultobj = SWIG_Py_Void();
22602 return resultobj;
22603 fail:
22604 return NULL;
22605 }
22606
22607
22608 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22609 PyObject *resultobj = 0;
22610 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22611 long result;
22612 void *argp1 = 0 ;
22613 int res1 = 0 ;
22614 PyObject *swig_obj[1] ;
22615
22616 if (!args) SWIG_fail;
22617 swig_obj[0] = args;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22621 }
22622 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22623 {
22624 PyThreadState* __tstate = wxPyBeginAllowThreads();
22625 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22626 wxPyEndAllowThreads(__tstate);
22627 if (PyErr_Occurred()) SWIG_fail;
22628 }
22629 resultobj = SWIG_From_long(static_cast< long >(result));
22630 return resultobj;
22631 fail:
22632 return NULL;
22633 }
22634
22635
22636 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22637 PyObject *resultobj = 0;
22638 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22639 int arg2 ;
22640 void *argp1 = 0 ;
22641 int res1 = 0 ;
22642 int val2 ;
22643 int ecode2 = 0 ;
22644 PyObject * obj0 = 0 ;
22645 PyObject * obj1 = 0 ;
22646 char * kwnames[] = {
22647 (char *) "self",(char *) "i", NULL
22648 };
22649
22650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22652 if (!SWIG_IsOK(res1)) {
22653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22654 }
22655 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22656 ecode2 = SWIG_AsVal_int(obj1, &val2);
22657 if (!SWIG_IsOK(ecode2)) {
22658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22659 }
22660 arg2 = static_cast< int >(val2);
22661 {
22662 PyThreadState* __tstate = wxPyBeginAllowThreads();
22663 (arg1)->SetInt(arg2);
22664 wxPyEndAllowThreads(__tstate);
22665 if (PyErr_Occurred()) SWIG_fail;
22666 }
22667 resultobj = SWIG_Py_Void();
22668 return resultobj;
22669 fail:
22670 return NULL;
22671 }
22672
22673
22674 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22675 PyObject *resultobj = 0;
22676 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22677 int result;
22678 void *argp1 = 0 ;
22679 int res1 = 0 ;
22680 PyObject *swig_obj[1] ;
22681
22682 if (!args) SWIG_fail;
22683 swig_obj[0] = args;
22684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22685 if (!SWIG_IsOK(res1)) {
22686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22687 }
22688 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22689 {
22690 PyThreadState* __tstate = wxPyBeginAllowThreads();
22691 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22692 wxPyEndAllowThreads(__tstate);
22693 if (PyErr_Occurred()) SWIG_fail;
22694 }
22695 resultobj = SWIG_From_int(static_cast< int >(result));
22696 return resultobj;
22697 fail:
22698 return NULL;
22699 }
22700
22701
22702 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22703 PyObject *resultobj = 0;
22704 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22705 PyObject *result = 0 ;
22706 void *argp1 = 0 ;
22707 int res1 = 0 ;
22708 PyObject *swig_obj[1] ;
22709
22710 if (!args) SWIG_fail;
22711 swig_obj[0] = args;
22712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22713 if (!SWIG_IsOK(res1)) {
22714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22715 }
22716 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22717 {
22718 PyThreadState* __tstate = wxPyBeginAllowThreads();
22719 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22720 wxPyEndAllowThreads(__tstate);
22721 if (PyErr_Occurred()) SWIG_fail;
22722 }
22723 resultobj = result;
22724 return resultobj;
22725 fail:
22726 return NULL;
22727 }
22728
22729
22730 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22731 PyObject *resultobj = 0;
22732 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22733 PyObject *arg2 = (PyObject *) 0 ;
22734 void *argp1 = 0 ;
22735 int res1 = 0 ;
22736 PyObject * obj0 = 0 ;
22737 PyObject * obj1 = 0 ;
22738 char * kwnames[] = {
22739 (char *) "self",(char *) "clientData", NULL
22740 };
22741
22742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22744 if (!SWIG_IsOK(res1)) {
22745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22746 }
22747 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22748 arg2 = obj1;
22749 {
22750 PyThreadState* __tstate = wxPyBeginAllowThreads();
22751 wxCommandEvent_SetClientData(arg1,arg2);
22752 wxPyEndAllowThreads(__tstate);
22753 if (PyErr_Occurred()) SWIG_fail;
22754 }
22755 resultobj = SWIG_Py_Void();
22756 return resultobj;
22757 fail:
22758 return NULL;
22759 }
22760
22761
22762 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22763 PyObject *resultobj = 0;
22764 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22765 wxEvent *result = 0 ;
22766 void *argp1 = 0 ;
22767 int res1 = 0 ;
22768 PyObject *swig_obj[1] ;
22769
22770 if (!args) SWIG_fail;
22771 swig_obj[0] = args;
22772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22773 if (!SWIG_IsOK(res1)) {
22774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22775 }
22776 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22777 {
22778 PyThreadState* __tstate = wxPyBeginAllowThreads();
22779 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22780 wxPyEndAllowThreads(__tstate);
22781 if (PyErr_Occurred()) SWIG_fail;
22782 }
22783 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22784 return resultobj;
22785 fail:
22786 return NULL;
22787 }
22788
22789
22790 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22791 PyObject *obj;
22792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22793 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22794 return SWIG_Py_Void();
22795 }
22796
22797 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22798 return SWIG_Python_InitShadowInstance(args);
22799 }
22800
22801 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22802 PyObject *resultobj = 0;
22803 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22804 int arg2 = (int) 0 ;
22805 wxNotifyEvent *result = 0 ;
22806 int val1 ;
22807 int ecode1 = 0 ;
22808 int val2 ;
22809 int ecode2 = 0 ;
22810 PyObject * obj0 = 0 ;
22811 PyObject * obj1 = 0 ;
22812 char * kwnames[] = {
22813 (char *) "commandType",(char *) "winid", NULL
22814 };
22815
22816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22817 if (obj0) {
22818 ecode1 = SWIG_AsVal_int(obj0, &val1);
22819 if (!SWIG_IsOK(ecode1)) {
22820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22821 }
22822 arg1 = static_cast< wxEventType >(val1);
22823 }
22824 if (obj1) {
22825 ecode2 = SWIG_AsVal_int(obj1, &val2);
22826 if (!SWIG_IsOK(ecode2)) {
22827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22828 }
22829 arg2 = static_cast< int >(val2);
22830 }
22831 {
22832 PyThreadState* __tstate = wxPyBeginAllowThreads();
22833 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22834 wxPyEndAllowThreads(__tstate);
22835 if (PyErr_Occurred()) SWIG_fail;
22836 }
22837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22838 return resultobj;
22839 fail:
22840 return NULL;
22841 }
22842
22843
22844 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22845 PyObject *resultobj = 0;
22846 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22847 void *argp1 = 0 ;
22848 int res1 = 0 ;
22849 PyObject *swig_obj[1] ;
22850
22851 if (!args) SWIG_fail;
22852 swig_obj[0] = args;
22853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22854 if (!SWIG_IsOK(res1)) {
22855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22856 }
22857 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22858 {
22859 PyThreadState* __tstate = wxPyBeginAllowThreads();
22860 (arg1)->Veto();
22861 wxPyEndAllowThreads(__tstate);
22862 if (PyErr_Occurred()) SWIG_fail;
22863 }
22864 resultobj = SWIG_Py_Void();
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22872 PyObject *resultobj = 0;
22873 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22874 void *argp1 = 0 ;
22875 int res1 = 0 ;
22876 PyObject *swig_obj[1] ;
22877
22878 if (!args) SWIG_fail;
22879 swig_obj[0] = args;
22880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22881 if (!SWIG_IsOK(res1)) {
22882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22883 }
22884 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22885 {
22886 PyThreadState* __tstate = wxPyBeginAllowThreads();
22887 (arg1)->Allow();
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 resultobj = SWIG_Py_Void();
22892 return resultobj;
22893 fail:
22894 return NULL;
22895 }
22896
22897
22898 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22899 PyObject *resultobj = 0;
22900 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22901 bool result;
22902 void *argp1 = 0 ;
22903 int res1 = 0 ;
22904 PyObject *swig_obj[1] ;
22905
22906 if (!args) SWIG_fail;
22907 swig_obj[0] = args;
22908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22909 if (!SWIG_IsOK(res1)) {
22910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22911 }
22912 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22913 {
22914 PyThreadState* __tstate = wxPyBeginAllowThreads();
22915 result = (bool)(arg1)->IsAllowed();
22916 wxPyEndAllowThreads(__tstate);
22917 if (PyErr_Occurred()) SWIG_fail;
22918 }
22919 {
22920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22921 }
22922 return resultobj;
22923 fail:
22924 return NULL;
22925 }
22926
22927
22928 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22929 PyObject *obj;
22930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22931 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22932 return SWIG_Py_Void();
22933 }
22934
22935 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22936 return SWIG_Python_InitShadowInstance(args);
22937 }
22938
22939 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22940 PyObject *resultobj = 0;
22941 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22942 int arg2 = (int) 0 ;
22943 int arg3 = (int) 0 ;
22944 int arg4 = (int) 0 ;
22945 wxScrollEvent *result = 0 ;
22946 int val1 ;
22947 int ecode1 = 0 ;
22948 int val2 ;
22949 int ecode2 = 0 ;
22950 int val3 ;
22951 int ecode3 = 0 ;
22952 int val4 ;
22953 int ecode4 = 0 ;
22954 PyObject * obj0 = 0 ;
22955 PyObject * obj1 = 0 ;
22956 PyObject * obj2 = 0 ;
22957 PyObject * obj3 = 0 ;
22958 char * kwnames[] = {
22959 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22960 };
22961
22962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22963 if (obj0) {
22964 ecode1 = SWIG_AsVal_int(obj0, &val1);
22965 if (!SWIG_IsOK(ecode1)) {
22966 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22967 }
22968 arg1 = static_cast< wxEventType >(val1);
22969 }
22970 if (obj1) {
22971 ecode2 = SWIG_AsVal_int(obj1, &val2);
22972 if (!SWIG_IsOK(ecode2)) {
22973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22974 }
22975 arg2 = static_cast< int >(val2);
22976 }
22977 if (obj2) {
22978 ecode3 = SWIG_AsVal_int(obj2, &val3);
22979 if (!SWIG_IsOK(ecode3)) {
22980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22981 }
22982 arg3 = static_cast< int >(val3);
22983 }
22984 if (obj3) {
22985 ecode4 = SWIG_AsVal_int(obj3, &val4);
22986 if (!SWIG_IsOK(ecode4)) {
22987 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22988 }
22989 arg4 = static_cast< int >(val4);
22990 }
22991 {
22992 PyThreadState* __tstate = wxPyBeginAllowThreads();
22993 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22998 return resultobj;
22999 fail:
23000 return NULL;
23001 }
23002
23003
23004 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23005 PyObject *resultobj = 0;
23006 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23007 int result;
23008 void *argp1 = 0 ;
23009 int res1 = 0 ;
23010 PyObject *swig_obj[1] ;
23011
23012 if (!args) SWIG_fail;
23013 swig_obj[0] = args;
23014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23015 if (!SWIG_IsOK(res1)) {
23016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23017 }
23018 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23019 {
23020 PyThreadState* __tstate = wxPyBeginAllowThreads();
23021 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
23022 wxPyEndAllowThreads(__tstate);
23023 if (PyErr_Occurred()) SWIG_fail;
23024 }
23025 resultobj = SWIG_From_int(static_cast< int >(result));
23026 return resultobj;
23027 fail:
23028 return NULL;
23029 }
23030
23031
23032 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23033 PyObject *resultobj = 0;
23034 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23035 int result;
23036 void *argp1 = 0 ;
23037 int res1 = 0 ;
23038 PyObject *swig_obj[1] ;
23039
23040 if (!args) SWIG_fail;
23041 swig_obj[0] = args;
23042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23043 if (!SWIG_IsOK(res1)) {
23044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
23045 }
23046 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23047 {
23048 PyThreadState* __tstate = wxPyBeginAllowThreads();
23049 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
23050 wxPyEndAllowThreads(__tstate);
23051 if (PyErr_Occurred()) SWIG_fail;
23052 }
23053 resultobj = SWIG_From_int(static_cast< int >(result));
23054 return resultobj;
23055 fail:
23056 return NULL;
23057 }
23058
23059
23060 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23061 PyObject *resultobj = 0;
23062 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23063 int arg2 ;
23064 void *argp1 = 0 ;
23065 int res1 = 0 ;
23066 int val2 ;
23067 int ecode2 = 0 ;
23068 PyObject * obj0 = 0 ;
23069 PyObject * obj1 = 0 ;
23070 char * kwnames[] = {
23071 (char *) "self",(char *) "orient", NULL
23072 };
23073
23074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23076 if (!SWIG_IsOK(res1)) {
23077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23078 }
23079 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23080 ecode2 = SWIG_AsVal_int(obj1, &val2);
23081 if (!SWIG_IsOK(ecode2)) {
23082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23083 }
23084 arg2 = static_cast< int >(val2);
23085 {
23086 PyThreadState* __tstate = wxPyBeginAllowThreads();
23087 (arg1)->SetOrientation(arg2);
23088 wxPyEndAllowThreads(__tstate);
23089 if (PyErr_Occurred()) SWIG_fail;
23090 }
23091 resultobj = SWIG_Py_Void();
23092 return resultobj;
23093 fail:
23094 return NULL;
23095 }
23096
23097
23098 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23099 PyObject *resultobj = 0;
23100 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
23101 int arg2 ;
23102 void *argp1 = 0 ;
23103 int res1 = 0 ;
23104 int val2 ;
23105 int ecode2 = 0 ;
23106 PyObject * obj0 = 0 ;
23107 PyObject * obj1 = 0 ;
23108 char * kwnames[] = {
23109 (char *) "self",(char *) "pos", NULL
23110 };
23111
23112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
23114 if (!SWIG_IsOK(res1)) {
23115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
23116 }
23117 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
23118 ecode2 = SWIG_AsVal_int(obj1, &val2);
23119 if (!SWIG_IsOK(ecode2)) {
23120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23121 }
23122 arg2 = static_cast< int >(val2);
23123 {
23124 PyThreadState* __tstate = wxPyBeginAllowThreads();
23125 (arg1)->SetPosition(arg2);
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 resultobj = SWIG_Py_Void();
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23137 PyObject *obj;
23138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23139 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
23140 return SWIG_Py_Void();
23141 }
23142
23143 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23144 return SWIG_Python_InitShadowInstance(args);
23145 }
23146
23147 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23148 PyObject *resultobj = 0;
23149 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23150 int arg2 = (int) 0 ;
23151 int arg3 = (int) 0 ;
23152 wxScrollWinEvent *result = 0 ;
23153 int val1 ;
23154 int ecode1 = 0 ;
23155 int val2 ;
23156 int ecode2 = 0 ;
23157 int val3 ;
23158 int ecode3 = 0 ;
23159 PyObject * obj0 = 0 ;
23160 PyObject * obj1 = 0 ;
23161 PyObject * obj2 = 0 ;
23162 char * kwnames[] = {
23163 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
23164 };
23165
23166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23167 if (obj0) {
23168 ecode1 = SWIG_AsVal_int(obj0, &val1);
23169 if (!SWIG_IsOK(ecode1)) {
23170 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23171 }
23172 arg1 = static_cast< wxEventType >(val1);
23173 }
23174 if (obj1) {
23175 ecode2 = SWIG_AsVal_int(obj1, &val2);
23176 if (!SWIG_IsOK(ecode2)) {
23177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
23178 }
23179 arg2 = static_cast< int >(val2);
23180 }
23181 if (obj2) {
23182 ecode3 = SWIG_AsVal_int(obj2, &val3);
23183 if (!SWIG_IsOK(ecode3)) {
23184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
23185 }
23186 arg3 = static_cast< int >(val3);
23187 }
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
23191 wxPyEndAllowThreads(__tstate);
23192 if (PyErr_Occurred()) SWIG_fail;
23193 }
23194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23202 PyObject *resultobj = 0;
23203 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23204 int result;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 PyObject *swig_obj[1] ;
23208
23209 if (!args) SWIG_fail;
23210 swig_obj[0] = args;
23211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23212 if (!SWIG_IsOK(res1)) {
23213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23214 }
23215 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 resultobj = SWIG_From_int(static_cast< int >(result));
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23230 PyObject *resultobj = 0;
23231 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23232 int result;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 PyObject *swig_obj[1] ;
23236
23237 if (!args) SWIG_fail;
23238 swig_obj[0] = args;
23239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23240 if (!SWIG_IsOK(res1)) {
23241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
23242 }
23243 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23244 {
23245 PyThreadState* __tstate = wxPyBeginAllowThreads();
23246 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
23247 wxPyEndAllowThreads(__tstate);
23248 if (PyErr_Occurred()) SWIG_fail;
23249 }
23250 resultobj = SWIG_From_int(static_cast< int >(result));
23251 return resultobj;
23252 fail:
23253 return NULL;
23254 }
23255
23256
23257 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23258 PyObject *resultobj = 0;
23259 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23260 int arg2 ;
23261 void *argp1 = 0 ;
23262 int res1 = 0 ;
23263 int val2 ;
23264 int ecode2 = 0 ;
23265 PyObject * obj0 = 0 ;
23266 PyObject * obj1 = 0 ;
23267 char * kwnames[] = {
23268 (char *) "self",(char *) "orient", NULL
23269 };
23270
23271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
23272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23273 if (!SWIG_IsOK(res1)) {
23274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23275 }
23276 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23277 ecode2 = SWIG_AsVal_int(obj1, &val2);
23278 if (!SWIG_IsOK(ecode2)) {
23279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
23280 }
23281 arg2 = static_cast< int >(val2);
23282 {
23283 PyThreadState* __tstate = wxPyBeginAllowThreads();
23284 (arg1)->SetOrientation(arg2);
23285 wxPyEndAllowThreads(__tstate);
23286 if (PyErr_Occurred()) SWIG_fail;
23287 }
23288 resultobj = SWIG_Py_Void();
23289 return resultobj;
23290 fail:
23291 return NULL;
23292 }
23293
23294
23295 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23296 PyObject *resultobj = 0;
23297 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
23298 int arg2 ;
23299 void *argp1 = 0 ;
23300 int res1 = 0 ;
23301 int val2 ;
23302 int ecode2 = 0 ;
23303 PyObject * obj0 = 0 ;
23304 PyObject * obj1 = 0 ;
23305 char * kwnames[] = {
23306 (char *) "self",(char *) "pos", NULL
23307 };
23308
23309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23310 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
23311 if (!SWIG_IsOK(res1)) {
23312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
23313 }
23314 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
23315 ecode2 = SWIG_AsVal_int(obj1, &val2);
23316 if (!SWIG_IsOK(ecode2)) {
23317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
23318 }
23319 arg2 = static_cast< int >(val2);
23320 {
23321 PyThreadState* __tstate = wxPyBeginAllowThreads();
23322 (arg1)->SetPosition(arg2);
23323 wxPyEndAllowThreads(__tstate);
23324 if (PyErr_Occurred()) SWIG_fail;
23325 }
23326 resultobj = SWIG_Py_Void();
23327 return resultobj;
23328 fail:
23329 return NULL;
23330 }
23331
23332
23333 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23334 PyObject *obj;
23335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23336 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
23337 return SWIG_Py_Void();
23338 }
23339
23340 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23341 return SWIG_Python_InitShadowInstance(args);
23342 }
23343
23344 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23345 PyObject *resultobj = 0;
23346 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23347 wxMouseEvent *result = 0 ;
23348 int val1 ;
23349 int ecode1 = 0 ;
23350 PyObject * obj0 = 0 ;
23351 char * kwnames[] = {
23352 (char *) "mouseType", NULL
23353 };
23354
23355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
23356 if (obj0) {
23357 ecode1 = SWIG_AsVal_int(obj0, &val1);
23358 if (!SWIG_IsOK(ecode1)) {
23359 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23360 }
23361 arg1 = static_cast< wxEventType >(val1);
23362 }
23363 {
23364 PyThreadState* __tstate = wxPyBeginAllowThreads();
23365 result = (wxMouseEvent *)new wxMouseEvent(arg1);
23366 wxPyEndAllowThreads(__tstate);
23367 if (PyErr_Occurred()) SWIG_fail;
23368 }
23369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
23370 return resultobj;
23371 fail:
23372 return NULL;
23373 }
23374
23375
23376 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23377 PyObject *resultobj = 0;
23378 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23379 bool result;
23380 void *argp1 = 0 ;
23381 int res1 = 0 ;
23382 PyObject *swig_obj[1] ;
23383
23384 if (!args) SWIG_fail;
23385 swig_obj[0] = args;
23386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23387 if (!SWIG_IsOK(res1)) {
23388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23389 }
23390 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23391 {
23392 PyThreadState* __tstate = wxPyBeginAllowThreads();
23393 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
23394 wxPyEndAllowThreads(__tstate);
23395 if (PyErr_Occurred()) SWIG_fail;
23396 }
23397 {
23398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23399 }
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj = 0;
23408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23409 int arg2 = (int) wxMOUSE_BTN_ANY ;
23410 bool result;
23411 void *argp1 = 0 ;
23412 int res1 = 0 ;
23413 int val2 ;
23414 int ecode2 = 0 ;
23415 PyObject * obj0 = 0 ;
23416 PyObject * obj1 = 0 ;
23417 char * kwnames[] = {
23418 (char *) "self",(char *) "but", NULL
23419 };
23420
23421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
23422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23423 if (!SWIG_IsOK(res1)) {
23424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23425 }
23426 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23427 if (obj1) {
23428 ecode2 = SWIG_AsVal_int(obj1, &val2);
23429 if (!SWIG_IsOK(ecode2)) {
23430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
23431 }
23432 arg2 = static_cast< int >(val2);
23433 }
23434 {
23435 PyThreadState* __tstate = wxPyBeginAllowThreads();
23436 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
23437 wxPyEndAllowThreads(__tstate);
23438 if (PyErr_Occurred()) SWIG_fail;
23439 }
23440 {
23441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23442 }
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj = 0;
23451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23452 int arg2 = (int) wxMOUSE_BTN_ANY ;
23453 bool result;
23454 void *argp1 = 0 ;
23455 int res1 = 0 ;
23456 int val2 ;
23457 int ecode2 = 0 ;
23458 PyObject * obj0 = 0 ;
23459 PyObject * obj1 = 0 ;
23460 char * kwnames[] = {
23461 (char *) "self",(char *) "but", NULL
23462 };
23463
23464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
23465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23466 if (!SWIG_IsOK(res1)) {
23467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23468 }
23469 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23470 if (obj1) {
23471 ecode2 = SWIG_AsVal_int(obj1, &val2);
23472 if (!SWIG_IsOK(ecode2)) {
23473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
23474 }
23475 arg2 = static_cast< int >(val2);
23476 }
23477 {
23478 PyThreadState* __tstate = wxPyBeginAllowThreads();
23479 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
23480 wxPyEndAllowThreads(__tstate);
23481 if (PyErr_Occurred()) SWIG_fail;
23482 }
23483 {
23484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23485 }
23486 return resultobj;
23487 fail:
23488 return NULL;
23489 }
23490
23491
23492 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23493 PyObject *resultobj = 0;
23494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23495 int arg2 = (int) wxMOUSE_BTN_ANY ;
23496 bool result;
23497 void *argp1 = 0 ;
23498 int res1 = 0 ;
23499 int val2 ;
23500 int ecode2 = 0 ;
23501 PyObject * obj0 = 0 ;
23502 PyObject * obj1 = 0 ;
23503 char * kwnames[] = {
23504 (char *) "self",(char *) "but", NULL
23505 };
23506
23507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
23508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23509 if (!SWIG_IsOK(res1)) {
23510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23511 }
23512 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23513 if (obj1) {
23514 ecode2 = SWIG_AsVal_int(obj1, &val2);
23515 if (!SWIG_IsOK(ecode2)) {
23516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
23517 }
23518 arg2 = static_cast< int >(val2);
23519 }
23520 {
23521 PyThreadState* __tstate = wxPyBeginAllowThreads();
23522 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
23523 wxPyEndAllowThreads(__tstate);
23524 if (PyErr_Occurred()) SWIG_fail;
23525 }
23526 {
23527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23528 }
23529 return resultobj;
23530 fail:
23531 return NULL;
23532 }
23533
23534
23535 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23536 PyObject *resultobj = 0;
23537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23538 int arg2 ;
23539 bool result;
23540 void *argp1 = 0 ;
23541 int res1 = 0 ;
23542 int val2 ;
23543 int ecode2 = 0 ;
23544 PyObject * obj0 = 0 ;
23545 PyObject * obj1 = 0 ;
23546 char * kwnames[] = {
23547 (char *) "self",(char *) "button", NULL
23548 };
23549
23550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23552 if (!SWIG_IsOK(res1)) {
23553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23554 }
23555 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23556 ecode2 = SWIG_AsVal_int(obj1, &val2);
23557 if (!SWIG_IsOK(ecode2)) {
23558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23559 }
23560 arg2 = static_cast< int >(val2);
23561 {
23562 PyThreadState* __tstate = wxPyBeginAllowThreads();
23563 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23564 wxPyEndAllowThreads(__tstate);
23565 if (PyErr_Occurred()) SWIG_fail;
23566 }
23567 {
23568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23569 }
23570 return resultobj;
23571 fail:
23572 return NULL;
23573 }
23574
23575
23576 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23577 PyObject *resultobj = 0;
23578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23579 int arg2 ;
23580 bool result;
23581 void *argp1 = 0 ;
23582 int res1 = 0 ;
23583 int val2 ;
23584 int ecode2 = 0 ;
23585 PyObject * obj0 = 0 ;
23586 PyObject * obj1 = 0 ;
23587 char * kwnames[] = {
23588 (char *) "self",(char *) "but", NULL
23589 };
23590
23591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23593 if (!SWIG_IsOK(res1)) {
23594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23595 }
23596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23597 ecode2 = SWIG_AsVal_int(obj1, &val2);
23598 if (!SWIG_IsOK(ecode2)) {
23599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23600 }
23601 arg2 = static_cast< int >(val2);
23602 {
23603 PyThreadState* __tstate = wxPyBeginAllowThreads();
23604 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23605 wxPyEndAllowThreads(__tstate);
23606 if (PyErr_Occurred()) SWIG_fail;
23607 }
23608 {
23609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23610 }
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23618 PyObject *resultobj = 0;
23619 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23620 int result;
23621 void *argp1 = 0 ;
23622 int res1 = 0 ;
23623 PyObject *swig_obj[1] ;
23624
23625 if (!args) SWIG_fail;
23626 swig_obj[0] = args;
23627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23628 if (!SWIG_IsOK(res1)) {
23629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23630 }
23631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23632 {
23633 PyThreadState* __tstate = wxPyBeginAllowThreads();
23634 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23635 wxPyEndAllowThreads(__tstate);
23636 if (PyErr_Occurred()) SWIG_fail;
23637 }
23638 resultobj = SWIG_From_int(static_cast< int >(result));
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23646 PyObject *resultobj = 0;
23647 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23648 bool result;
23649 void *argp1 = 0 ;
23650 int res1 = 0 ;
23651 PyObject *swig_obj[1] ;
23652
23653 if (!args) SWIG_fail;
23654 swig_obj[0] = args;
23655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23656 if (!SWIG_IsOK(res1)) {
23657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23658 }
23659 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23660 {
23661 PyThreadState* __tstate = wxPyBeginAllowThreads();
23662 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23663 wxPyEndAllowThreads(__tstate);
23664 if (PyErr_Occurred()) SWIG_fail;
23665 }
23666 {
23667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23668 }
23669 return resultobj;
23670 fail:
23671 return NULL;
23672 }
23673
23674
23675 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23676 PyObject *resultobj = 0;
23677 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23678 bool result;
23679 void *argp1 = 0 ;
23680 int res1 = 0 ;
23681 PyObject *swig_obj[1] ;
23682
23683 if (!args) SWIG_fail;
23684 swig_obj[0] = args;
23685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23686 if (!SWIG_IsOK(res1)) {
23687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23688 }
23689 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23690 {
23691 PyThreadState* __tstate = wxPyBeginAllowThreads();
23692 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23693 wxPyEndAllowThreads(__tstate);
23694 if (PyErr_Occurred()) SWIG_fail;
23695 }
23696 {
23697 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23698 }
23699 return resultobj;
23700 fail:
23701 return NULL;
23702 }
23703
23704
23705 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23706 PyObject *resultobj = 0;
23707 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23708 bool result;
23709 void *argp1 = 0 ;
23710 int res1 = 0 ;
23711 PyObject *swig_obj[1] ;
23712
23713 if (!args) SWIG_fail;
23714 swig_obj[0] = args;
23715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23716 if (!SWIG_IsOK(res1)) {
23717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23718 }
23719 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23723 wxPyEndAllowThreads(__tstate);
23724 if (PyErr_Occurred()) SWIG_fail;
23725 }
23726 {
23727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23728 }
23729 return resultobj;
23730 fail:
23731 return NULL;
23732 }
23733
23734
23735 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23736 PyObject *resultobj = 0;
23737 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23738 bool result;
23739 void *argp1 = 0 ;
23740 int res1 = 0 ;
23741 PyObject *swig_obj[1] ;
23742
23743 if (!args) SWIG_fail;
23744 swig_obj[0] = args;
23745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23746 if (!SWIG_IsOK(res1)) {
23747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23748 }
23749 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23750 {
23751 PyThreadState* __tstate = wxPyBeginAllowThreads();
23752 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23753 wxPyEndAllowThreads(__tstate);
23754 if (PyErr_Occurred()) SWIG_fail;
23755 }
23756 {
23757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23758 }
23759 return resultobj;
23760 fail:
23761 return NULL;
23762 }
23763
23764
23765 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23766 PyObject *resultobj = 0;
23767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23768 bool result;
23769 void *argp1 = 0 ;
23770 int res1 = 0 ;
23771 PyObject *swig_obj[1] ;
23772
23773 if (!args) SWIG_fail;
23774 swig_obj[0] = args;
23775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23776 if (!SWIG_IsOK(res1)) {
23777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23778 }
23779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23780 {
23781 PyThreadState* __tstate = wxPyBeginAllowThreads();
23782 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23783 wxPyEndAllowThreads(__tstate);
23784 if (PyErr_Occurred()) SWIG_fail;
23785 }
23786 {
23787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23788 }
23789 return resultobj;
23790 fail:
23791 return NULL;
23792 }
23793
23794
23795 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23796 PyObject *resultobj = 0;
23797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23798 bool result;
23799 void *argp1 = 0 ;
23800 int res1 = 0 ;
23801 PyObject *swig_obj[1] ;
23802
23803 if (!args) SWIG_fail;
23804 swig_obj[0] = args;
23805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23806 if (!SWIG_IsOK(res1)) {
23807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23808 }
23809 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23810 {
23811 PyThreadState* __tstate = wxPyBeginAllowThreads();
23812 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23813 wxPyEndAllowThreads(__tstate);
23814 if (PyErr_Occurred()) SWIG_fail;
23815 }
23816 {
23817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23818 }
23819 return resultobj;
23820 fail:
23821 return NULL;
23822 }
23823
23824
23825 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23826 PyObject *resultobj = 0;
23827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23828 bool result;
23829 void *argp1 = 0 ;
23830 int res1 = 0 ;
23831 PyObject *swig_obj[1] ;
23832
23833 if (!args) SWIG_fail;
23834 swig_obj[0] = args;
23835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23836 if (!SWIG_IsOK(res1)) {
23837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23838 }
23839 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23840 {
23841 PyThreadState* __tstate = wxPyBeginAllowThreads();
23842 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23843 wxPyEndAllowThreads(__tstate);
23844 if (PyErr_Occurred()) SWIG_fail;
23845 }
23846 {
23847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23848 }
23849 return resultobj;
23850 fail:
23851 return NULL;
23852 }
23853
23854
23855 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23856 PyObject *resultobj = 0;
23857 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23858 bool result;
23859 void *argp1 = 0 ;
23860 int res1 = 0 ;
23861 PyObject *swig_obj[1] ;
23862
23863 if (!args) SWIG_fail;
23864 swig_obj[0] = args;
23865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23866 if (!SWIG_IsOK(res1)) {
23867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23868 }
23869 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23870 {
23871 PyThreadState* __tstate = wxPyBeginAllowThreads();
23872 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 {
23877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23878 }
23879 return resultobj;
23880 fail:
23881 return NULL;
23882 }
23883
23884
23885 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23886 PyObject *resultobj = 0;
23887 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23888 bool result;
23889 void *argp1 = 0 ;
23890 int res1 = 0 ;
23891 PyObject *swig_obj[1] ;
23892
23893 if (!args) SWIG_fail;
23894 swig_obj[0] = args;
23895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23896 if (!SWIG_IsOK(res1)) {
23897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23898 }
23899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23900 {
23901 PyThreadState* __tstate = wxPyBeginAllowThreads();
23902 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23903 wxPyEndAllowThreads(__tstate);
23904 if (PyErr_Occurred()) SWIG_fail;
23905 }
23906 {
23907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23908 }
23909 return resultobj;
23910 fail:
23911 return NULL;
23912 }
23913
23914
23915 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23916 PyObject *resultobj = 0;
23917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23918 bool result;
23919 void *argp1 = 0 ;
23920 int res1 = 0 ;
23921 PyObject *swig_obj[1] ;
23922
23923 if (!args) SWIG_fail;
23924 swig_obj[0] = args;
23925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23926 if (!SWIG_IsOK(res1)) {
23927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23928 }
23929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23930 {
23931 PyThreadState* __tstate = wxPyBeginAllowThreads();
23932 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23933 wxPyEndAllowThreads(__tstate);
23934 if (PyErr_Occurred()) SWIG_fail;
23935 }
23936 {
23937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23938 }
23939 return resultobj;
23940 fail:
23941 return NULL;
23942 }
23943
23944
23945 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23946 PyObject *resultobj = 0;
23947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23948 bool result;
23949 void *argp1 = 0 ;
23950 int res1 = 0 ;
23951 PyObject *swig_obj[1] ;
23952
23953 if (!args) SWIG_fail;
23954 swig_obj[0] = args;
23955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23956 if (!SWIG_IsOK(res1)) {
23957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23958 }
23959 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23960 {
23961 PyThreadState* __tstate = wxPyBeginAllowThreads();
23962 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23963 wxPyEndAllowThreads(__tstate);
23964 if (PyErr_Occurred()) SWIG_fail;
23965 }
23966 {
23967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23968 }
23969 return resultobj;
23970 fail:
23971 return NULL;
23972 }
23973
23974
23975 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23976 PyObject *resultobj = 0;
23977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23978 bool result;
23979 void *argp1 = 0 ;
23980 int res1 = 0 ;
23981 PyObject *swig_obj[1] ;
23982
23983 if (!args) SWIG_fail;
23984 swig_obj[0] = args;
23985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23986 if (!SWIG_IsOK(res1)) {
23987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23988 }
23989 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23990 {
23991 PyThreadState* __tstate = wxPyBeginAllowThreads();
23992 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23993 wxPyEndAllowThreads(__tstate);
23994 if (PyErr_Occurred()) SWIG_fail;
23995 }
23996 {
23997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23998 }
23999 return resultobj;
24000 fail:
24001 return NULL;
24002 }
24003
24004
24005 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24006 PyObject *resultobj = 0;
24007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24008 bool result;
24009 void *argp1 = 0 ;
24010 int res1 = 0 ;
24011 PyObject *swig_obj[1] ;
24012
24013 if (!args) SWIG_fail;
24014 swig_obj[0] = args;
24015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24016 if (!SWIG_IsOK(res1)) {
24017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24018 }
24019 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24020 {
24021 PyThreadState* __tstate = wxPyBeginAllowThreads();
24022 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
24023 wxPyEndAllowThreads(__tstate);
24024 if (PyErr_Occurred()) SWIG_fail;
24025 }
24026 {
24027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24028 }
24029 return resultobj;
24030 fail:
24031 return NULL;
24032 }
24033
24034
24035 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24036 PyObject *resultobj = 0;
24037 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24038 bool result;
24039 void *argp1 = 0 ;
24040 int res1 = 0 ;
24041 PyObject *swig_obj[1] ;
24042
24043 if (!args) SWIG_fail;
24044 swig_obj[0] = args;
24045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24046 if (!SWIG_IsOK(res1)) {
24047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24048 }
24049 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24050 {
24051 PyThreadState* __tstate = wxPyBeginAllowThreads();
24052 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
24053 wxPyEndAllowThreads(__tstate);
24054 if (PyErr_Occurred()) SWIG_fail;
24055 }
24056 {
24057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24058 }
24059 return resultobj;
24060 fail:
24061 return NULL;
24062 }
24063
24064
24065 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24066 PyObject *resultobj = 0;
24067 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24068 bool result;
24069 void *argp1 = 0 ;
24070 int res1 = 0 ;
24071 PyObject *swig_obj[1] ;
24072
24073 if (!args) SWIG_fail;
24074 swig_obj[0] = args;
24075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24076 if (!SWIG_IsOK(res1)) {
24077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24078 }
24079 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24080 {
24081 PyThreadState* __tstate = wxPyBeginAllowThreads();
24082 result = (bool)(arg1)->LeftIsDown();
24083 wxPyEndAllowThreads(__tstate);
24084 if (PyErr_Occurred()) SWIG_fail;
24085 }
24086 {
24087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24088 }
24089 return resultobj;
24090 fail:
24091 return NULL;
24092 }
24093
24094
24095 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24096 PyObject *resultobj = 0;
24097 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24098 bool result;
24099 void *argp1 = 0 ;
24100 int res1 = 0 ;
24101 PyObject *swig_obj[1] ;
24102
24103 if (!args) SWIG_fail;
24104 swig_obj[0] = args;
24105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24106 if (!SWIG_IsOK(res1)) {
24107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24108 }
24109 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24110 {
24111 PyThreadState* __tstate = wxPyBeginAllowThreads();
24112 result = (bool)(arg1)->MiddleIsDown();
24113 wxPyEndAllowThreads(__tstate);
24114 if (PyErr_Occurred()) SWIG_fail;
24115 }
24116 {
24117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24118 }
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24126 PyObject *resultobj = 0;
24127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24128 bool result;
24129 void *argp1 = 0 ;
24130 int res1 = 0 ;
24131 PyObject *swig_obj[1] ;
24132
24133 if (!args) SWIG_fail;
24134 swig_obj[0] = args;
24135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24136 if (!SWIG_IsOK(res1)) {
24137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24138 }
24139 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24140 {
24141 PyThreadState* __tstate = wxPyBeginAllowThreads();
24142 result = (bool)(arg1)->RightIsDown();
24143 wxPyEndAllowThreads(__tstate);
24144 if (PyErr_Occurred()) SWIG_fail;
24145 }
24146 {
24147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24148 }
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24156 PyObject *resultobj = 0;
24157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24158 bool result;
24159 void *argp1 = 0 ;
24160 int res1 = 0 ;
24161 PyObject *swig_obj[1] ;
24162
24163 if (!args) SWIG_fail;
24164 swig_obj[0] = args;
24165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24166 if (!SWIG_IsOK(res1)) {
24167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24168 }
24169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24170 {
24171 PyThreadState* __tstate = wxPyBeginAllowThreads();
24172 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
24173 wxPyEndAllowThreads(__tstate);
24174 if (PyErr_Occurred()) SWIG_fail;
24175 }
24176 {
24177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24178 }
24179 return resultobj;
24180 fail:
24181 return NULL;
24182 }
24183
24184
24185 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24186 PyObject *resultobj = 0;
24187 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24188 bool result;
24189 void *argp1 = 0 ;
24190 int res1 = 0 ;
24191 PyObject *swig_obj[1] ;
24192
24193 if (!args) SWIG_fail;
24194 swig_obj[0] = args;
24195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24196 if (!SWIG_IsOK(res1)) {
24197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24198 }
24199 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24200 {
24201 PyThreadState* __tstate = wxPyBeginAllowThreads();
24202 result = (bool)((wxMouseEvent const *)arg1)->Moving();
24203 wxPyEndAllowThreads(__tstate);
24204 if (PyErr_Occurred()) SWIG_fail;
24205 }
24206 {
24207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24208 }
24209 return resultobj;
24210 fail:
24211 return NULL;
24212 }
24213
24214
24215 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24216 PyObject *resultobj = 0;
24217 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24218 bool result;
24219 void *argp1 = 0 ;
24220 int res1 = 0 ;
24221 PyObject *swig_obj[1] ;
24222
24223 if (!args) SWIG_fail;
24224 swig_obj[0] = args;
24225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24226 if (!SWIG_IsOK(res1)) {
24227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24228 }
24229 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24230 {
24231 PyThreadState* __tstate = wxPyBeginAllowThreads();
24232 result = (bool)((wxMouseEvent const *)arg1)->Entering();
24233 wxPyEndAllowThreads(__tstate);
24234 if (PyErr_Occurred()) SWIG_fail;
24235 }
24236 {
24237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24238 }
24239 return resultobj;
24240 fail:
24241 return NULL;
24242 }
24243
24244
24245 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24246 PyObject *resultobj = 0;
24247 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24248 bool result;
24249 void *argp1 = 0 ;
24250 int res1 = 0 ;
24251 PyObject *swig_obj[1] ;
24252
24253 if (!args) SWIG_fail;
24254 swig_obj[0] = args;
24255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24256 if (!SWIG_IsOK(res1)) {
24257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24258 }
24259 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24260 {
24261 PyThreadState* __tstate = wxPyBeginAllowThreads();
24262 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
24263 wxPyEndAllowThreads(__tstate);
24264 if (PyErr_Occurred()) SWIG_fail;
24265 }
24266 {
24267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24268 }
24269 return resultobj;
24270 fail:
24271 return NULL;
24272 }
24273
24274
24275 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24276 PyObject *resultobj = 0;
24277 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24278 wxPoint result;
24279 void *argp1 = 0 ;
24280 int res1 = 0 ;
24281 PyObject *swig_obj[1] ;
24282
24283 if (!args) SWIG_fail;
24284 swig_obj[0] = args;
24285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24286 if (!SWIG_IsOK(res1)) {
24287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24288 }
24289 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24290 {
24291 PyThreadState* __tstate = wxPyBeginAllowThreads();
24292 result = (arg1)->GetPosition();
24293 wxPyEndAllowThreads(__tstate);
24294 if (PyErr_Occurred()) SWIG_fail;
24295 }
24296 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24297 return resultobj;
24298 fail:
24299 return NULL;
24300 }
24301
24302
24303 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24304 PyObject *resultobj = 0;
24305 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24306 long *arg2 = (long *) 0 ;
24307 long *arg3 = (long *) 0 ;
24308 void *argp1 = 0 ;
24309 int res1 = 0 ;
24310 long temp2 ;
24311 int res2 = SWIG_TMPOBJ ;
24312 long temp3 ;
24313 int res3 = SWIG_TMPOBJ ;
24314 PyObject *swig_obj[1] ;
24315
24316 arg2 = &temp2;
24317 arg3 = &temp3;
24318 if (!args) SWIG_fail;
24319 swig_obj[0] = args;
24320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24321 if (!SWIG_IsOK(res1)) {
24322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24323 }
24324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24325 {
24326 PyThreadState* __tstate = wxPyBeginAllowThreads();
24327 (arg1)->GetPosition(arg2,arg3);
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 resultobj = SWIG_Py_Void();
24332 if (SWIG_IsTmpObj(res2)) {
24333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
24334 } else {
24335 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
24337 }
24338 if (SWIG_IsTmpObj(res3)) {
24339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
24340 } else {
24341 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
24342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
24343 }
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj = 0;
24352 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24353 wxDC *arg2 = 0 ;
24354 wxPoint result;
24355 void *argp1 = 0 ;
24356 int res1 = 0 ;
24357 void *argp2 = 0 ;
24358 int res2 = 0 ;
24359 PyObject * obj0 = 0 ;
24360 PyObject * obj1 = 0 ;
24361 char * kwnames[] = {
24362 (char *) "self",(char *) "dc", NULL
24363 };
24364
24365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
24366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24367 if (!SWIG_IsOK(res1)) {
24368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24369 }
24370 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24371 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
24372 if (!SWIG_IsOK(res2)) {
24373 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24374 }
24375 if (!argp2) {
24376 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
24377 }
24378 arg2 = reinterpret_cast< wxDC * >(argp2);
24379 {
24380 PyThreadState* __tstate = wxPyBeginAllowThreads();
24381 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
24382 wxPyEndAllowThreads(__tstate);
24383 if (PyErr_Occurred()) SWIG_fail;
24384 }
24385 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24386 return resultobj;
24387 fail:
24388 return NULL;
24389 }
24390
24391
24392 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24393 PyObject *resultobj = 0;
24394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24395 int result;
24396 void *argp1 = 0 ;
24397 int res1 = 0 ;
24398 PyObject *swig_obj[1] ;
24399
24400 if (!args) SWIG_fail;
24401 swig_obj[0] = args;
24402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24403 if (!SWIG_IsOK(res1)) {
24404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24405 }
24406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24407 {
24408 PyThreadState* __tstate = wxPyBeginAllowThreads();
24409 result = (int)((wxMouseEvent const *)arg1)->GetX();
24410 wxPyEndAllowThreads(__tstate);
24411 if (PyErr_Occurred()) SWIG_fail;
24412 }
24413 resultobj = SWIG_From_int(static_cast< int >(result));
24414 return resultobj;
24415 fail:
24416 return NULL;
24417 }
24418
24419
24420 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24421 PyObject *resultobj = 0;
24422 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24423 int result;
24424 void *argp1 = 0 ;
24425 int res1 = 0 ;
24426 PyObject *swig_obj[1] ;
24427
24428 if (!args) SWIG_fail;
24429 swig_obj[0] = args;
24430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24431 if (!SWIG_IsOK(res1)) {
24432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24433 }
24434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24435 {
24436 PyThreadState* __tstate = wxPyBeginAllowThreads();
24437 result = (int)((wxMouseEvent const *)arg1)->GetY();
24438 wxPyEndAllowThreads(__tstate);
24439 if (PyErr_Occurred()) SWIG_fail;
24440 }
24441 resultobj = SWIG_From_int(static_cast< int >(result));
24442 return resultobj;
24443 fail:
24444 return NULL;
24445 }
24446
24447
24448 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24449 PyObject *resultobj = 0;
24450 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24451 int result;
24452 void *argp1 = 0 ;
24453 int res1 = 0 ;
24454 PyObject *swig_obj[1] ;
24455
24456 if (!args) SWIG_fail;
24457 swig_obj[0] = args;
24458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24459 if (!SWIG_IsOK(res1)) {
24460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24461 }
24462 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24463 {
24464 PyThreadState* __tstate = wxPyBeginAllowThreads();
24465 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
24466 wxPyEndAllowThreads(__tstate);
24467 if (PyErr_Occurred()) SWIG_fail;
24468 }
24469 resultobj = SWIG_From_int(static_cast< int >(result));
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24477 PyObject *resultobj = 0;
24478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24479 int result;
24480 void *argp1 = 0 ;
24481 int res1 = 0 ;
24482 PyObject *swig_obj[1] ;
24483
24484 if (!args) SWIG_fail;
24485 swig_obj[0] = args;
24486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24487 if (!SWIG_IsOK(res1)) {
24488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24489 }
24490 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24491 {
24492 PyThreadState* __tstate = wxPyBeginAllowThreads();
24493 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
24494 wxPyEndAllowThreads(__tstate);
24495 if (PyErr_Occurred()) SWIG_fail;
24496 }
24497 resultobj = SWIG_From_int(static_cast< int >(result));
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24505 PyObject *resultobj = 0;
24506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24507 int result;
24508 void *argp1 = 0 ;
24509 int res1 = 0 ;
24510 PyObject *swig_obj[1] ;
24511
24512 if (!args) SWIG_fail;
24513 swig_obj[0] = args;
24514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24515 if (!SWIG_IsOK(res1)) {
24516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24517 }
24518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24519 {
24520 PyThreadState* __tstate = wxPyBeginAllowThreads();
24521 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
24522 wxPyEndAllowThreads(__tstate);
24523 if (PyErr_Occurred()) SWIG_fail;
24524 }
24525 resultobj = SWIG_From_int(static_cast< int >(result));
24526 return resultobj;
24527 fail:
24528 return NULL;
24529 }
24530
24531
24532 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24533 PyObject *resultobj = 0;
24534 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24535 int result;
24536 void *argp1 = 0 ;
24537 int res1 = 0 ;
24538 PyObject *swig_obj[1] ;
24539
24540 if (!args) SWIG_fail;
24541 swig_obj[0] = args;
24542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24543 if (!SWIG_IsOK(res1)) {
24544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24545 }
24546 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24547 {
24548 PyThreadState* __tstate = wxPyBeginAllowThreads();
24549 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 resultobj = SWIG_From_int(static_cast< int >(result));
24554 return resultobj;
24555 fail:
24556 return NULL;
24557 }
24558
24559
24560 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24561 PyObject *resultobj = 0;
24562 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24563 bool result;
24564 void *argp1 = 0 ;
24565 int res1 = 0 ;
24566 PyObject *swig_obj[1] ;
24567
24568 if (!args) SWIG_fail;
24569 swig_obj[0] = args;
24570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24571 if (!SWIG_IsOK(res1)) {
24572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24573 }
24574 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24575 {
24576 PyThreadState* __tstate = wxPyBeginAllowThreads();
24577 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24578 wxPyEndAllowThreads(__tstate);
24579 if (PyErr_Occurred()) SWIG_fail;
24580 }
24581 {
24582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24583 }
24584 return resultobj;
24585 fail:
24586 return NULL;
24587 }
24588
24589
24590 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24591 PyObject *resultobj = 0;
24592 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24593 int arg2 ;
24594 void *argp1 = 0 ;
24595 int res1 = 0 ;
24596 int val2 ;
24597 int ecode2 = 0 ;
24598 PyObject *swig_obj[2] ;
24599
24600 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24602 if (!SWIG_IsOK(res1)) {
24603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24604 }
24605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24606 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24607 if (!SWIG_IsOK(ecode2)) {
24608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24609 }
24610 arg2 = static_cast< int >(val2);
24611 if (arg1) (arg1)->m_x = arg2;
24612
24613 resultobj = SWIG_Py_Void();
24614 return resultobj;
24615 fail:
24616 return NULL;
24617 }
24618
24619
24620 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24621 PyObject *resultobj = 0;
24622 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24623 int result;
24624 void *argp1 = 0 ;
24625 int res1 = 0 ;
24626 PyObject *swig_obj[1] ;
24627
24628 if (!args) SWIG_fail;
24629 swig_obj[0] = args;
24630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24631 if (!SWIG_IsOK(res1)) {
24632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24633 }
24634 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24635 result = (int) ((arg1)->m_x);
24636 resultobj = SWIG_From_int(static_cast< int >(result));
24637 return resultobj;
24638 fail:
24639 return NULL;
24640 }
24641
24642
24643 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24644 PyObject *resultobj = 0;
24645 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24646 int arg2 ;
24647 void *argp1 = 0 ;
24648 int res1 = 0 ;
24649 int val2 ;
24650 int ecode2 = 0 ;
24651 PyObject *swig_obj[2] ;
24652
24653 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24655 if (!SWIG_IsOK(res1)) {
24656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24657 }
24658 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24659 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24660 if (!SWIG_IsOK(ecode2)) {
24661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24662 }
24663 arg2 = static_cast< int >(val2);
24664 if (arg1) (arg1)->m_y = arg2;
24665
24666 resultobj = SWIG_Py_Void();
24667 return resultobj;
24668 fail:
24669 return NULL;
24670 }
24671
24672
24673 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24674 PyObject *resultobj = 0;
24675 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24676 int result;
24677 void *argp1 = 0 ;
24678 int res1 = 0 ;
24679 PyObject *swig_obj[1] ;
24680
24681 if (!args) SWIG_fail;
24682 swig_obj[0] = args;
24683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24684 if (!SWIG_IsOK(res1)) {
24685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24686 }
24687 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24688 result = (int) ((arg1)->m_y);
24689 resultobj = SWIG_From_int(static_cast< int >(result));
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24699 bool arg2 ;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 bool val2 ;
24703 int ecode2 = 0 ;
24704 PyObject *swig_obj[2] ;
24705
24706 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24708 if (!SWIG_IsOK(res1)) {
24709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24710 }
24711 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24712 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24713 if (!SWIG_IsOK(ecode2)) {
24714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24715 }
24716 arg2 = static_cast< bool >(val2);
24717 if (arg1) (arg1)->m_leftDown = arg2;
24718
24719 resultobj = SWIG_Py_Void();
24720 return resultobj;
24721 fail:
24722 return NULL;
24723 }
24724
24725
24726 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24727 PyObject *resultobj = 0;
24728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24729 bool result;
24730 void *argp1 = 0 ;
24731 int res1 = 0 ;
24732 PyObject *swig_obj[1] ;
24733
24734 if (!args) SWIG_fail;
24735 swig_obj[0] = args;
24736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24737 if (!SWIG_IsOK(res1)) {
24738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24739 }
24740 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24741 result = (bool) ((arg1)->m_leftDown);
24742 {
24743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24744 }
24745 return resultobj;
24746 fail:
24747 return NULL;
24748 }
24749
24750
24751 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24752 PyObject *resultobj = 0;
24753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24754 bool arg2 ;
24755 void *argp1 = 0 ;
24756 int res1 = 0 ;
24757 bool val2 ;
24758 int ecode2 = 0 ;
24759 PyObject *swig_obj[2] ;
24760
24761 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24763 if (!SWIG_IsOK(res1)) {
24764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24765 }
24766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24767 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24768 if (!SWIG_IsOK(ecode2)) {
24769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24770 }
24771 arg2 = static_cast< bool >(val2);
24772 if (arg1) (arg1)->m_middleDown = arg2;
24773
24774 resultobj = SWIG_Py_Void();
24775 return resultobj;
24776 fail:
24777 return NULL;
24778 }
24779
24780
24781 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24782 PyObject *resultobj = 0;
24783 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24784 bool result;
24785 void *argp1 = 0 ;
24786 int res1 = 0 ;
24787 PyObject *swig_obj[1] ;
24788
24789 if (!args) SWIG_fail;
24790 swig_obj[0] = args;
24791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24792 if (!SWIG_IsOK(res1)) {
24793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24794 }
24795 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24796 result = (bool) ((arg1)->m_middleDown);
24797 {
24798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24799 }
24800 return resultobj;
24801 fail:
24802 return NULL;
24803 }
24804
24805
24806 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24807 PyObject *resultobj = 0;
24808 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24809 bool arg2 ;
24810 void *argp1 = 0 ;
24811 int res1 = 0 ;
24812 bool val2 ;
24813 int ecode2 = 0 ;
24814 PyObject *swig_obj[2] ;
24815
24816 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24818 if (!SWIG_IsOK(res1)) {
24819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24820 }
24821 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24822 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24823 if (!SWIG_IsOK(ecode2)) {
24824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24825 }
24826 arg2 = static_cast< bool >(val2);
24827 if (arg1) (arg1)->m_rightDown = arg2;
24828
24829 resultobj = SWIG_Py_Void();
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24837 PyObject *resultobj = 0;
24838 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24839 bool result;
24840 void *argp1 = 0 ;
24841 int res1 = 0 ;
24842 PyObject *swig_obj[1] ;
24843
24844 if (!args) SWIG_fail;
24845 swig_obj[0] = args;
24846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24847 if (!SWIG_IsOK(res1)) {
24848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24849 }
24850 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24851 result = (bool) ((arg1)->m_rightDown);
24852 {
24853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24854 }
24855 return resultobj;
24856 fail:
24857 return NULL;
24858 }
24859
24860
24861 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24862 PyObject *resultobj = 0;
24863 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24864 bool arg2 ;
24865 void *argp1 = 0 ;
24866 int res1 = 0 ;
24867 bool val2 ;
24868 int ecode2 = 0 ;
24869 PyObject *swig_obj[2] ;
24870
24871 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24873 if (!SWIG_IsOK(res1)) {
24874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24875 }
24876 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24877 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24878 if (!SWIG_IsOK(ecode2)) {
24879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24880 }
24881 arg2 = static_cast< bool >(val2);
24882 if (arg1) (arg1)->m_controlDown = arg2;
24883
24884 resultobj = SWIG_Py_Void();
24885 return resultobj;
24886 fail:
24887 return NULL;
24888 }
24889
24890
24891 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24892 PyObject *resultobj = 0;
24893 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24894 bool result;
24895 void *argp1 = 0 ;
24896 int res1 = 0 ;
24897 PyObject *swig_obj[1] ;
24898
24899 if (!args) SWIG_fail;
24900 swig_obj[0] = args;
24901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24902 if (!SWIG_IsOK(res1)) {
24903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24904 }
24905 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24906 result = (bool) ((arg1)->m_controlDown);
24907 {
24908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24909 }
24910 return resultobj;
24911 fail:
24912 return NULL;
24913 }
24914
24915
24916 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24917 PyObject *resultobj = 0;
24918 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24919 bool arg2 ;
24920 void *argp1 = 0 ;
24921 int res1 = 0 ;
24922 bool val2 ;
24923 int ecode2 = 0 ;
24924 PyObject *swig_obj[2] ;
24925
24926 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24932 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24933 if (!SWIG_IsOK(ecode2)) {
24934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24935 }
24936 arg2 = static_cast< bool >(val2);
24937 if (arg1) (arg1)->m_shiftDown = arg2;
24938
24939 resultobj = SWIG_Py_Void();
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24947 PyObject *resultobj = 0;
24948 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24949 bool result;
24950 void *argp1 = 0 ;
24951 int res1 = 0 ;
24952 PyObject *swig_obj[1] ;
24953
24954 if (!args) SWIG_fail;
24955 swig_obj[0] = args;
24956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24959 }
24960 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24961 result = (bool) ((arg1)->m_shiftDown);
24962 {
24963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24964 }
24965 return resultobj;
24966 fail:
24967 return NULL;
24968 }
24969
24970
24971 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24972 PyObject *resultobj = 0;
24973 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24974 bool arg2 ;
24975 void *argp1 = 0 ;
24976 int res1 = 0 ;
24977 bool val2 ;
24978 int ecode2 = 0 ;
24979 PyObject *swig_obj[2] ;
24980
24981 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24983 if (!SWIG_IsOK(res1)) {
24984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24985 }
24986 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24987 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24988 if (!SWIG_IsOK(ecode2)) {
24989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24990 }
24991 arg2 = static_cast< bool >(val2);
24992 if (arg1) (arg1)->m_altDown = arg2;
24993
24994 resultobj = SWIG_Py_Void();
24995 return resultobj;
24996 fail:
24997 return NULL;
24998 }
24999
25000
25001 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25002 PyObject *resultobj = 0;
25003 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25004 bool result;
25005 void *argp1 = 0 ;
25006 int res1 = 0 ;
25007 PyObject *swig_obj[1] ;
25008
25009 if (!args) SWIG_fail;
25010 swig_obj[0] = args;
25011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25012 if (!SWIG_IsOK(res1)) {
25013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25014 }
25015 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25016 result = (bool) ((arg1)->m_altDown);
25017 {
25018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25019 }
25020 return resultobj;
25021 fail:
25022 return NULL;
25023 }
25024
25025
25026 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25027 PyObject *resultobj = 0;
25028 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25029 bool arg2 ;
25030 void *argp1 = 0 ;
25031 int res1 = 0 ;
25032 bool val2 ;
25033 int ecode2 = 0 ;
25034 PyObject *swig_obj[2] ;
25035
25036 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25040 }
25041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25042 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25043 if (!SWIG_IsOK(ecode2)) {
25044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25045 }
25046 arg2 = static_cast< bool >(val2);
25047 if (arg1) (arg1)->m_metaDown = arg2;
25048
25049 resultobj = SWIG_Py_Void();
25050 return resultobj;
25051 fail:
25052 return NULL;
25053 }
25054
25055
25056 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25057 PyObject *resultobj = 0;
25058 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25059 bool result;
25060 void *argp1 = 0 ;
25061 int res1 = 0 ;
25062 PyObject *swig_obj[1] ;
25063
25064 if (!args) SWIG_fail;
25065 swig_obj[0] = args;
25066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25067 if (!SWIG_IsOK(res1)) {
25068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25069 }
25070 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25071 result = (bool) ((arg1)->m_metaDown);
25072 {
25073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25074 }
25075 return resultobj;
25076 fail:
25077 return NULL;
25078 }
25079
25080
25081 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25082 PyObject *resultobj = 0;
25083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25084 int arg2 ;
25085 void *argp1 = 0 ;
25086 int res1 = 0 ;
25087 int val2 ;
25088 int ecode2 = 0 ;
25089 PyObject *swig_obj[2] ;
25090
25091 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
25092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25095 }
25096 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25097 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25098 if (!SWIG_IsOK(ecode2)) {
25099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
25100 }
25101 arg2 = static_cast< int >(val2);
25102 if (arg1) (arg1)->m_wheelRotation = arg2;
25103
25104 resultobj = SWIG_Py_Void();
25105 return resultobj;
25106 fail:
25107 return NULL;
25108 }
25109
25110
25111 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25112 PyObject *resultobj = 0;
25113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25114 int result;
25115 void *argp1 = 0 ;
25116 int res1 = 0 ;
25117 PyObject *swig_obj[1] ;
25118
25119 if (!args) SWIG_fail;
25120 swig_obj[0] = args;
25121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25122 if (!SWIG_IsOK(res1)) {
25123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25124 }
25125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25126 result = (int) ((arg1)->m_wheelRotation);
25127 resultobj = SWIG_From_int(static_cast< int >(result));
25128 return resultobj;
25129 fail:
25130 return NULL;
25131 }
25132
25133
25134 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25135 PyObject *resultobj = 0;
25136 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25137 int arg2 ;
25138 void *argp1 = 0 ;
25139 int res1 = 0 ;
25140 int val2 ;
25141 int ecode2 = 0 ;
25142 PyObject *swig_obj[2] ;
25143
25144 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
25145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25146 if (!SWIG_IsOK(res1)) {
25147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25148 }
25149 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25150 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25151 if (!SWIG_IsOK(ecode2)) {
25152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
25153 }
25154 arg2 = static_cast< int >(val2);
25155 if (arg1) (arg1)->m_wheelDelta = arg2;
25156
25157 resultobj = SWIG_Py_Void();
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25165 PyObject *resultobj = 0;
25166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25167 int result;
25168 void *argp1 = 0 ;
25169 int res1 = 0 ;
25170 PyObject *swig_obj[1] ;
25171
25172 if (!args) SWIG_fail;
25173 swig_obj[0] = args;
25174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25175 if (!SWIG_IsOK(res1)) {
25176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25177 }
25178 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25179 result = (int) ((arg1)->m_wheelDelta);
25180 resultobj = SWIG_From_int(static_cast< int >(result));
25181 return resultobj;
25182 fail:
25183 return NULL;
25184 }
25185
25186
25187 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25188 PyObject *resultobj = 0;
25189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25190 int arg2 ;
25191 void *argp1 = 0 ;
25192 int res1 = 0 ;
25193 int val2 ;
25194 int ecode2 = 0 ;
25195 PyObject *swig_obj[2] ;
25196
25197 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
25198 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25199 if (!SWIG_IsOK(res1)) {
25200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25201 }
25202 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25203 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25204 if (!SWIG_IsOK(ecode2)) {
25205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
25206 }
25207 arg2 = static_cast< int >(val2);
25208 if (arg1) (arg1)->m_linesPerAction = arg2;
25209
25210 resultobj = SWIG_Py_Void();
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25218 PyObject *resultobj = 0;
25219 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
25220 int result;
25221 void *argp1 = 0 ;
25222 int res1 = 0 ;
25223 PyObject *swig_obj[1] ;
25224
25225 if (!args) SWIG_fail;
25226 swig_obj[0] = args;
25227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
25228 if (!SWIG_IsOK(res1)) {
25229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
25230 }
25231 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
25232 result = (int) ((arg1)->m_linesPerAction);
25233 resultobj = SWIG_From_int(static_cast< int >(result));
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *obj;
25242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25243 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
25244 return SWIG_Py_Void();
25245 }
25246
25247 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 return SWIG_Python_InitShadowInstance(args);
25249 }
25250
25251 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 int arg1 = (int) 0 ;
25254 int arg2 = (int) 0 ;
25255 wxSetCursorEvent *result = 0 ;
25256 int val1 ;
25257 int ecode1 = 0 ;
25258 int val2 ;
25259 int ecode2 = 0 ;
25260 PyObject * obj0 = 0 ;
25261 PyObject * obj1 = 0 ;
25262 char * kwnames[] = {
25263 (char *) "x",(char *) "y", NULL
25264 };
25265
25266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25267 if (obj0) {
25268 ecode1 = SWIG_AsVal_int(obj0, &val1);
25269 if (!SWIG_IsOK(ecode1)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
25271 }
25272 arg1 = static_cast< int >(val1);
25273 }
25274 if (obj1) {
25275 ecode2 = SWIG_AsVal_int(obj1, &val2);
25276 if (!SWIG_IsOK(ecode2)) {
25277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
25278 }
25279 arg2 = static_cast< int >(val2);
25280 }
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *resultobj = 0;
25296 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25297 int result;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 PyObject *swig_obj[1] ;
25301
25302 if (!args) SWIG_fail;
25303 swig_obj[0] = args;
25304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 resultobj = SWIG_From_int(static_cast< int >(result));
25316 return resultobj;
25317 fail:
25318 return NULL;
25319 }
25320
25321
25322 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25323 PyObject *resultobj = 0;
25324 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25325 int result;
25326 void *argp1 = 0 ;
25327 int res1 = 0 ;
25328 PyObject *swig_obj[1] ;
25329
25330 if (!args) SWIG_fail;
25331 swig_obj[0] = args;
25332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25333 if (!SWIG_IsOK(res1)) {
25334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25335 }
25336 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
25340 wxPyEndAllowThreads(__tstate);
25341 if (PyErr_Occurred()) SWIG_fail;
25342 }
25343 resultobj = SWIG_From_int(static_cast< int >(result));
25344 return resultobj;
25345 fail:
25346 return NULL;
25347 }
25348
25349
25350 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25351 PyObject *resultobj = 0;
25352 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25353 wxCursor *arg2 = 0 ;
25354 void *argp1 = 0 ;
25355 int res1 = 0 ;
25356 void *argp2 = 0 ;
25357 int res2 = 0 ;
25358 PyObject * obj0 = 0 ;
25359 PyObject * obj1 = 0 ;
25360 char * kwnames[] = {
25361 (char *) "self",(char *) "cursor", NULL
25362 };
25363
25364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
25365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25366 if (!SWIG_IsOK(res1)) {
25367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
25368 }
25369 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25370 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
25371 if (!SWIG_IsOK(res2)) {
25372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25373 }
25374 if (!argp2) {
25375 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
25376 }
25377 arg2 = reinterpret_cast< wxCursor * >(argp2);
25378 {
25379 PyThreadState* __tstate = wxPyBeginAllowThreads();
25380 (arg1)->SetCursor((wxCursor const &)*arg2);
25381 wxPyEndAllowThreads(__tstate);
25382 if (PyErr_Occurred()) SWIG_fail;
25383 }
25384 resultobj = SWIG_Py_Void();
25385 return resultobj;
25386 fail:
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25392 PyObject *resultobj = 0;
25393 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25394 wxCursor *result = 0 ;
25395 void *argp1 = 0 ;
25396 int res1 = 0 ;
25397 PyObject *swig_obj[1] ;
25398
25399 if (!args) SWIG_fail;
25400 swig_obj[0] = args;
25401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25402 if (!SWIG_IsOK(res1)) {
25403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25404 }
25405 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 {
25409 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
25410 result = (wxCursor *) &_result_ref;
25411 }
25412 wxPyEndAllowThreads(__tstate);
25413 if (PyErr_Occurred()) SWIG_fail;
25414 }
25415 {
25416 wxCursor* resultptr = new wxCursor(*result);
25417 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
25418 }
25419 return resultobj;
25420 fail:
25421 return NULL;
25422 }
25423
25424
25425 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25426 PyObject *resultobj = 0;
25427 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
25428 bool result;
25429 void *argp1 = 0 ;
25430 int res1 = 0 ;
25431 PyObject *swig_obj[1] ;
25432
25433 if (!args) SWIG_fail;
25434 swig_obj[0] = args;
25435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
25436 if (!SWIG_IsOK(res1)) {
25437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
25438 }
25439 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
25440 {
25441 PyThreadState* __tstate = wxPyBeginAllowThreads();
25442 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
25443 wxPyEndAllowThreads(__tstate);
25444 if (PyErr_Occurred()) SWIG_fail;
25445 }
25446 {
25447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25448 }
25449 return resultobj;
25450 fail:
25451 return NULL;
25452 }
25453
25454
25455 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25456 PyObject *obj;
25457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25458 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
25459 return SWIG_Py_Void();
25460 }
25461
25462 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25463 return SWIG_Python_InitShadowInstance(args);
25464 }
25465
25466 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25467 PyObject *resultobj = 0;
25468 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25469 wxKeyEvent *result = 0 ;
25470 int val1 ;
25471 int ecode1 = 0 ;
25472 PyObject * obj0 = 0 ;
25473 char * kwnames[] = {
25474 (char *) "eventType", NULL
25475 };
25476
25477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
25478 if (obj0) {
25479 ecode1 = SWIG_AsVal_int(obj0, &val1);
25480 if (!SWIG_IsOK(ecode1)) {
25481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
25482 }
25483 arg1 = static_cast< wxEventType >(val1);
25484 }
25485 {
25486 PyThreadState* __tstate = wxPyBeginAllowThreads();
25487 result = (wxKeyEvent *)new wxKeyEvent(arg1);
25488 wxPyEndAllowThreads(__tstate);
25489 if (PyErr_Occurred()) SWIG_fail;
25490 }
25491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
25492 return resultobj;
25493 fail:
25494 return NULL;
25495 }
25496
25497
25498 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25499 PyObject *resultobj = 0;
25500 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25501 int result;
25502 void *argp1 = 0 ;
25503 int res1 = 0 ;
25504 PyObject *swig_obj[1] ;
25505
25506 if (!args) SWIG_fail;
25507 swig_obj[0] = args;
25508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25509 if (!SWIG_IsOK(res1)) {
25510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25511 }
25512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25513 {
25514 PyThreadState* __tstate = wxPyBeginAllowThreads();
25515 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
25516 wxPyEndAllowThreads(__tstate);
25517 if (PyErr_Occurred()) SWIG_fail;
25518 }
25519 resultobj = SWIG_From_int(static_cast< int >(result));
25520 return resultobj;
25521 fail:
25522 return NULL;
25523 }
25524
25525
25526 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25527 PyObject *resultobj = 0;
25528 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25529 bool result;
25530 void *argp1 = 0 ;
25531 int res1 = 0 ;
25532 PyObject *swig_obj[1] ;
25533
25534 if (!args) SWIG_fail;
25535 swig_obj[0] = args;
25536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25537 if (!SWIG_IsOK(res1)) {
25538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25539 }
25540 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25541 {
25542 PyThreadState* __tstate = wxPyBeginAllowThreads();
25543 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
25544 wxPyEndAllowThreads(__tstate);
25545 if (PyErr_Occurred()) SWIG_fail;
25546 }
25547 {
25548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25549 }
25550 return resultobj;
25551 fail:
25552 return NULL;
25553 }
25554
25555
25556 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25557 PyObject *resultobj = 0;
25558 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25559 bool result;
25560 void *argp1 = 0 ;
25561 int res1 = 0 ;
25562 PyObject *swig_obj[1] ;
25563
25564 if (!args) SWIG_fail;
25565 swig_obj[0] = args;
25566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25567 if (!SWIG_IsOK(res1)) {
25568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25569 }
25570 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25571 {
25572 PyThreadState* __tstate = wxPyBeginAllowThreads();
25573 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25574 wxPyEndAllowThreads(__tstate);
25575 if (PyErr_Occurred()) SWIG_fail;
25576 }
25577 {
25578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25579 }
25580 return resultobj;
25581 fail:
25582 return NULL;
25583 }
25584
25585
25586 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25589 bool result;
25590 void *argp1 = 0 ;
25591 int res1 = 0 ;
25592 PyObject *swig_obj[1] ;
25593
25594 if (!args) SWIG_fail;
25595 swig_obj[0] = args;
25596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25597 if (!SWIG_IsOK(res1)) {
25598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25599 }
25600 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25601 {
25602 PyThreadState* __tstate = wxPyBeginAllowThreads();
25603 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25604 wxPyEndAllowThreads(__tstate);
25605 if (PyErr_Occurred()) SWIG_fail;
25606 }
25607 {
25608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25609 }
25610 return resultobj;
25611 fail:
25612 return NULL;
25613 }
25614
25615
25616 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25617 PyObject *resultobj = 0;
25618 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25619 bool result;
25620 void *argp1 = 0 ;
25621 int res1 = 0 ;
25622 PyObject *swig_obj[1] ;
25623
25624 if (!args) SWIG_fail;
25625 swig_obj[0] = args;
25626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25627 if (!SWIG_IsOK(res1)) {
25628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25629 }
25630 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25631 {
25632 PyThreadState* __tstate = wxPyBeginAllowThreads();
25633 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25634 wxPyEndAllowThreads(__tstate);
25635 if (PyErr_Occurred()) SWIG_fail;
25636 }
25637 {
25638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25639 }
25640 return resultobj;
25641 fail:
25642 return NULL;
25643 }
25644
25645
25646 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25647 PyObject *resultobj = 0;
25648 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25649 bool result;
25650 void *argp1 = 0 ;
25651 int res1 = 0 ;
25652 PyObject *swig_obj[1] ;
25653
25654 if (!args) SWIG_fail;
25655 swig_obj[0] = args;
25656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25659 }
25660 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25661 {
25662 PyThreadState* __tstate = wxPyBeginAllowThreads();
25663 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25664 wxPyEndAllowThreads(__tstate);
25665 if (PyErr_Occurred()) SWIG_fail;
25666 }
25667 {
25668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25669 }
25670 return resultobj;
25671 fail:
25672 return NULL;
25673 }
25674
25675
25676 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25677 PyObject *resultobj = 0;
25678 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25679 bool result;
25680 void *argp1 = 0 ;
25681 int res1 = 0 ;
25682 PyObject *swig_obj[1] ;
25683
25684 if (!args) SWIG_fail;
25685 swig_obj[0] = args;
25686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25687 if (!SWIG_IsOK(res1)) {
25688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25689 }
25690 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25691 {
25692 PyThreadState* __tstate = wxPyBeginAllowThreads();
25693 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25694 wxPyEndAllowThreads(__tstate);
25695 if (PyErr_Occurred()) SWIG_fail;
25696 }
25697 {
25698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25699 }
25700 return resultobj;
25701 fail:
25702 return NULL;
25703 }
25704
25705
25706 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25707 PyObject *resultobj = 0;
25708 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25709 int result;
25710 void *argp1 = 0 ;
25711 int res1 = 0 ;
25712 PyObject *swig_obj[1] ;
25713
25714 if (!args) SWIG_fail;
25715 swig_obj[0] = args;
25716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25717 if (!SWIG_IsOK(res1)) {
25718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25719 }
25720 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25724 wxPyEndAllowThreads(__tstate);
25725 if (PyErr_Occurred()) SWIG_fail;
25726 }
25727 resultobj = SWIG_From_int(static_cast< int >(result));
25728 return resultobj;
25729 fail:
25730 return NULL;
25731 }
25732
25733
25734 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25735 PyObject *resultobj = 0;
25736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25737 int result;
25738 void *argp1 = 0 ;
25739 int res1 = 0 ;
25740 PyObject *swig_obj[1] ;
25741
25742 if (!args) SWIG_fail;
25743 swig_obj[0] = args;
25744 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25745 if (!SWIG_IsOK(res1)) {
25746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25747 }
25748 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25749 {
25750 PyThreadState* __tstate = wxPyBeginAllowThreads();
25751 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25752 wxPyEndAllowThreads(__tstate);
25753 if (PyErr_Occurred()) SWIG_fail;
25754 }
25755 resultobj = SWIG_From_int(static_cast< int >(result));
25756 return resultobj;
25757 fail:
25758 return NULL;
25759 }
25760
25761
25762 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25763 PyObject *resultobj = 0;
25764 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25765 int arg2 ;
25766 void *argp1 = 0 ;
25767 int res1 = 0 ;
25768 int val2 ;
25769 int ecode2 = 0 ;
25770 PyObject * obj0 = 0 ;
25771 PyObject * obj1 = 0 ;
25772 char * kwnames[] = {
25773 (char *) "self",(char *) "uniChar", NULL
25774 };
25775
25776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25778 if (!SWIG_IsOK(res1)) {
25779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25780 }
25781 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25782 ecode2 = SWIG_AsVal_int(obj1, &val2);
25783 if (!SWIG_IsOK(ecode2)) {
25784 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25785 }
25786 arg2 = static_cast< int >(val2);
25787 {
25788 PyThreadState* __tstate = wxPyBeginAllowThreads();
25789 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25790 wxPyEndAllowThreads(__tstate);
25791 if (PyErr_Occurred()) SWIG_fail;
25792 }
25793 resultobj = SWIG_Py_Void();
25794 return resultobj;
25795 fail:
25796 return NULL;
25797 }
25798
25799
25800 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25801 PyObject *resultobj = 0;
25802 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25803 unsigned int result;
25804 void *argp1 = 0 ;
25805 int res1 = 0 ;
25806 PyObject *swig_obj[1] ;
25807
25808 if (!args) SWIG_fail;
25809 swig_obj[0] = args;
25810 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25811 if (!SWIG_IsOK(res1)) {
25812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25813 }
25814 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25815 {
25816 PyThreadState* __tstate = wxPyBeginAllowThreads();
25817 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25818 wxPyEndAllowThreads(__tstate);
25819 if (PyErr_Occurred()) SWIG_fail;
25820 }
25821 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25822 return resultobj;
25823 fail:
25824 return NULL;
25825 }
25826
25827
25828 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25829 PyObject *resultobj = 0;
25830 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25831 unsigned int result;
25832 void *argp1 = 0 ;
25833 int res1 = 0 ;
25834 PyObject *swig_obj[1] ;
25835
25836 if (!args) SWIG_fail;
25837 swig_obj[0] = args;
25838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25839 if (!SWIG_IsOK(res1)) {
25840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25841 }
25842 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25843 {
25844 PyThreadState* __tstate = wxPyBeginAllowThreads();
25845 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25846 wxPyEndAllowThreads(__tstate);
25847 if (PyErr_Occurred()) SWIG_fail;
25848 }
25849 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25850 return resultobj;
25851 fail:
25852 return NULL;
25853 }
25854
25855
25856 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25857 PyObject *resultobj = 0;
25858 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25859 wxPoint result;
25860 void *argp1 = 0 ;
25861 int res1 = 0 ;
25862 PyObject *swig_obj[1] ;
25863
25864 if (!args) SWIG_fail;
25865 swig_obj[0] = args;
25866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25867 if (!SWIG_IsOK(res1)) {
25868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25869 }
25870 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25871 {
25872 PyThreadState* __tstate = wxPyBeginAllowThreads();
25873 result = (arg1)->GetPosition();
25874 wxPyEndAllowThreads(__tstate);
25875 if (PyErr_Occurred()) SWIG_fail;
25876 }
25877 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25878 return resultobj;
25879 fail:
25880 return NULL;
25881 }
25882
25883
25884 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 PyObject *resultobj = 0;
25886 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25887 long *arg2 = (long *) 0 ;
25888 long *arg3 = (long *) 0 ;
25889 void *argp1 = 0 ;
25890 int res1 = 0 ;
25891 long temp2 ;
25892 int res2 = SWIG_TMPOBJ ;
25893 long temp3 ;
25894 int res3 = SWIG_TMPOBJ ;
25895 PyObject *swig_obj[1] ;
25896
25897 arg2 = &temp2;
25898 arg3 = &temp3;
25899 if (!args) SWIG_fail;
25900 swig_obj[0] = args;
25901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25902 if (!SWIG_IsOK(res1)) {
25903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25904 }
25905 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25906 {
25907 PyThreadState* __tstate = wxPyBeginAllowThreads();
25908 (arg1)->GetPosition(arg2,arg3);
25909 wxPyEndAllowThreads(__tstate);
25910 if (PyErr_Occurred()) SWIG_fail;
25911 }
25912 resultobj = SWIG_Py_Void();
25913 if (SWIG_IsTmpObj(res2)) {
25914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25915 } else {
25916 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25918 }
25919 if (SWIG_IsTmpObj(res3)) {
25920 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25921 } else {
25922 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25923 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25924 }
25925 return resultobj;
25926 fail:
25927 return NULL;
25928 }
25929
25930
25931 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25932 PyObject *resultobj = 0;
25933 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25934 int result;
25935 void *argp1 = 0 ;
25936 int res1 = 0 ;
25937 PyObject *swig_obj[1] ;
25938
25939 if (!args) SWIG_fail;
25940 swig_obj[0] = args;
25941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25942 if (!SWIG_IsOK(res1)) {
25943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25944 }
25945 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25946 {
25947 PyThreadState* __tstate = wxPyBeginAllowThreads();
25948 result = (int)((wxKeyEvent const *)arg1)->GetX();
25949 wxPyEndAllowThreads(__tstate);
25950 if (PyErr_Occurred()) SWIG_fail;
25951 }
25952 resultobj = SWIG_From_int(static_cast< int >(result));
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25960 PyObject *resultobj = 0;
25961 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25962 int result;
25963 void *argp1 = 0 ;
25964 int res1 = 0 ;
25965 PyObject *swig_obj[1] ;
25966
25967 if (!args) SWIG_fail;
25968 swig_obj[0] = args;
25969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25970 if (!SWIG_IsOK(res1)) {
25971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25972 }
25973 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25974 {
25975 PyThreadState* __tstate = wxPyBeginAllowThreads();
25976 result = (int)((wxKeyEvent const *)arg1)->GetY();
25977 wxPyEndAllowThreads(__tstate);
25978 if (PyErr_Occurred()) SWIG_fail;
25979 }
25980 resultobj = SWIG_From_int(static_cast< int >(result));
25981 return resultobj;
25982 fail:
25983 return NULL;
25984 }
25985
25986
25987 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25988 PyObject *resultobj = 0;
25989 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25990 int arg2 ;
25991 void *argp1 = 0 ;
25992 int res1 = 0 ;
25993 int val2 ;
25994 int ecode2 = 0 ;
25995 PyObject *swig_obj[2] ;
25996
25997 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25999 if (!SWIG_IsOK(res1)) {
26000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26001 }
26002 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26003 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26004 if (!SWIG_IsOK(ecode2)) {
26005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
26006 }
26007 arg2 = static_cast< int >(val2);
26008 if (arg1) (arg1)->m_x = arg2;
26009
26010 resultobj = SWIG_Py_Void();
26011 return resultobj;
26012 fail:
26013 return NULL;
26014 }
26015
26016
26017 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26018 PyObject *resultobj = 0;
26019 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26020 int result;
26021 void *argp1 = 0 ;
26022 int res1 = 0 ;
26023 PyObject *swig_obj[1] ;
26024
26025 if (!args) SWIG_fail;
26026 swig_obj[0] = args;
26027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26028 if (!SWIG_IsOK(res1)) {
26029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26030 }
26031 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26032 result = (int) ((arg1)->m_x);
26033 resultobj = SWIG_From_int(static_cast< int >(result));
26034 return resultobj;
26035 fail:
26036 return NULL;
26037 }
26038
26039
26040 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26041 PyObject *resultobj = 0;
26042 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26043 int arg2 ;
26044 void *argp1 = 0 ;
26045 int res1 = 0 ;
26046 int val2 ;
26047 int ecode2 = 0 ;
26048 PyObject *swig_obj[2] ;
26049
26050 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
26051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26052 if (!SWIG_IsOK(res1)) {
26053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26054 }
26055 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26056 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
26057 if (!SWIG_IsOK(ecode2)) {
26058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
26059 }
26060 arg2 = static_cast< int >(val2);
26061 if (arg1) (arg1)->m_y = arg2;
26062
26063 resultobj = SWIG_Py_Void();
26064 return resultobj;
26065 fail:
26066 return NULL;
26067 }
26068
26069
26070 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26071 PyObject *resultobj = 0;
26072 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26073 int result;
26074 void *argp1 = 0 ;
26075 int res1 = 0 ;
26076 PyObject *swig_obj[1] ;
26077
26078 if (!args) SWIG_fail;
26079 swig_obj[0] = args;
26080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26081 if (!SWIG_IsOK(res1)) {
26082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26083 }
26084 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26085 result = (int) ((arg1)->m_y);
26086 resultobj = SWIG_From_int(static_cast< int >(result));
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26094 PyObject *resultobj = 0;
26095 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26096 long arg2 ;
26097 void *argp1 = 0 ;
26098 int res1 = 0 ;
26099 long val2 ;
26100 int ecode2 = 0 ;
26101 PyObject *swig_obj[2] ;
26102
26103 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
26104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26105 if (!SWIG_IsOK(res1)) {
26106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26107 }
26108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26109 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
26110 if (!SWIG_IsOK(ecode2)) {
26111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
26112 }
26113 arg2 = static_cast< long >(val2);
26114 if (arg1) (arg1)->m_keyCode = arg2;
26115
26116 resultobj = SWIG_Py_Void();
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26124 PyObject *resultobj = 0;
26125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26126 long result;
26127 void *argp1 = 0 ;
26128 int res1 = 0 ;
26129 PyObject *swig_obj[1] ;
26130
26131 if (!args) SWIG_fail;
26132 swig_obj[0] = args;
26133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26134 if (!SWIG_IsOK(res1)) {
26135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26136 }
26137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26138 result = (long) ((arg1)->m_keyCode);
26139 resultobj = SWIG_From_long(static_cast< long >(result));
26140 return resultobj;
26141 fail:
26142 return NULL;
26143 }
26144
26145
26146 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26147 PyObject *resultobj = 0;
26148 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26149 bool arg2 ;
26150 void *argp1 = 0 ;
26151 int res1 = 0 ;
26152 bool val2 ;
26153 int ecode2 = 0 ;
26154 PyObject *swig_obj[2] ;
26155
26156 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
26157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26158 if (!SWIG_IsOK(res1)) {
26159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26160 }
26161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26162 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26163 if (!SWIG_IsOK(ecode2)) {
26164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
26165 }
26166 arg2 = static_cast< bool >(val2);
26167 if (arg1) (arg1)->m_controlDown = arg2;
26168
26169 resultobj = SWIG_Py_Void();
26170 return resultobj;
26171 fail:
26172 return NULL;
26173 }
26174
26175
26176 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26177 PyObject *resultobj = 0;
26178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26179 bool result;
26180 void *argp1 = 0 ;
26181 int res1 = 0 ;
26182 PyObject *swig_obj[1] ;
26183
26184 if (!args) SWIG_fail;
26185 swig_obj[0] = args;
26186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26187 if (!SWIG_IsOK(res1)) {
26188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26189 }
26190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26191 result = (bool) ((arg1)->m_controlDown);
26192 {
26193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26194 }
26195 return resultobj;
26196 fail:
26197 return NULL;
26198 }
26199
26200
26201 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26202 PyObject *resultobj = 0;
26203 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26204 bool arg2 ;
26205 void *argp1 = 0 ;
26206 int res1 = 0 ;
26207 bool val2 ;
26208 int ecode2 = 0 ;
26209 PyObject *swig_obj[2] ;
26210
26211 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
26212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26213 if (!SWIG_IsOK(res1)) {
26214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26215 }
26216 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26217 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26218 if (!SWIG_IsOK(ecode2)) {
26219 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
26220 }
26221 arg2 = static_cast< bool >(val2);
26222 if (arg1) (arg1)->m_shiftDown = arg2;
26223
26224 resultobj = SWIG_Py_Void();
26225 return resultobj;
26226 fail:
26227 return NULL;
26228 }
26229
26230
26231 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26232 PyObject *resultobj = 0;
26233 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26234 bool result;
26235 void *argp1 = 0 ;
26236 int res1 = 0 ;
26237 PyObject *swig_obj[1] ;
26238
26239 if (!args) SWIG_fail;
26240 swig_obj[0] = args;
26241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26242 if (!SWIG_IsOK(res1)) {
26243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26244 }
26245 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26246 result = (bool) ((arg1)->m_shiftDown);
26247 {
26248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26249 }
26250 return resultobj;
26251 fail:
26252 return NULL;
26253 }
26254
26255
26256 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26257 PyObject *resultobj = 0;
26258 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26259 bool arg2 ;
26260 void *argp1 = 0 ;
26261 int res1 = 0 ;
26262 bool val2 ;
26263 int ecode2 = 0 ;
26264 PyObject *swig_obj[2] ;
26265
26266 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
26267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26268 if (!SWIG_IsOK(res1)) {
26269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26270 }
26271 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26272 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26273 if (!SWIG_IsOK(ecode2)) {
26274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
26275 }
26276 arg2 = static_cast< bool >(val2);
26277 if (arg1) (arg1)->m_altDown = arg2;
26278
26279 resultobj = SWIG_Py_Void();
26280 return resultobj;
26281 fail:
26282 return NULL;
26283 }
26284
26285
26286 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26287 PyObject *resultobj = 0;
26288 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26289 bool result;
26290 void *argp1 = 0 ;
26291 int res1 = 0 ;
26292 PyObject *swig_obj[1] ;
26293
26294 if (!args) SWIG_fail;
26295 swig_obj[0] = args;
26296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26297 if (!SWIG_IsOK(res1)) {
26298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26299 }
26300 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26301 result = (bool) ((arg1)->m_altDown);
26302 {
26303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26304 }
26305 return resultobj;
26306 fail:
26307 return NULL;
26308 }
26309
26310
26311 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26312 PyObject *resultobj = 0;
26313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26314 bool arg2 ;
26315 void *argp1 = 0 ;
26316 int res1 = 0 ;
26317 bool val2 ;
26318 int ecode2 = 0 ;
26319 PyObject *swig_obj[2] ;
26320
26321 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
26322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26323 if (!SWIG_IsOK(res1)) {
26324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26325 }
26326 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26327 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26328 if (!SWIG_IsOK(ecode2)) {
26329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
26330 }
26331 arg2 = static_cast< bool >(val2);
26332 if (arg1) (arg1)->m_metaDown = arg2;
26333
26334 resultobj = SWIG_Py_Void();
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26342 PyObject *resultobj = 0;
26343 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26344 bool result;
26345 void *argp1 = 0 ;
26346 int res1 = 0 ;
26347 PyObject *swig_obj[1] ;
26348
26349 if (!args) SWIG_fail;
26350 swig_obj[0] = args;
26351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26352 if (!SWIG_IsOK(res1)) {
26353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26354 }
26355 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26356 result = (bool) ((arg1)->m_metaDown);
26357 {
26358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26359 }
26360 return resultobj;
26361 fail:
26362 return NULL;
26363 }
26364
26365
26366 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26367 PyObject *resultobj = 0;
26368 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26369 bool arg2 ;
26370 void *argp1 = 0 ;
26371 int res1 = 0 ;
26372 bool val2 ;
26373 int ecode2 = 0 ;
26374 PyObject *swig_obj[2] ;
26375
26376 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
26377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26378 if (!SWIG_IsOK(res1)) {
26379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26380 }
26381 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26382 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
26383 if (!SWIG_IsOK(ecode2)) {
26384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
26385 }
26386 arg2 = static_cast< bool >(val2);
26387 if (arg1) (arg1)->m_scanCode = arg2;
26388
26389 resultobj = SWIG_Py_Void();
26390 return resultobj;
26391 fail:
26392 return NULL;
26393 }
26394
26395
26396 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26397 PyObject *resultobj = 0;
26398 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26399 bool result;
26400 void *argp1 = 0 ;
26401 int res1 = 0 ;
26402 PyObject *swig_obj[1] ;
26403
26404 if (!args) SWIG_fail;
26405 swig_obj[0] = args;
26406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26407 if (!SWIG_IsOK(res1)) {
26408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26409 }
26410 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26411 result = (bool) ((arg1)->m_scanCode);
26412 {
26413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26414 }
26415 return resultobj;
26416 fail:
26417 return NULL;
26418 }
26419
26420
26421 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26422 PyObject *resultobj = 0;
26423 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26424 unsigned int arg2 ;
26425 void *argp1 = 0 ;
26426 int res1 = 0 ;
26427 unsigned int val2 ;
26428 int ecode2 = 0 ;
26429 PyObject *swig_obj[2] ;
26430
26431 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
26432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26433 if (!SWIG_IsOK(res1)) {
26434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26435 }
26436 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26437 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26438 if (!SWIG_IsOK(ecode2)) {
26439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
26440 }
26441 arg2 = static_cast< unsigned int >(val2);
26442 if (arg1) (arg1)->m_rawCode = arg2;
26443
26444 resultobj = SWIG_Py_Void();
26445 return resultobj;
26446 fail:
26447 return NULL;
26448 }
26449
26450
26451 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26452 PyObject *resultobj = 0;
26453 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26454 unsigned int result;
26455 void *argp1 = 0 ;
26456 int res1 = 0 ;
26457 PyObject *swig_obj[1] ;
26458
26459 if (!args) SWIG_fail;
26460 swig_obj[0] = args;
26461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26462 if (!SWIG_IsOK(res1)) {
26463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26464 }
26465 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26466 result = (unsigned int) ((arg1)->m_rawCode);
26467 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26468 return resultobj;
26469 fail:
26470 return NULL;
26471 }
26472
26473
26474 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26475 PyObject *resultobj = 0;
26476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26477 unsigned int arg2 ;
26478 void *argp1 = 0 ;
26479 int res1 = 0 ;
26480 unsigned int val2 ;
26481 int ecode2 = 0 ;
26482 PyObject *swig_obj[2] ;
26483
26484 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
26485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26486 if (!SWIG_IsOK(res1)) {
26487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26488 }
26489 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26490 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
26491 if (!SWIG_IsOK(ecode2)) {
26492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
26493 }
26494 arg2 = static_cast< unsigned int >(val2);
26495 if (arg1) (arg1)->m_rawFlags = arg2;
26496
26497 resultobj = SWIG_Py_Void();
26498 return resultobj;
26499 fail:
26500 return NULL;
26501 }
26502
26503
26504 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26505 PyObject *resultobj = 0;
26506 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
26507 unsigned int result;
26508 void *argp1 = 0 ;
26509 int res1 = 0 ;
26510 PyObject *swig_obj[1] ;
26511
26512 if (!args) SWIG_fail;
26513 swig_obj[0] = args;
26514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
26515 if (!SWIG_IsOK(res1)) {
26516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
26517 }
26518 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
26519 result = (unsigned int) ((arg1)->m_rawFlags);
26520 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
26521 return resultobj;
26522 fail:
26523 return NULL;
26524 }
26525
26526
26527 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26528 PyObject *obj;
26529 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26530 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
26531 return SWIG_Py_Void();
26532 }
26533
26534 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26535 return SWIG_Python_InitShadowInstance(args);
26536 }
26537
26538 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26539 PyObject *resultobj = 0;
26540 wxSize const &arg1_defvalue = wxDefaultSize ;
26541 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
26542 int arg2 = (int) 0 ;
26543 wxSizeEvent *result = 0 ;
26544 wxSize temp1 ;
26545 int val2 ;
26546 int ecode2 = 0 ;
26547 PyObject * obj0 = 0 ;
26548 PyObject * obj1 = 0 ;
26549 char * kwnames[] = {
26550 (char *) "sz",(char *) "winid", NULL
26551 };
26552
26553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26554 if (obj0) {
26555 {
26556 arg1 = &temp1;
26557 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26558 }
26559 }
26560 if (obj1) {
26561 ecode2 = SWIG_AsVal_int(obj1, &val2);
26562 if (!SWIG_IsOK(ecode2)) {
26563 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26564 }
26565 arg2 = static_cast< int >(val2);
26566 }
26567 {
26568 PyThreadState* __tstate = wxPyBeginAllowThreads();
26569 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26570 wxPyEndAllowThreads(__tstate);
26571 if (PyErr_Occurred()) SWIG_fail;
26572 }
26573 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26574 return resultobj;
26575 fail:
26576 return NULL;
26577 }
26578
26579
26580 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26581 PyObject *resultobj = 0;
26582 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26583 wxSize result;
26584 void *argp1 = 0 ;
26585 int res1 = 0 ;
26586 PyObject *swig_obj[1] ;
26587
26588 if (!args) SWIG_fail;
26589 swig_obj[0] = args;
26590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26591 if (!SWIG_IsOK(res1)) {
26592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26593 }
26594 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26595 {
26596 PyThreadState* __tstate = wxPyBeginAllowThreads();
26597 result = ((wxSizeEvent const *)arg1)->GetSize();
26598 wxPyEndAllowThreads(__tstate);
26599 if (PyErr_Occurred()) SWIG_fail;
26600 }
26601 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26602 return resultobj;
26603 fail:
26604 return NULL;
26605 }
26606
26607
26608 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26609 PyObject *resultobj = 0;
26610 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26611 wxRect result;
26612 void *argp1 = 0 ;
26613 int res1 = 0 ;
26614 PyObject *swig_obj[1] ;
26615
26616 if (!args) SWIG_fail;
26617 swig_obj[0] = args;
26618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26619 if (!SWIG_IsOK(res1)) {
26620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26621 }
26622 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26623 {
26624 PyThreadState* __tstate = wxPyBeginAllowThreads();
26625 result = ((wxSizeEvent const *)arg1)->GetRect();
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj = 0;
26638 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26639 wxRect arg2 ;
26640 void *argp1 = 0 ;
26641 int res1 = 0 ;
26642 void *argp2 ;
26643 int res2 = 0 ;
26644 PyObject * obj0 = 0 ;
26645 PyObject * obj1 = 0 ;
26646 char * kwnames[] = {
26647 (char *) "self",(char *) "rect", NULL
26648 };
26649
26650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26652 if (!SWIG_IsOK(res1)) {
26653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26654 }
26655 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26656 {
26657 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26658 if (!SWIG_IsOK(res2)) {
26659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26660 }
26661 if (!argp2) {
26662 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26663 } else {
26664 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26665 arg2 = *temp;
26666 if (SWIG_IsNewObj(res2)) delete temp;
26667 }
26668 }
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 (arg1)->SetRect(arg2);
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 resultobj = SWIG_Py_Void();
26676 return resultobj;
26677 fail:
26678 return NULL;
26679 }
26680
26681
26682 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26683 PyObject *resultobj = 0;
26684 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26685 wxSize arg2 ;
26686 void *argp1 = 0 ;
26687 int res1 = 0 ;
26688 void *argp2 ;
26689 int res2 = 0 ;
26690 PyObject * obj0 = 0 ;
26691 PyObject * obj1 = 0 ;
26692 char * kwnames[] = {
26693 (char *) "self",(char *) "size", NULL
26694 };
26695
26696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26698 if (!SWIG_IsOK(res1)) {
26699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26700 }
26701 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26702 {
26703 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26704 if (!SWIG_IsOK(res2)) {
26705 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26706 }
26707 if (!argp2) {
26708 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26709 } else {
26710 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26711 arg2 = *temp;
26712 if (SWIG_IsNewObj(res2)) delete temp;
26713 }
26714 }
26715 {
26716 PyThreadState* __tstate = wxPyBeginAllowThreads();
26717 wxSizeEvent_SetSize(arg1,arg2);
26718 wxPyEndAllowThreads(__tstate);
26719 if (PyErr_Occurred()) SWIG_fail;
26720 }
26721 resultobj = SWIG_Py_Void();
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26729 PyObject *resultobj = 0;
26730 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26731 wxSize *arg2 = (wxSize *) 0 ;
26732 void *argp1 = 0 ;
26733 int res1 = 0 ;
26734 void *argp2 = 0 ;
26735 int res2 = 0 ;
26736 PyObject *swig_obj[2] ;
26737
26738 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26739 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26740 if (!SWIG_IsOK(res1)) {
26741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26742 }
26743 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26744 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26745 if (!SWIG_IsOK(res2)) {
26746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26747 }
26748 arg2 = reinterpret_cast< wxSize * >(argp2);
26749 if (arg1) (arg1)->m_size = *arg2;
26750
26751 resultobj = SWIG_Py_Void();
26752 return resultobj;
26753 fail:
26754 return NULL;
26755 }
26756
26757
26758 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26759 PyObject *resultobj = 0;
26760 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26761 wxSize *result = 0 ;
26762 void *argp1 = 0 ;
26763 int res1 = 0 ;
26764 PyObject *swig_obj[1] ;
26765
26766 if (!args) SWIG_fail;
26767 swig_obj[0] = args;
26768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26769 if (!SWIG_IsOK(res1)) {
26770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26771 }
26772 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26773 result = (wxSize *)& ((arg1)->m_size);
26774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26775 return resultobj;
26776 fail:
26777 return NULL;
26778 }
26779
26780
26781 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26782 PyObject *resultobj = 0;
26783 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26784 wxRect *arg2 = (wxRect *) 0 ;
26785 void *argp1 = 0 ;
26786 int res1 = 0 ;
26787 void *argp2 = 0 ;
26788 int res2 = 0 ;
26789 PyObject *swig_obj[2] ;
26790
26791 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26793 if (!SWIG_IsOK(res1)) {
26794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26795 }
26796 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26797 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26798 if (!SWIG_IsOK(res2)) {
26799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26800 }
26801 arg2 = reinterpret_cast< wxRect * >(argp2);
26802 if (arg1) (arg1)->m_rect = *arg2;
26803
26804 resultobj = SWIG_Py_Void();
26805 return resultobj;
26806 fail:
26807 return NULL;
26808 }
26809
26810
26811 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26812 PyObject *resultobj = 0;
26813 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26814 wxRect *result = 0 ;
26815 void *argp1 = 0 ;
26816 int res1 = 0 ;
26817 PyObject *swig_obj[1] ;
26818
26819 if (!args) SWIG_fail;
26820 swig_obj[0] = args;
26821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26824 }
26825 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26826 result = (wxRect *)& ((arg1)->m_rect);
26827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26835 PyObject *obj;
26836 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26837 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26838 return SWIG_Py_Void();
26839 }
26840
26841 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26842 return SWIG_Python_InitShadowInstance(args);
26843 }
26844
26845 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26846 PyObject *resultobj = 0;
26847 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26848 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26849 int arg2 = (int) 0 ;
26850 wxMoveEvent *result = 0 ;
26851 wxPoint temp1 ;
26852 int val2 ;
26853 int ecode2 = 0 ;
26854 PyObject * obj0 = 0 ;
26855 PyObject * obj1 = 0 ;
26856 char * kwnames[] = {
26857 (char *) "pos",(char *) "winid", NULL
26858 };
26859
26860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26861 if (obj0) {
26862 {
26863 arg1 = &temp1;
26864 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26865 }
26866 }
26867 if (obj1) {
26868 ecode2 = SWIG_AsVal_int(obj1, &val2);
26869 if (!SWIG_IsOK(ecode2)) {
26870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26871 }
26872 arg2 = static_cast< int >(val2);
26873 }
26874 {
26875 PyThreadState* __tstate = wxPyBeginAllowThreads();
26876 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26877 wxPyEndAllowThreads(__tstate);
26878 if (PyErr_Occurred()) SWIG_fail;
26879 }
26880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26881 return resultobj;
26882 fail:
26883 return NULL;
26884 }
26885
26886
26887 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26888 PyObject *resultobj = 0;
26889 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26890 wxPoint result;
26891 void *argp1 = 0 ;
26892 int res1 = 0 ;
26893 PyObject *swig_obj[1] ;
26894
26895 if (!args) SWIG_fail;
26896 swig_obj[0] = args;
26897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26898 if (!SWIG_IsOK(res1)) {
26899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26900 }
26901 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26902 {
26903 PyThreadState* __tstate = wxPyBeginAllowThreads();
26904 result = ((wxMoveEvent const *)arg1)->GetPosition();
26905 wxPyEndAllowThreads(__tstate);
26906 if (PyErr_Occurred()) SWIG_fail;
26907 }
26908 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26909 return resultobj;
26910 fail:
26911 return NULL;
26912 }
26913
26914
26915 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26916 PyObject *resultobj = 0;
26917 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26918 wxRect result;
26919 void *argp1 = 0 ;
26920 int res1 = 0 ;
26921 PyObject *swig_obj[1] ;
26922
26923 if (!args) SWIG_fail;
26924 swig_obj[0] = args;
26925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26926 if (!SWIG_IsOK(res1)) {
26927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26928 }
26929 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 result = ((wxMoveEvent const *)arg1)->GetRect();
26933 wxPyEndAllowThreads(__tstate);
26934 if (PyErr_Occurred()) SWIG_fail;
26935 }
26936 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26937 return resultobj;
26938 fail:
26939 return NULL;
26940 }
26941
26942
26943 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26944 PyObject *resultobj = 0;
26945 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26946 wxRect *arg2 = 0 ;
26947 void *argp1 = 0 ;
26948 int res1 = 0 ;
26949 wxRect temp2 ;
26950 PyObject * obj0 = 0 ;
26951 PyObject * obj1 = 0 ;
26952 char * kwnames[] = {
26953 (char *) "self",(char *) "rect", NULL
26954 };
26955
26956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26958 if (!SWIG_IsOK(res1)) {
26959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26960 }
26961 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26962 {
26963 arg2 = &temp2;
26964 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26965 }
26966 {
26967 PyThreadState* __tstate = wxPyBeginAllowThreads();
26968 (arg1)->SetRect((wxRect const &)*arg2);
26969 wxPyEndAllowThreads(__tstate);
26970 if (PyErr_Occurred()) SWIG_fail;
26971 }
26972 resultobj = SWIG_Py_Void();
26973 return resultobj;
26974 fail:
26975 return NULL;
26976 }
26977
26978
26979 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26980 PyObject *resultobj = 0;
26981 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26982 wxPoint *arg2 = 0 ;
26983 void *argp1 = 0 ;
26984 int res1 = 0 ;
26985 wxPoint temp2 ;
26986 PyObject * obj0 = 0 ;
26987 PyObject * obj1 = 0 ;
26988 char * kwnames[] = {
26989 (char *) "self",(char *) "pos", NULL
26990 };
26991
26992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26994 if (!SWIG_IsOK(res1)) {
26995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26996 }
26997 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26998 {
26999 arg2 = &temp2;
27000 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
27001 }
27002 {
27003 PyThreadState* __tstate = wxPyBeginAllowThreads();
27004 (arg1)->SetPosition((wxPoint const &)*arg2);
27005 wxPyEndAllowThreads(__tstate);
27006 if (PyErr_Occurred()) SWIG_fail;
27007 }
27008 resultobj = SWIG_Py_Void();
27009 return resultobj;
27010 fail:
27011 return NULL;
27012 }
27013
27014
27015 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27016 PyObject *obj;
27017 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27018 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
27019 return SWIG_Py_Void();
27020 }
27021
27022 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27023 return SWIG_Python_InitShadowInstance(args);
27024 }
27025
27026 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27027 PyObject *resultobj = 0;
27028 int arg1 = (int) 0 ;
27029 wxPaintEvent *result = 0 ;
27030 int val1 ;
27031 int ecode1 = 0 ;
27032 PyObject * obj0 = 0 ;
27033 char * kwnames[] = {
27034 (char *) "Id", NULL
27035 };
27036
27037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
27038 if (obj0) {
27039 ecode1 = SWIG_AsVal_int(obj0, &val1);
27040 if (!SWIG_IsOK(ecode1)) {
27041 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
27042 }
27043 arg1 = static_cast< int >(val1);
27044 }
27045 {
27046 PyThreadState* __tstate = wxPyBeginAllowThreads();
27047 result = (wxPaintEvent *)new wxPaintEvent(arg1);
27048 wxPyEndAllowThreads(__tstate);
27049 if (PyErr_Occurred()) SWIG_fail;
27050 }
27051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
27052 return resultobj;
27053 fail:
27054 return NULL;
27055 }
27056
27057
27058 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27059 PyObject *obj;
27060 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27061 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
27062 return SWIG_Py_Void();
27063 }
27064
27065 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27066 return SWIG_Python_InitShadowInstance(args);
27067 }
27068
27069 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27070 PyObject *resultobj = 0;
27071 int arg1 = (int) 0 ;
27072 wxNcPaintEvent *result = 0 ;
27073 int val1 ;
27074 int ecode1 = 0 ;
27075 PyObject * obj0 = 0 ;
27076 char * kwnames[] = {
27077 (char *) "winid", NULL
27078 };
27079
27080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
27081 if (obj0) {
27082 ecode1 = SWIG_AsVal_int(obj0, &val1);
27083 if (!SWIG_IsOK(ecode1)) {
27084 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
27085 }
27086 arg1 = static_cast< int >(val1);
27087 }
27088 {
27089 PyThreadState* __tstate = wxPyBeginAllowThreads();
27090 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
27091 wxPyEndAllowThreads(__tstate);
27092 if (PyErr_Occurred()) SWIG_fail;
27093 }
27094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
27095 return resultobj;
27096 fail:
27097 return NULL;
27098 }
27099
27100
27101 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27102 PyObject *obj;
27103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27104 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
27105 return SWIG_Py_Void();
27106 }
27107
27108 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27109 return SWIG_Python_InitShadowInstance(args);
27110 }
27111
27112 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj = 0;
27114 int arg1 = (int) 0 ;
27115 wxDC *arg2 = (wxDC *) NULL ;
27116 wxEraseEvent *result = 0 ;
27117 int val1 ;
27118 int ecode1 = 0 ;
27119 void *argp2 = 0 ;
27120 int res2 = 0 ;
27121 PyObject * obj0 = 0 ;
27122 PyObject * obj1 = 0 ;
27123 char * kwnames[] = {
27124 (char *) "Id",(char *) "dc", NULL
27125 };
27126
27127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27128 if (obj0) {
27129 ecode1 = SWIG_AsVal_int(obj0, &val1);
27130 if (!SWIG_IsOK(ecode1)) {
27131 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
27132 }
27133 arg1 = static_cast< int >(val1);
27134 }
27135 if (obj1) {
27136 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
27137 if (!SWIG_IsOK(res2)) {
27138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
27139 }
27140 arg2 = reinterpret_cast< wxDC * >(argp2);
27141 }
27142 {
27143 PyThreadState* __tstate = wxPyBeginAllowThreads();
27144 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
27145 wxPyEndAllowThreads(__tstate);
27146 if (PyErr_Occurred()) SWIG_fail;
27147 }
27148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
27149 return resultobj;
27150 fail:
27151 return NULL;
27152 }
27153
27154
27155 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27156 PyObject *resultobj = 0;
27157 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
27158 wxDC *result = 0 ;
27159 void *argp1 = 0 ;
27160 int res1 = 0 ;
27161 PyObject *swig_obj[1] ;
27162
27163 if (!args) SWIG_fail;
27164 swig_obj[0] = args;
27165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
27166 if (!SWIG_IsOK(res1)) {
27167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
27168 }
27169 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
27173 wxPyEndAllowThreads(__tstate);
27174 if (PyErr_Occurred()) SWIG_fail;
27175 }
27176 {
27177 resultobj = wxPyMake_wxObject(result, (bool)0);
27178 }
27179 return resultobj;
27180 fail:
27181 return NULL;
27182 }
27183
27184
27185 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27186 PyObject *obj;
27187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27188 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
27189 return SWIG_Py_Void();
27190 }
27191
27192 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27193 return SWIG_Python_InitShadowInstance(args);
27194 }
27195
27196 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27197 PyObject *resultobj = 0;
27198 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27199 int arg2 = (int) 0 ;
27200 wxFocusEvent *result = 0 ;
27201 int val1 ;
27202 int ecode1 = 0 ;
27203 int val2 ;
27204 int ecode2 = 0 ;
27205 PyObject * obj0 = 0 ;
27206 PyObject * obj1 = 0 ;
27207 char * kwnames[] = {
27208 (char *) "type",(char *) "winid", NULL
27209 };
27210
27211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27212 if (obj0) {
27213 ecode1 = SWIG_AsVal_int(obj0, &val1);
27214 if (!SWIG_IsOK(ecode1)) {
27215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27216 }
27217 arg1 = static_cast< wxEventType >(val1);
27218 }
27219 if (obj1) {
27220 ecode2 = SWIG_AsVal_int(obj1, &val2);
27221 if (!SWIG_IsOK(ecode2)) {
27222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
27223 }
27224 arg2 = static_cast< int >(val2);
27225 }
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
27229 wxPyEndAllowThreads(__tstate);
27230 if (PyErr_Occurred()) SWIG_fail;
27231 }
27232 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
27233 return resultobj;
27234 fail:
27235 return NULL;
27236 }
27237
27238
27239 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27240 PyObject *resultobj = 0;
27241 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27242 wxWindow *result = 0 ;
27243 void *argp1 = 0 ;
27244 int res1 = 0 ;
27245 PyObject *swig_obj[1] ;
27246
27247 if (!args) SWIG_fail;
27248 swig_obj[0] = args;
27249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27250 if (!SWIG_IsOK(res1)) {
27251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
27252 }
27253 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27254 {
27255 PyThreadState* __tstate = wxPyBeginAllowThreads();
27256 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
27257 wxPyEndAllowThreads(__tstate);
27258 if (PyErr_Occurred()) SWIG_fail;
27259 }
27260 {
27261 resultobj = wxPyMake_wxObject(result, (bool)0);
27262 }
27263 return resultobj;
27264 fail:
27265 return NULL;
27266 }
27267
27268
27269 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27270 PyObject *resultobj = 0;
27271 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
27272 wxWindow *arg2 = (wxWindow *) 0 ;
27273 void *argp1 = 0 ;
27274 int res1 = 0 ;
27275 void *argp2 = 0 ;
27276 int res2 = 0 ;
27277 PyObject * obj0 = 0 ;
27278 PyObject * obj1 = 0 ;
27279 char * kwnames[] = {
27280 (char *) "self",(char *) "win", NULL
27281 };
27282
27283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
27285 if (!SWIG_IsOK(res1)) {
27286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
27287 }
27288 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
27289 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27290 if (!SWIG_IsOK(res2)) {
27291 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27292 }
27293 arg2 = reinterpret_cast< wxWindow * >(argp2);
27294 {
27295 PyThreadState* __tstate = wxPyBeginAllowThreads();
27296 (arg1)->SetWindow(arg2);
27297 wxPyEndAllowThreads(__tstate);
27298 if (PyErr_Occurred()) SWIG_fail;
27299 }
27300 resultobj = SWIG_Py_Void();
27301 return resultobj;
27302 fail:
27303 return NULL;
27304 }
27305
27306
27307 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27308 PyObject *obj;
27309 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27310 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
27311 return SWIG_Py_Void();
27312 }
27313
27314 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27315 return SWIG_Python_InitShadowInstance(args);
27316 }
27317
27318 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27319 PyObject *resultobj = 0;
27320 wxWindow *arg1 = (wxWindow *) NULL ;
27321 wxChildFocusEvent *result = 0 ;
27322 void *argp1 = 0 ;
27323 int res1 = 0 ;
27324 PyObject * obj0 = 0 ;
27325 char * kwnames[] = {
27326 (char *) "win", NULL
27327 };
27328
27329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
27330 if (obj0) {
27331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
27332 if (!SWIG_IsOK(res1)) {
27333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
27334 }
27335 arg1 = reinterpret_cast< wxWindow * >(argp1);
27336 }
27337 {
27338 PyThreadState* __tstate = wxPyBeginAllowThreads();
27339 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
27340 wxPyEndAllowThreads(__tstate);
27341 if (PyErr_Occurred()) SWIG_fail;
27342 }
27343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27351 PyObject *resultobj = 0;
27352 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
27353 wxWindow *result = 0 ;
27354 void *argp1 = 0 ;
27355 int res1 = 0 ;
27356 PyObject *swig_obj[1] ;
27357
27358 if (!args) SWIG_fail;
27359 swig_obj[0] = args;
27360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
27361 if (!SWIG_IsOK(res1)) {
27362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
27363 }
27364 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
27365 {
27366 PyThreadState* __tstate = wxPyBeginAllowThreads();
27367 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
27368 wxPyEndAllowThreads(__tstate);
27369 if (PyErr_Occurred()) SWIG_fail;
27370 }
27371 {
27372 resultobj = wxPyMake_wxObject(result, (bool)0);
27373 }
27374 return resultobj;
27375 fail:
27376 return NULL;
27377 }
27378
27379
27380 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27381 PyObject *obj;
27382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27383 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
27384 return SWIG_Py_Void();
27385 }
27386
27387 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27388 return SWIG_Python_InitShadowInstance(args);
27389 }
27390
27391 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27392 PyObject *resultobj = 0;
27393 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27394 bool arg2 = (bool) true ;
27395 int arg3 = (int) 0 ;
27396 wxActivateEvent *result = 0 ;
27397 int val1 ;
27398 int ecode1 = 0 ;
27399 bool val2 ;
27400 int ecode2 = 0 ;
27401 int val3 ;
27402 int ecode3 = 0 ;
27403 PyObject * obj0 = 0 ;
27404 PyObject * obj1 = 0 ;
27405 PyObject * obj2 = 0 ;
27406 char * kwnames[] = {
27407 (char *) "type",(char *) "active",(char *) "Id", NULL
27408 };
27409
27410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27411 if (obj0) {
27412 ecode1 = SWIG_AsVal_int(obj0, &val1);
27413 if (!SWIG_IsOK(ecode1)) {
27414 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27415 }
27416 arg1 = static_cast< wxEventType >(val1);
27417 }
27418 if (obj1) {
27419 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27420 if (!SWIG_IsOK(ecode2)) {
27421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
27422 }
27423 arg2 = static_cast< bool >(val2);
27424 }
27425 if (obj2) {
27426 ecode3 = SWIG_AsVal_int(obj2, &val3);
27427 if (!SWIG_IsOK(ecode3)) {
27428 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
27429 }
27430 arg3 = static_cast< int >(val3);
27431 }
27432 {
27433 PyThreadState* __tstate = wxPyBeginAllowThreads();
27434 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
27435 wxPyEndAllowThreads(__tstate);
27436 if (PyErr_Occurred()) SWIG_fail;
27437 }
27438 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
27439 return resultobj;
27440 fail:
27441 return NULL;
27442 }
27443
27444
27445 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27446 PyObject *resultobj = 0;
27447 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
27448 bool result;
27449 void *argp1 = 0 ;
27450 int res1 = 0 ;
27451 PyObject *swig_obj[1] ;
27452
27453 if (!args) SWIG_fail;
27454 swig_obj[0] = args;
27455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
27456 if (!SWIG_IsOK(res1)) {
27457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
27458 }
27459 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
27460 {
27461 PyThreadState* __tstate = wxPyBeginAllowThreads();
27462 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
27463 wxPyEndAllowThreads(__tstate);
27464 if (PyErr_Occurred()) SWIG_fail;
27465 }
27466 {
27467 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27468 }
27469 return resultobj;
27470 fail:
27471 return NULL;
27472 }
27473
27474
27475 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27476 PyObject *obj;
27477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27478 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
27479 return SWIG_Py_Void();
27480 }
27481
27482 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27483 return SWIG_Python_InitShadowInstance(args);
27484 }
27485
27486 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27487 PyObject *resultobj = 0;
27488 int arg1 = (int) 0 ;
27489 wxInitDialogEvent *result = 0 ;
27490 int val1 ;
27491 int ecode1 = 0 ;
27492 PyObject * obj0 = 0 ;
27493 char * kwnames[] = {
27494 (char *) "Id", NULL
27495 };
27496
27497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
27498 if (obj0) {
27499 ecode1 = SWIG_AsVal_int(obj0, &val1);
27500 if (!SWIG_IsOK(ecode1)) {
27501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
27502 }
27503 arg1 = static_cast< int >(val1);
27504 }
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27519 PyObject *obj;
27520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27521 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
27522 return SWIG_Py_Void();
27523 }
27524
27525 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27526 return SWIG_Python_InitShadowInstance(args);
27527 }
27528
27529 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27530 PyObject *resultobj = 0;
27531 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27532 int arg2 = (int) 0 ;
27533 wxMenu *arg3 = (wxMenu *) NULL ;
27534 wxMenuEvent *result = 0 ;
27535 int val1 ;
27536 int ecode1 = 0 ;
27537 int val2 ;
27538 int ecode2 = 0 ;
27539 void *argp3 = 0 ;
27540 int res3 = 0 ;
27541 PyObject * obj0 = 0 ;
27542 PyObject * obj1 = 0 ;
27543 PyObject * obj2 = 0 ;
27544 char * kwnames[] = {
27545 (char *) "type",(char *) "winid",(char *) "menu", NULL
27546 };
27547
27548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27549 if (obj0) {
27550 ecode1 = SWIG_AsVal_int(obj0, &val1);
27551 if (!SWIG_IsOK(ecode1)) {
27552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27553 }
27554 arg1 = static_cast< wxEventType >(val1);
27555 }
27556 if (obj1) {
27557 ecode2 = SWIG_AsVal_int(obj1, &val2);
27558 if (!SWIG_IsOK(ecode2)) {
27559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27560 }
27561 arg2 = static_cast< int >(val2);
27562 }
27563 if (obj2) {
27564 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27565 if (!SWIG_IsOK(res3)) {
27566 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27567 }
27568 arg3 = reinterpret_cast< wxMenu * >(argp3);
27569 }
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27577 return resultobj;
27578 fail:
27579 return NULL;
27580 }
27581
27582
27583 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27584 PyObject *resultobj = 0;
27585 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27586 int result;
27587 void *argp1 = 0 ;
27588 int res1 = 0 ;
27589 PyObject *swig_obj[1] ;
27590
27591 if (!args) SWIG_fail;
27592 swig_obj[0] = args;
27593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27594 if (!SWIG_IsOK(res1)) {
27595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27596 }
27597 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27598 {
27599 PyThreadState* __tstate = wxPyBeginAllowThreads();
27600 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27601 wxPyEndAllowThreads(__tstate);
27602 if (PyErr_Occurred()) SWIG_fail;
27603 }
27604 resultobj = SWIG_From_int(static_cast< int >(result));
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27612 PyObject *resultobj = 0;
27613 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27614 bool result;
27615 void *argp1 = 0 ;
27616 int res1 = 0 ;
27617 PyObject *swig_obj[1] ;
27618
27619 if (!args) SWIG_fail;
27620 swig_obj[0] = args;
27621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27622 if (!SWIG_IsOK(res1)) {
27623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27624 }
27625 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27626 {
27627 PyThreadState* __tstate = wxPyBeginAllowThreads();
27628 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27629 wxPyEndAllowThreads(__tstate);
27630 if (PyErr_Occurred()) SWIG_fail;
27631 }
27632 {
27633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27634 }
27635 return resultobj;
27636 fail:
27637 return NULL;
27638 }
27639
27640
27641 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27642 PyObject *resultobj = 0;
27643 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27644 wxMenu *result = 0 ;
27645 void *argp1 = 0 ;
27646 int res1 = 0 ;
27647 PyObject *swig_obj[1] ;
27648
27649 if (!args) SWIG_fail;
27650 swig_obj[0] = args;
27651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27652 if (!SWIG_IsOK(res1)) {
27653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27654 }
27655 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27656 {
27657 PyThreadState* __tstate = wxPyBeginAllowThreads();
27658 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27659 wxPyEndAllowThreads(__tstate);
27660 if (PyErr_Occurred()) SWIG_fail;
27661 }
27662 {
27663 resultobj = wxPyMake_wxObject(result, (bool)0);
27664 }
27665 return resultobj;
27666 fail:
27667 return NULL;
27668 }
27669
27670
27671 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27672 PyObject *obj;
27673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27675 return SWIG_Py_Void();
27676 }
27677
27678 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27679 return SWIG_Python_InitShadowInstance(args);
27680 }
27681
27682 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27683 PyObject *resultobj = 0;
27684 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27685 int arg2 = (int) 0 ;
27686 wxCloseEvent *result = 0 ;
27687 int val1 ;
27688 int ecode1 = 0 ;
27689 int val2 ;
27690 int ecode2 = 0 ;
27691 PyObject * obj0 = 0 ;
27692 PyObject * obj1 = 0 ;
27693 char * kwnames[] = {
27694 (char *) "type",(char *) "winid", NULL
27695 };
27696
27697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27698 if (obj0) {
27699 ecode1 = SWIG_AsVal_int(obj0, &val1);
27700 if (!SWIG_IsOK(ecode1)) {
27701 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27702 }
27703 arg1 = static_cast< wxEventType >(val1);
27704 }
27705 if (obj1) {
27706 ecode2 = SWIG_AsVal_int(obj1, &val2);
27707 if (!SWIG_IsOK(ecode2)) {
27708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27709 }
27710 arg2 = static_cast< int >(val2);
27711 }
27712 {
27713 PyThreadState* __tstate = wxPyBeginAllowThreads();
27714 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27715 wxPyEndAllowThreads(__tstate);
27716 if (PyErr_Occurred()) SWIG_fail;
27717 }
27718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27719 return resultobj;
27720 fail:
27721 return NULL;
27722 }
27723
27724
27725 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27726 PyObject *resultobj = 0;
27727 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27728 bool arg2 ;
27729 void *argp1 = 0 ;
27730 int res1 = 0 ;
27731 bool val2 ;
27732 int ecode2 = 0 ;
27733 PyObject * obj0 = 0 ;
27734 PyObject * obj1 = 0 ;
27735 char * kwnames[] = {
27736 (char *) "self",(char *) "logOff", NULL
27737 };
27738
27739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27741 if (!SWIG_IsOK(res1)) {
27742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27743 }
27744 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27745 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27746 if (!SWIG_IsOK(ecode2)) {
27747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27748 }
27749 arg2 = static_cast< bool >(val2);
27750 {
27751 PyThreadState* __tstate = wxPyBeginAllowThreads();
27752 (arg1)->SetLoggingOff(arg2);
27753 wxPyEndAllowThreads(__tstate);
27754 if (PyErr_Occurred()) SWIG_fail;
27755 }
27756 resultobj = SWIG_Py_Void();
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27764 PyObject *resultobj = 0;
27765 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27766 bool result;
27767 void *argp1 = 0 ;
27768 int res1 = 0 ;
27769 PyObject *swig_obj[1] ;
27770
27771 if (!args) SWIG_fail;
27772 swig_obj[0] = args;
27773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27774 if (!SWIG_IsOK(res1)) {
27775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27776 }
27777 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27794 PyObject *resultobj = 0;
27795 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27796 bool arg2 = (bool) true ;
27797 void *argp1 = 0 ;
27798 int res1 = 0 ;
27799 bool val2 ;
27800 int ecode2 = 0 ;
27801 PyObject * obj0 = 0 ;
27802 PyObject * obj1 = 0 ;
27803 char * kwnames[] = {
27804 (char *) "self",(char *) "veto", NULL
27805 };
27806
27807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27809 if (!SWIG_IsOK(res1)) {
27810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27811 }
27812 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27813 if (obj1) {
27814 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27815 if (!SWIG_IsOK(ecode2)) {
27816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27817 }
27818 arg2 = static_cast< bool >(val2);
27819 }
27820 {
27821 PyThreadState* __tstate = wxPyBeginAllowThreads();
27822 (arg1)->Veto(arg2);
27823 wxPyEndAllowThreads(__tstate);
27824 if (PyErr_Occurred()) SWIG_fail;
27825 }
27826 resultobj = SWIG_Py_Void();
27827 return resultobj;
27828 fail:
27829 return NULL;
27830 }
27831
27832
27833 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27834 PyObject *resultobj = 0;
27835 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27836 bool result;
27837 void *argp1 = 0 ;
27838 int res1 = 0 ;
27839 PyObject *swig_obj[1] ;
27840
27841 if (!args) SWIG_fail;
27842 swig_obj[0] = args;
27843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27844 if (!SWIG_IsOK(res1)) {
27845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27846 }
27847 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27848 {
27849 PyThreadState* __tstate = wxPyBeginAllowThreads();
27850 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 {
27855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27856 }
27857 return resultobj;
27858 fail:
27859 return NULL;
27860 }
27861
27862
27863 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27864 PyObject *resultobj = 0;
27865 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27866 bool arg2 ;
27867 void *argp1 = 0 ;
27868 int res1 = 0 ;
27869 bool val2 ;
27870 int ecode2 = 0 ;
27871 PyObject * obj0 = 0 ;
27872 PyObject * obj1 = 0 ;
27873 char * kwnames[] = {
27874 (char *) "self",(char *) "canVeto", NULL
27875 };
27876
27877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27879 if (!SWIG_IsOK(res1)) {
27880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27881 }
27882 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27883 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27884 if (!SWIG_IsOK(ecode2)) {
27885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27886 }
27887 arg2 = static_cast< bool >(val2);
27888 {
27889 PyThreadState* __tstate = wxPyBeginAllowThreads();
27890 (arg1)->SetCanVeto(arg2);
27891 wxPyEndAllowThreads(__tstate);
27892 if (PyErr_Occurred()) SWIG_fail;
27893 }
27894 resultobj = SWIG_Py_Void();
27895 return resultobj;
27896 fail:
27897 return NULL;
27898 }
27899
27900
27901 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27902 PyObject *resultobj = 0;
27903 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27904 bool result;
27905 void *argp1 = 0 ;
27906 int res1 = 0 ;
27907 PyObject *swig_obj[1] ;
27908
27909 if (!args) SWIG_fail;
27910 swig_obj[0] = args;
27911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27912 if (!SWIG_IsOK(res1)) {
27913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27914 }
27915 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27919 wxPyEndAllowThreads(__tstate);
27920 if (PyErr_Occurred()) SWIG_fail;
27921 }
27922 {
27923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27924 }
27925 return resultobj;
27926 fail:
27927 return NULL;
27928 }
27929
27930
27931 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27932 PyObject *obj;
27933 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27934 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27935 return SWIG_Py_Void();
27936 }
27937
27938 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27939 return SWIG_Python_InitShadowInstance(args);
27940 }
27941
27942 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27943 PyObject *resultobj = 0;
27944 int arg1 = (int) 0 ;
27945 bool arg2 = (bool) false ;
27946 wxShowEvent *result = 0 ;
27947 int val1 ;
27948 int ecode1 = 0 ;
27949 bool val2 ;
27950 int ecode2 = 0 ;
27951 PyObject * obj0 = 0 ;
27952 PyObject * obj1 = 0 ;
27953 char * kwnames[] = {
27954 (char *) "winid",(char *) "show", NULL
27955 };
27956
27957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27958 if (obj0) {
27959 ecode1 = SWIG_AsVal_int(obj0, &val1);
27960 if (!SWIG_IsOK(ecode1)) {
27961 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27962 }
27963 arg1 = static_cast< int >(val1);
27964 }
27965 if (obj1) {
27966 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27967 if (!SWIG_IsOK(ecode2)) {
27968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27969 }
27970 arg2 = static_cast< bool >(val2);
27971 }
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27988 bool arg2 ;
27989 void *argp1 = 0 ;
27990 int res1 = 0 ;
27991 bool val2 ;
27992 int ecode2 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 PyObject * obj1 = 0 ;
27995 char * kwnames[] = {
27996 (char *) "self",(char *) "show", NULL
27997 };
27998
27999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
28000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
28003 }
28004 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28006 if (!SWIG_IsOK(ecode2)) {
28007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
28008 }
28009 arg2 = static_cast< bool >(val2);
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 (arg1)->SetShow(arg2);
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = SWIG_Py_Void();
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28024 PyObject *resultobj = 0;
28025 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
28026 bool result;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 PyObject *swig_obj[1] ;
28030
28031 if (!args) SWIG_fail;
28032 swig_obj[0] = args;
28033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
28034 if (!SWIG_IsOK(res1)) {
28035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
28036 }
28037 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
28038 {
28039 PyThreadState* __tstate = wxPyBeginAllowThreads();
28040 result = (bool)((wxShowEvent const *)arg1)->GetShow();
28041 wxPyEndAllowThreads(__tstate);
28042 if (PyErr_Occurred()) SWIG_fail;
28043 }
28044 {
28045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28046 }
28047 return resultobj;
28048 fail:
28049 return NULL;
28050 }
28051
28052
28053 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28054 PyObject *obj;
28055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28056 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
28057 return SWIG_Py_Void();
28058 }
28059
28060 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28061 return SWIG_Python_InitShadowInstance(args);
28062 }
28063
28064 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28065 PyObject *resultobj = 0;
28066 int arg1 = (int) 0 ;
28067 bool arg2 = (bool) true ;
28068 wxIconizeEvent *result = 0 ;
28069 int val1 ;
28070 int ecode1 = 0 ;
28071 bool val2 ;
28072 int ecode2 = 0 ;
28073 PyObject * obj0 = 0 ;
28074 PyObject * obj1 = 0 ;
28075 char * kwnames[] = {
28076 (char *) "id",(char *) "iconized", NULL
28077 };
28078
28079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28080 if (obj0) {
28081 ecode1 = SWIG_AsVal_int(obj0, &val1);
28082 if (!SWIG_IsOK(ecode1)) {
28083 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
28084 }
28085 arg1 = static_cast< int >(val1);
28086 }
28087 if (obj1) {
28088 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28089 if (!SWIG_IsOK(ecode2)) {
28090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
28091 }
28092 arg2 = static_cast< bool >(val2);
28093 }
28094 {
28095 PyThreadState* __tstate = wxPyBeginAllowThreads();
28096 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
28101 return resultobj;
28102 fail:
28103 return NULL;
28104 }
28105
28106
28107 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28108 PyObject *resultobj = 0;
28109 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
28110 bool result;
28111 void *argp1 = 0 ;
28112 int res1 = 0 ;
28113 PyObject *swig_obj[1] ;
28114
28115 if (!args) SWIG_fail;
28116 swig_obj[0] = args;
28117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
28118 if (!SWIG_IsOK(res1)) {
28119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
28120 }
28121 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 result = (bool)(arg1)->Iconized();
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 {
28129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28130 }
28131 return resultobj;
28132 fail:
28133 return NULL;
28134 }
28135
28136
28137 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28138 PyObject *obj;
28139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28140 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
28141 return SWIG_Py_Void();
28142 }
28143
28144 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28145 return SWIG_Python_InitShadowInstance(args);
28146 }
28147
28148 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28149 PyObject *resultobj = 0;
28150 int arg1 = (int) 0 ;
28151 wxMaximizeEvent *result = 0 ;
28152 int val1 ;
28153 int ecode1 = 0 ;
28154 PyObject * obj0 = 0 ;
28155 char * kwnames[] = {
28156 (char *) "id", NULL
28157 };
28158
28159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
28160 if (obj0) {
28161 ecode1 = SWIG_AsVal_int(obj0, &val1);
28162 if (!SWIG_IsOK(ecode1)) {
28163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
28164 }
28165 arg1 = static_cast< int >(val1);
28166 }
28167 {
28168 PyThreadState* __tstate = wxPyBeginAllowThreads();
28169 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
28170 wxPyEndAllowThreads(__tstate);
28171 if (PyErr_Occurred()) SWIG_fail;
28172 }
28173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
28174 return resultobj;
28175 fail:
28176 return NULL;
28177 }
28178
28179
28180 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28181 PyObject *obj;
28182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28183 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
28184 return SWIG_Py_Void();
28185 }
28186
28187 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28188 return SWIG_Python_InitShadowInstance(args);
28189 }
28190
28191 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28192 PyObject *resultobj = 0;
28193 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28194 wxPoint result;
28195 void *argp1 = 0 ;
28196 int res1 = 0 ;
28197 PyObject *swig_obj[1] ;
28198
28199 if (!args) SWIG_fail;
28200 swig_obj[0] = args;
28201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28202 if (!SWIG_IsOK(res1)) {
28203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28204 }
28205 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28206 {
28207 PyThreadState* __tstate = wxPyBeginAllowThreads();
28208 result = (arg1)->GetPosition();
28209 wxPyEndAllowThreads(__tstate);
28210 if (PyErr_Occurred()) SWIG_fail;
28211 }
28212 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
28213 return resultobj;
28214 fail:
28215 return NULL;
28216 }
28217
28218
28219 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28220 PyObject *resultobj = 0;
28221 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28222 int result;
28223 void *argp1 = 0 ;
28224 int res1 = 0 ;
28225 PyObject *swig_obj[1] ;
28226
28227 if (!args) SWIG_fail;
28228 swig_obj[0] = args;
28229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28230 if (!SWIG_IsOK(res1)) {
28231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28232 }
28233 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28234 {
28235 PyThreadState* __tstate = wxPyBeginAllowThreads();
28236 result = (int)(arg1)->GetNumberOfFiles();
28237 wxPyEndAllowThreads(__tstate);
28238 if (PyErr_Occurred()) SWIG_fail;
28239 }
28240 resultobj = SWIG_From_int(static_cast< int >(result));
28241 return resultobj;
28242 fail:
28243 return NULL;
28244 }
28245
28246
28247 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28248 PyObject *resultobj = 0;
28249 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
28250 PyObject *result = 0 ;
28251 void *argp1 = 0 ;
28252 int res1 = 0 ;
28253 PyObject *swig_obj[1] ;
28254
28255 if (!args) SWIG_fail;
28256 swig_obj[0] = args;
28257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
28258 if (!SWIG_IsOK(res1)) {
28259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
28260 }
28261 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
28262 {
28263 PyThreadState* __tstate = wxPyBeginAllowThreads();
28264 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 resultobj = result;
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28276 PyObject *obj;
28277 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28278 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
28279 return SWIG_Py_Void();
28280 }
28281
28282 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28283 PyObject *resultobj = 0;
28284 int arg1 = (int) 0 ;
28285 wxUpdateUIEvent *result = 0 ;
28286 int val1 ;
28287 int ecode1 = 0 ;
28288 PyObject * obj0 = 0 ;
28289 char * kwnames[] = {
28290 (char *) "commandId", NULL
28291 };
28292
28293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
28294 if (obj0) {
28295 ecode1 = SWIG_AsVal_int(obj0, &val1);
28296 if (!SWIG_IsOK(ecode1)) {
28297 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
28298 }
28299 arg1 = static_cast< int >(val1);
28300 }
28301 {
28302 PyThreadState* __tstate = wxPyBeginAllowThreads();
28303 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
28304 wxPyEndAllowThreads(__tstate);
28305 if (PyErr_Occurred()) SWIG_fail;
28306 }
28307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
28308 return resultobj;
28309 fail:
28310 return NULL;
28311 }
28312
28313
28314 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28315 PyObject *resultobj = 0;
28316 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28317 bool result;
28318 void *argp1 = 0 ;
28319 int res1 = 0 ;
28320 PyObject *swig_obj[1] ;
28321
28322 if (!args) SWIG_fail;
28323 swig_obj[0] = args;
28324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28325 if (!SWIG_IsOK(res1)) {
28326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28327 }
28328 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28329 {
28330 PyThreadState* __tstate = wxPyBeginAllowThreads();
28331 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
28332 wxPyEndAllowThreads(__tstate);
28333 if (PyErr_Occurred()) SWIG_fail;
28334 }
28335 {
28336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28337 }
28338 return resultobj;
28339 fail:
28340 return NULL;
28341 }
28342
28343
28344 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 PyObject *resultobj = 0;
28346 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28347 bool result;
28348 void *argp1 = 0 ;
28349 int res1 = 0 ;
28350 PyObject *swig_obj[1] ;
28351
28352 if (!args) SWIG_fail;
28353 swig_obj[0] = args;
28354 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28355 if (!SWIG_IsOK(res1)) {
28356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28357 }
28358 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28359 {
28360 PyThreadState* __tstate = wxPyBeginAllowThreads();
28361 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 {
28366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28367 }
28368 return resultobj;
28369 fail:
28370 return NULL;
28371 }
28372
28373
28374 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28375 PyObject *resultobj = 0;
28376 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28377 bool result;
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_wxUpdateUIEvent, 0 | 0 );
28385 if (!SWIG_IsOK(res1)) {
28386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28387 }
28388 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28389 {
28390 PyThreadState* __tstate = wxPyBeginAllowThreads();
28391 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
28392 wxPyEndAllowThreads(__tstate);
28393 if (PyErr_Occurred()) SWIG_fail;
28394 }
28395 {
28396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28397 }
28398 return resultobj;
28399 fail:
28400 return NULL;
28401 }
28402
28403
28404 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28405 PyObject *resultobj = 0;
28406 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28407 wxString result;
28408 void *argp1 = 0 ;
28409 int res1 = 0 ;
28410 PyObject *swig_obj[1] ;
28411
28412 if (!args) SWIG_fail;
28413 swig_obj[0] = args;
28414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28415 if (!SWIG_IsOK(res1)) {
28416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28417 }
28418 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28419 {
28420 PyThreadState* __tstate = wxPyBeginAllowThreads();
28421 result = ((wxUpdateUIEvent const *)arg1)->GetText();
28422 wxPyEndAllowThreads(__tstate);
28423 if (PyErr_Occurred()) SWIG_fail;
28424 }
28425 {
28426 #if wxUSE_UNICODE
28427 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28428 #else
28429 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28430 #endif
28431 }
28432 return resultobj;
28433 fail:
28434 return NULL;
28435 }
28436
28437
28438 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28439 PyObject *resultobj = 0;
28440 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28441 bool result;
28442 void *argp1 = 0 ;
28443 int res1 = 0 ;
28444 PyObject *swig_obj[1] ;
28445
28446 if (!args) SWIG_fail;
28447 swig_obj[0] = args;
28448 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28449 if (!SWIG_IsOK(res1)) {
28450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28451 }
28452 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28453 {
28454 PyThreadState* __tstate = wxPyBeginAllowThreads();
28455 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
28456 wxPyEndAllowThreads(__tstate);
28457 if (PyErr_Occurred()) SWIG_fail;
28458 }
28459 {
28460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28461 }
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28469 PyObject *resultobj = 0;
28470 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28471 bool result;
28472 void *argp1 = 0 ;
28473 int res1 = 0 ;
28474 PyObject *swig_obj[1] ;
28475
28476 if (!args) SWIG_fail;
28477 swig_obj[0] = args;
28478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28479 if (!SWIG_IsOK(res1)) {
28480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28481 }
28482 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28483 {
28484 PyThreadState* __tstate = wxPyBeginAllowThreads();
28485 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
28486 wxPyEndAllowThreads(__tstate);
28487 if (PyErr_Occurred()) SWIG_fail;
28488 }
28489 {
28490 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28491 }
28492 return resultobj;
28493 fail:
28494 return NULL;
28495 }
28496
28497
28498 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28499 PyObject *resultobj = 0;
28500 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28501 bool result;
28502 void *argp1 = 0 ;
28503 int res1 = 0 ;
28504 PyObject *swig_obj[1] ;
28505
28506 if (!args) SWIG_fail;
28507 swig_obj[0] = args;
28508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28509 if (!SWIG_IsOK(res1)) {
28510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28511 }
28512 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28513 {
28514 PyThreadState* __tstate = wxPyBeginAllowThreads();
28515 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
28516 wxPyEndAllowThreads(__tstate);
28517 if (PyErr_Occurred()) SWIG_fail;
28518 }
28519 {
28520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28521 }
28522 return resultobj;
28523 fail:
28524 return NULL;
28525 }
28526
28527
28528 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28529 PyObject *resultobj = 0;
28530 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28531 bool result;
28532 void *argp1 = 0 ;
28533 int res1 = 0 ;
28534 PyObject *swig_obj[1] ;
28535
28536 if (!args) SWIG_fail;
28537 swig_obj[0] = args;
28538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28539 if (!SWIG_IsOK(res1)) {
28540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
28541 }
28542 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28543 {
28544 PyThreadState* __tstate = wxPyBeginAllowThreads();
28545 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
28546 wxPyEndAllowThreads(__tstate);
28547 if (PyErr_Occurred()) SWIG_fail;
28548 }
28549 {
28550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28551 }
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28559 PyObject *resultobj = 0;
28560 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28561 bool arg2 ;
28562 void *argp1 = 0 ;
28563 int res1 = 0 ;
28564 bool val2 ;
28565 int ecode2 = 0 ;
28566 PyObject * obj0 = 0 ;
28567 PyObject * obj1 = 0 ;
28568 char * kwnames[] = {
28569 (char *) "self",(char *) "check", NULL
28570 };
28571
28572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28574 if (!SWIG_IsOK(res1)) {
28575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28576 }
28577 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28578 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28579 if (!SWIG_IsOK(ecode2)) {
28580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28581 }
28582 arg2 = static_cast< bool >(val2);
28583 {
28584 PyThreadState* __tstate = wxPyBeginAllowThreads();
28585 (arg1)->Check(arg2);
28586 wxPyEndAllowThreads(__tstate);
28587 if (PyErr_Occurred()) SWIG_fail;
28588 }
28589 resultobj = SWIG_Py_Void();
28590 return resultobj;
28591 fail:
28592 return NULL;
28593 }
28594
28595
28596 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28597 PyObject *resultobj = 0;
28598 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28599 bool arg2 ;
28600 void *argp1 = 0 ;
28601 int res1 = 0 ;
28602 bool val2 ;
28603 int ecode2 = 0 ;
28604 PyObject * obj0 = 0 ;
28605 PyObject * obj1 = 0 ;
28606 char * kwnames[] = {
28607 (char *) "self",(char *) "enable", NULL
28608 };
28609
28610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28612 if (!SWIG_IsOK(res1)) {
28613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28614 }
28615 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28616 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28617 if (!SWIG_IsOK(ecode2)) {
28618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28619 }
28620 arg2 = static_cast< bool >(val2);
28621 {
28622 PyThreadState* __tstate = wxPyBeginAllowThreads();
28623 (arg1)->Enable(arg2);
28624 wxPyEndAllowThreads(__tstate);
28625 if (PyErr_Occurred()) SWIG_fail;
28626 }
28627 resultobj = SWIG_Py_Void();
28628 return resultobj;
28629 fail:
28630 return NULL;
28631 }
28632
28633
28634 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28635 PyObject *resultobj = 0;
28636 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28637 bool arg2 ;
28638 void *argp1 = 0 ;
28639 int res1 = 0 ;
28640 bool val2 ;
28641 int ecode2 = 0 ;
28642 PyObject * obj0 = 0 ;
28643 PyObject * obj1 = 0 ;
28644 char * kwnames[] = {
28645 (char *) "self",(char *) "show", NULL
28646 };
28647
28648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28650 if (!SWIG_IsOK(res1)) {
28651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28652 }
28653 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28655 if (!SWIG_IsOK(ecode2)) {
28656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28657 }
28658 arg2 = static_cast< bool >(val2);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 (arg1)->Show(arg2);
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 resultobj = SWIG_Py_Void();
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28673 PyObject *resultobj = 0;
28674 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28675 wxString *arg2 = 0 ;
28676 void *argp1 = 0 ;
28677 int res1 = 0 ;
28678 bool temp2 = false ;
28679 PyObject * obj0 = 0 ;
28680 PyObject * obj1 = 0 ;
28681 char * kwnames[] = {
28682 (char *) "self",(char *) "text", NULL
28683 };
28684
28685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28687 if (!SWIG_IsOK(res1)) {
28688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28689 }
28690 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28691 {
28692 arg2 = wxString_in_helper(obj1);
28693 if (arg2 == NULL) SWIG_fail;
28694 temp2 = true;
28695 }
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 (arg1)->SetText((wxString const &)*arg2);
28699 wxPyEndAllowThreads(__tstate);
28700 if (PyErr_Occurred()) SWIG_fail;
28701 }
28702 resultobj = SWIG_Py_Void();
28703 {
28704 if (temp2)
28705 delete arg2;
28706 }
28707 return resultobj;
28708 fail:
28709 {
28710 if (temp2)
28711 delete arg2;
28712 }
28713 return NULL;
28714 }
28715
28716
28717 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28718 PyObject *resultobj = 0;
28719 long arg1 ;
28720 long val1 ;
28721 int ecode1 = 0 ;
28722 PyObject * obj0 = 0 ;
28723 char * kwnames[] = {
28724 (char *) "updateInterval", NULL
28725 };
28726
28727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28728 ecode1 = SWIG_AsVal_long(obj0, &val1);
28729 if (!SWIG_IsOK(ecode1)) {
28730 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28731 }
28732 arg1 = static_cast< long >(val1);
28733 {
28734 PyThreadState* __tstate = wxPyBeginAllowThreads();
28735 wxUpdateUIEvent::SetUpdateInterval(arg1);
28736 wxPyEndAllowThreads(__tstate);
28737 if (PyErr_Occurred()) SWIG_fail;
28738 }
28739 resultobj = SWIG_Py_Void();
28740 return resultobj;
28741 fail:
28742 return NULL;
28743 }
28744
28745
28746 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28747 PyObject *resultobj = 0;
28748 long result;
28749
28750 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28751 {
28752 PyThreadState* __tstate = wxPyBeginAllowThreads();
28753 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28754 wxPyEndAllowThreads(__tstate);
28755 if (PyErr_Occurred()) SWIG_fail;
28756 }
28757 resultobj = SWIG_From_long(static_cast< long >(result));
28758 return resultobj;
28759 fail:
28760 return NULL;
28761 }
28762
28763
28764 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28765 PyObject *resultobj = 0;
28766 wxWindow *arg1 = (wxWindow *) 0 ;
28767 bool result;
28768 void *argp1 = 0 ;
28769 int res1 = 0 ;
28770 PyObject * obj0 = 0 ;
28771 char * kwnames[] = {
28772 (char *) "win", NULL
28773 };
28774
28775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28777 if (!SWIG_IsOK(res1)) {
28778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28779 }
28780 arg1 = reinterpret_cast< wxWindow * >(argp1);
28781 {
28782 PyThreadState* __tstate = wxPyBeginAllowThreads();
28783 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28784 wxPyEndAllowThreads(__tstate);
28785 if (PyErr_Occurred()) SWIG_fail;
28786 }
28787 {
28788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28789 }
28790 return resultobj;
28791 fail:
28792 return NULL;
28793 }
28794
28795
28796 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28797 PyObject *resultobj = 0;
28798
28799 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28800 {
28801 PyThreadState* __tstate = wxPyBeginAllowThreads();
28802 wxUpdateUIEvent::ResetUpdateTime();
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 resultobj = SWIG_Py_Void();
28807 return resultobj;
28808 fail:
28809 return NULL;
28810 }
28811
28812
28813 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28814 PyObject *resultobj = 0;
28815 wxUpdateUIMode arg1 ;
28816 int val1 ;
28817 int ecode1 = 0 ;
28818 PyObject * obj0 = 0 ;
28819 char * kwnames[] = {
28820 (char *) "mode", NULL
28821 };
28822
28823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28824 ecode1 = SWIG_AsVal_int(obj0, &val1);
28825 if (!SWIG_IsOK(ecode1)) {
28826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28827 }
28828 arg1 = static_cast< wxUpdateUIMode >(val1);
28829 {
28830 PyThreadState* __tstate = wxPyBeginAllowThreads();
28831 wxUpdateUIEvent::SetMode(arg1);
28832 wxPyEndAllowThreads(__tstate);
28833 if (PyErr_Occurred()) SWIG_fail;
28834 }
28835 resultobj = SWIG_Py_Void();
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28843 PyObject *resultobj = 0;
28844 wxUpdateUIMode result;
28845
28846 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 resultobj = SWIG_From_int(static_cast< int >(result));
28854 return resultobj;
28855 fail:
28856 return NULL;
28857 }
28858
28859
28860 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28861 PyObject *obj;
28862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28863 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28864 return SWIG_Py_Void();
28865 }
28866
28867 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28868 return SWIG_Python_InitShadowInstance(args);
28869 }
28870
28871 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28872 PyObject *resultobj = 0;
28873 wxSysColourChangedEvent *result = 0 ;
28874
28875 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28890 PyObject *obj;
28891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28892 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28893 return SWIG_Py_Void();
28894 }
28895
28896 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28897 return SWIG_Python_InitShadowInstance(args);
28898 }
28899
28900 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28901 PyObject *resultobj = 0;
28902 int arg1 = (int) 0 ;
28903 wxWindow *arg2 = (wxWindow *) NULL ;
28904 wxMouseCaptureChangedEvent *result = 0 ;
28905 int val1 ;
28906 int ecode1 = 0 ;
28907 void *argp2 = 0 ;
28908 int res2 = 0 ;
28909 PyObject * obj0 = 0 ;
28910 PyObject * obj1 = 0 ;
28911 char * kwnames[] = {
28912 (char *) "winid",(char *) "gainedCapture", NULL
28913 };
28914
28915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28916 if (obj0) {
28917 ecode1 = SWIG_AsVal_int(obj0, &val1);
28918 if (!SWIG_IsOK(ecode1)) {
28919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28920 }
28921 arg1 = static_cast< int >(val1);
28922 }
28923 if (obj1) {
28924 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28925 if (!SWIG_IsOK(res2)) {
28926 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28927 }
28928 arg2 = reinterpret_cast< wxWindow * >(argp2);
28929 }
28930 {
28931 PyThreadState* __tstate = wxPyBeginAllowThreads();
28932 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28933 wxPyEndAllowThreads(__tstate);
28934 if (PyErr_Occurred()) SWIG_fail;
28935 }
28936 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28937 return resultobj;
28938 fail:
28939 return NULL;
28940 }
28941
28942
28943 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 PyObject *resultobj = 0;
28945 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28946 wxWindow *result = 0 ;
28947 void *argp1 = 0 ;
28948 int res1 = 0 ;
28949 PyObject *swig_obj[1] ;
28950
28951 if (!args) SWIG_fail;
28952 swig_obj[0] = args;
28953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28954 if (!SWIG_IsOK(res1)) {
28955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28956 }
28957 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28958 {
28959 PyThreadState* __tstate = wxPyBeginAllowThreads();
28960 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28961 wxPyEndAllowThreads(__tstate);
28962 if (PyErr_Occurred()) SWIG_fail;
28963 }
28964 {
28965 resultobj = wxPyMake_wxObject(result, (bool)0);
28966 }
28967 return resultobj;
28968 fail:
28969 return NULL;
28970 }
28971
28972
28973 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28974 PyObject *obj;
28975 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28976 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28977 return SWIG_Py_Void();
28978 }
28979
28980 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 return SWIG_Python_InitShadowInstance(args);
28982 }
28983
28984 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28985 PyObject *resultobj = 0;
28986 int arg1 = (int) 0 ;
28987 wxMouseCaptureLostEvent *result = 0 ;
28988 int val1 ;
28989 int ecode1 = 0 ;
28990 PyObject * obj0 = 0 ;
28991 char * kwnames[] = {
28992 (char *) "winid", NULL
28993 };
28994
28995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28996 if (obj0) {
28997 ecode1 = SWIG_AsVal_int(obj0, &val1);
28998 if (!SWIG_IsOK(ecode1)) {
28999 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
29000 }
29001 arg1 = static_cast< int >(val1);
29002 }
29003 {
29004 PyThreadState* __tstate = wxPyBeginAllowThreads();
29005 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
29006 wxPyEndAllowThreads(__tstate);
29007 if (PyErr_Occurred()) SWIG_fail;
29008 }
29009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
29010 return resultobj;
29011 fail:
29012 return NULL;
29013 }
29014
29015
29016 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29017 PyObject *obj;
29018 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29019 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
29020 return SWIG_Py_Void();
29021 }
29022
29023 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 return SWIG_Python_InitShadowInstance(args);
29025 }
29026
29027 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *resultobj = 0;
29029 wxDisplayChangedEvent *result = 0 ;
29030
29031 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
29035 wxPyEndAllowThreads(__tstate);
29036 if (PyErr_Occurred()) SWIG_fail;
29037 }
29038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
29039 return resultobj;
29040 fail:
29041 return NULL;
29042 }
29043
29044
29045 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29046 PyObject *obj;
29047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29048 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
29049 return SWIG_Py_Void();
29050 }
29051
29052 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29053 return SWIG_Python_InitShadowInstance(args);
29054 }
29055
29056 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29057 PyObject *resultobj = 0;
29058 int arg1 = (int) 0 ;
29059 wxPaletteChangedEvent *result = 0 ;
29060 int val1 ;
29061 int ecode1 = 0 ;
29062 PyObject * obj0 = 0 ;
29063 char * kwnames[] = {
29064 (char *) "id", NULL
29065 };
29066
29067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
29068 if (obj0) {
29069 ecode1 = SWIG_AsVal_int(obj0, &val1);
29070 if (!SWIG_IsOK(ecode1)) {
29071 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
29072 }
29073 arg1 = static_cast< int >(val1);
29074 }
29075 {
29076 PyThreadState* __tstate = wxPyBeginAllowThreads();
29077 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
29078 wxPyEndAllowThreads(__tstate);
29079 if (PyErr_Occurred()) SWIG_fail;
29080 }
29081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
29082 return resultobj;
29083 fail:
29084 return NULL;
29085 }
29086
29087
29088 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29089 PyObject *resultobj = 0;
29090 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29091 wxWindow *arg2 = (wxWindow *) 0 ;
29092 void *argp1 = 0 ;
29093 int res1 = 0 ;
29094 void *argp2 = 0 ;
29095 int res2 = 0 ;
29096 PyObject * obj0 = 0 ;
29097 PyObject * obj1 = 0 ;
29098 char * kwnames[] = {
29099 (char *) "self",(char *) "win", NULL
29100 };
29101
29102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
29103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29104 if (!SWIG_IsOK(res1)) {
29105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29106 }
29107 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29109 if (!SWIG_IsOK(res2)) {
29110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
29111 }
29112 arg2 = reinterpret_cast< wxWindow * >(argp2);
29113 {
29114 PyThreadState* __tstate = wxPyBeginAllowThreads();
29115 (arg1)->SetChangedWindow(arg2);
29116 wxPyEndAllowThreads(__tstate);
29117 if (PyErr_Occurred()) SWIG_fail;
29118 }
29119 resultobj = SWIG_Py_Void();
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *resultobj = 0;
29128 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
29129 wxWindow *result = 0 ;
29130 void *argp1 = 0 ;
29131 int res1 = 0 ;
29132 PyObject *swig_obj[1] ;
29133
29134 if (!args) SWIG_fail;
29135 swig_obj[0] = args;
29136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
29137 if (!SWIG_IsOK(res1)) {
29138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
29139 }
29140 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
29141 {
29142 PyThreadState* __tstate = wxPyBeginAllowThreads();
29143 result = (wxWindow *)(arg1)->GetChangedWindow();
29144 wxPyEndAllowThreads(__tstate);
29145 if (PyErr_Occurred()) SWIG_fail;
29146 }
29147 {
29148 resultobj = wxPyMake_wxObject(result, (bool)0);
29149 }
29150 return resultobj;
29151 fail:
29152 return NULL;
29153 }
29154
29155
29156 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29157 PyObject *obj;
29158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29159 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
29160 return SWIG_Py_Void();
29161 }
29162
29163 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29164 return SWIG_Python_InitShadowInstance(args);
29165 }
29166
29167 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29168 PyObject *resultobj = 0;
29169 int arg1 = (int) 0 ;
29170 wxQueryNewPaletteEvent *result = 0 ;
29171 int val1 ;
29172 int ecode1 = 0 ;
29173 PyObject * obj0 = 0 ;
29174 char * kwnames[] = {
29175 (char *) "winid", NULL
29176 };
29177
29178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
29179 if (obj0) {
29180 ecode1 = SWIG_AsVal_int(obj0, &val1);
29181 if (!SWIG_IsOK(ecode1)) {
29182 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
29183 }
29184 arg1 = static_cast< int >(val1);
29185 }
29186 {
29187 PyThreadState* __tstate = wxPyBeginAllowThreads();
29188 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
29189 wxPyEndAllowThreads(__tstate);
29190 if (PyErr_Occurred()) SWIG_fail;
29191 }
29192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29200 PyObject *resultobj = 0;
29201 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29202 bool arg2 ;
29203 void *argp1 = 0 ;
29204 int res1 = 0 ;
29205 bool val2 ;
29206 int ecode2 = 0 ;
29207 PyObject * obj0 = 0 ;
29208 PyObject * obj1 = 0 ;
29209 char * kwnames[] = {
29210 (char *) "self",(char *) "realized", NULL
29211 };
29212
29213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
29214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29215 if (!SWIG_IsOK(res1)) {
29216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
29217 }
29218 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29219 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29220 if (!SWIG_IsOK(ecode2)) {
29221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
29222 }
29223 arg2 = static_cast< bool >(val2);
29224 {
29225 PyThreadState* __tstate = wxPyBeginAllowThreads();
29226 (arg1)->SetPaletteRealized(arg2);
29227 wxPyEndAllowThreads(__tstate);
29228 if (PyErr_Occurred()) SWIG_fail;
29229 }
29230 resultobj = SWIG_Py_Void();
29231 return resultobj;
29232 fail:
29233 return NULL;
29234 }
29235
29236
29237 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29238 PyObject *resultobj = 0;
29239 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
29240 bool result;
29241 void *argp1 = 0 ;
29242 int res1 = 0 ;
29243 PyObject *swig_obj[1] ;
29244
29245 if (!args) SWIG_fail;
29246 swig_obj[0] = args;
29247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
29248 if (!SWIG_IsOK(res1)) {
29249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
29250 }
29251 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
29252 {
29253 PyThreadState* __tstate = wxPyBeginAllowThreads();
29254 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
29255 wxPyEndAllowThreads(__tstate);
29256 if (PyErr_Occurred()) SWIG_fail;
29257 }
29258 {
29259 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29260 }
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29268 PyObject *obj;
29269 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29270 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
29271 return SWIG_Py_Void();
29272 }
29273
29274 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29275 return SWIG_Python_InitShadowInstance(args);
29276 }
29277
29278 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29279 PyObject *resultobj = 0;
29280 wxNavigationKeyEvent *result = 0 ;
29281
29282 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
29283 {
29284 PyThreadState* __tstate = wxPyBeginAllowThreads();
29285 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
29286 wxPyEndAllowThreads(__tstate);
29287 if (PyErr_Occurred()) SWIG_fail;
29288 }
29289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
29290 return resultobj;
29291 fail:
29292 return NULL;
29293 }
29294
29295
29296 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29297 PyObject *resultobj = 0;
29298 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29299 bool result;
29300 void *argp1 = 0 ;
29301 int res1 = 0 ;
29302 PyObject *swig_obj[1] ;
29303
29304 if (!args) SWIG_fail;
29305 swig_obj[0] = args;
29306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29307 if (!SWIG_IsOK(res1)) {
29308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29309 }
29310 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29311 {
29312 PyThreadState* __tstate = wxPyBeginAllowThreads();
29313 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
29314 wxPyEndAllowThreads(__tstate);
29315 if (PyErr_Occurred()) SWIG_fail;
29316 }
29317 {
29318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29319 }
29320 return resultobj;
29321 fail:
29322 return NULL;
29323 }
29324
29325
29326 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29327 PyObject *resultobj = 0;
29328 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29329 bool arg2 ;
29330 void *argp1 = 0 ;
29331 int res1 = 0 ;
29332 bool val2 ;
29333 int ecode2 = 0 ;
29334 PyObject * obj0 = 0 ;
29335 PyObject * obj1 = 0 ;
29336 char * kwnames[] = {
29337 (char *) "self",(char *) "forward", NULL
29338 };
29339
29340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
29341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29342 if (!SWIG_IsOK(res1)) {
29343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29344 }
29345 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29347 if (!SWIG_IsOK(ecode2)) {
29348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
29349 }
29350 arg2 = static_cast< bool >(val2);
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 (arg1)->SetDirection(arg2);
29354 wxPyEndAllowThreads(__tstate);
29355 if (PyErr_Occurred()) SWIG_fail;
29356 }
29357 resultobj = SWIG_Py_Void();
29358 return resultobj;
29359 fail:
29360 return NULL;
29361 }
29362
29363
29364 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29365 PyObject *resultobj = 0;
29366 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29367 bool result;
29368 void *argp1 = 0 ;
29369 int res1 = 0 ;
29370 PyObject *swig_obj[1] ;
29371
29372 if (!args) SWIG_fail;
29373 swig_obj[0] = args;
29374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29375 if (!SWIG_IsOK(res1)) {
29376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29377 }
29378 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29379 {
29380 PyThreadState* __tstate = wxPyBeginAllowThreads();
29381 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
29382 wxPyEndAllowThreads(__tstate);
29383 if (PyErr_Occurred()) SWIG_fail;
29384 }
29385 {
29386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29387 }
29388 return resultobj;
29389 fail:
29390 return NULL;
29391 }
29392
29393
29394 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29395 PyObject *resultobj = 0;
29396 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29397 bool arg2 ;
29398 void *argp1 = 0 ;
29399 int res1 = 0 ;
29400 bool val2 ;
29401 int ecode2 = 0 ;
29402 PyObject * obj0 = 0 ;
29403 PyObject * obj1 = 0 ;
29404 char * kwnames[] = {
29405 (char *) "self",(char *) "ischange", NULL
29406 };
29407
29408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
29409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29410 if (!SWIG_IsOK(res1)) {
29411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29412 }
29413 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29414 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29415 if (!SWIG_IsOK(ecode2)) {
29416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
29417 }
29418 arg2 = static_cast< bool >(val2);
29419 {
29420 PyThreadState* __tstate = wxPyBeginAllowThreads();
29421 (arg1)->SetWindowChange(arg2);
29422 wxPyEndAllowThreads(__tstate);
29423 if (PyErr_Occurred()) SWIG_fail;
29424 }
29425 resultobj = SWIG_Py_Void();
29426 return resultobj;
29427 fail:
29428 return NULL;
29429 }
29430
29431
29432 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29433 PyObject *resultobj = 0;
29434 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29435 bool result;
29436 void *argp1 = 0 ;
29437 int res1 = 0 ;
29438 PyObject *swig_obj[1] ;
29439
29440 if (!args) SWIG_fail;
29441 swig_obj[0] = args;
29442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29443 if (!SWIG_IsOK(res1)) {
29444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29445 }
29446 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29447 {
29448 PyThreadState* __tstate = wxPyBeginAllowThreads();
29449 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
29450 wxPyEndAllowThreads(__tstate);
29451 if (PyErr_Occurred()) SWIG_fail;
29452 }
29453 {
29454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29455 }
29456 return resultobj;
29457 fail:
29458 return NULL;
29459 }
29460
29461
29462 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29463 PyObject *resultobj = 0;
29464 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29465 bool arg2 ;
29466 void *argp1 = 0 ;
29467 int res1 = 0 ;
29468 bool val2 ;
29469 int ecode2 = 0 ;
29470 PyObject * obj0 = 0 ;
29471 PyObject * obj1 = 0 ;
29472 char * kwnames[] = {
29473 (char *) "self",(char *) "bIs", NULL
29474 };
29475
29476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
29477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29478 if (!SWIG_IsOK(res1)) {
29479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29480 }
29481 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29482 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29483 if (!SWIG_IsOK(ecode2)) {
29484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
29485 }
29486 arg2 = static_cast< bool >(val2);
29487 {
29488 PyThreadState* __tstate = wxPyBeginAllowThreads();
29489 (arg1)->SetFromTab(arg2);
29490 wxPyEndAllowThreads(__tstate);
29491 if (PyErr_Occurred()) SWIG_fail;
29492 }
29493 resultobj = SWIG_Py_Void();
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj = 0;
29502 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29503 long arg2 ;
29504 void *argp1 = 0 ;
29505 int res1 = 0 ;
29506 long val2 ;
29507 int ecode2 = 0 ;
29508 PyObject * obj0 = 0 ;
29509 PyObject * obj1 = 0 ;
29510 char * kwnames[] = {
29511 (char *) "self",(char *) "flags", NULL
29512 };
29513
29514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
29515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29516 if (!SWIG_IsOK(res1)) {
29517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29518 }
29519 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29520 ecode2 = SWIG_AsVal_long(obj1, &val2);
29521 if (!SWIG_IsOK(ecode2)) {
29522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
29523 }
29524 arg2 = static_cast< long >(val2);
29525 {
29526 PyThreadState* __tstate = wxPyBeginAllowThreads();
29527 (arg1)->SetFlags(arg2);
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 resultobj = SWIG_Py_Void();
29532 return resultobj;
29533 fail:
29534 return NULL;
29535 }
29536
29537
29538 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29539 PyObject *resultobj = 0;
29540 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29541 wxWindow *result = 0 ;
29542 void *argp1 = 0 ;
29543 int res1 = 0 ;
29544 PyObject *swig_obj[1] ;
29545
29546 if (!args) SWIG_fail;
29547 swig_obj[0] = args;
29548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29549 if (!SWIG_IsOK(res1)) {
29550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
29551 }
29552 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29553 {
29554 PyThreadState* __tstate = wxPyBeginAllowThreads();
29555 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29556 wxPyEndAllowThreads(__tstate);
29557 if (PyErr_Occurred()) SWIG_fail;
29558 }
29559 {
29560 resultobj = wxPyMake_wxObject(result, (bool)0);
29561 }
29562 return resultobj;
29563 fail:
29564 return NULL;
29565 }
29566
29567
29568 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29569 PyObject *resultobj = 0;
29570 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29571 wxWindow *arg2 = (wxWindow *) 0 ;
29572 void *argp1 = 0 ;
29573 int res1 = 0 ;
29574 void *argp2 = 0 ;
29575 int res2 = 0 ;
29576 PyObject * obj0 = 0 ;
29577 PyObject * obj1 = 0 ;
29578 char * kwnames[] = {
29579 (char *) "self",(char *) "win", NULL
29580 };
29581
29582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29584 if (!SWIG_IsOK(res1)) {
29585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29586 }
29587 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29589 if (!SWIG_IsOK(res2)) {
29590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29591 }
29592 arg2 = reinterpret_cast< wxWindow * >(argp2);
29593 {
29594 PyThreadState* __tstate = wxPyBeginAllowThreads();
29595 (arg1)->SetCurrentFocus(arg2);
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 resultobj = SWIG_Py_Void();
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29607 PyObject *obj;
29608 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29609 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29610 return SWIG_Py_Void();
29611 }
29612
29613 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29614 return SWIG_Python_InitShadowInstance(args);
29615 }
29616
29617 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29618 PyObject *resultobj = 0;
29619 wxWindow *arg1 = (wxWindow *) NULL ;
29620 wxWindowCreateEvent *result = 0 ;
29621 void *argp1 = 0 ;
29622 int res1 = 0 ;
29623 PyObject * obj0 = 0 ;
29624 char * kwnames[] = {
29625 (char *) "win", NULL
29626 };
29627
29628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29629 if (obj0) {
29630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29631 if (!SWIG_IsOK(res1)) {
29632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29633 }
29634 arg1 = reinterpret_cast< wxWindow * >(argp1);
29635 }
29636 {
29637 PyThreadState* __tstate = wxPyBeginAllowThreads();
29638 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29639 wxPyEndAllowThreads(__tstate);
29640 if (PyErr_Occurred()) SWIG_fail;
29641 }
29642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29643 return resultobj;
29644 fail:
29645 return NULL;
29646 }
29647
29648
29649 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29650 PyObject *resultobj = 0;
29651 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29652 wxWindow *result = 0 ;
29653 void *argp1 = 0 ;
29654 int res1 = 0 ;
29655 PyObject *swig_obj[1] ;
29656
29657 if (!args) SWIG_fail;
29658 swig_obj[0] = args;
29659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29660 if (!SWIG_IsOK(res1)) {
29661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29662 }
29663 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29664 {
29665 PyThreadState* __tstate = wxPyBeginAllowThreads();
29666 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29667 wxPyEndAllowThreads(__tstate);
29668 if (PyErr_Occurred()) SWIG_fail;
29669 }
29670 {
29671 resultobj = wxPyMake_wxObject(result, (bool)0);
29672 }
29673 return resultobj;
29674 fail:
29675 return NULL;
29676 }
29677
29678
29679 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29680 PyObject *obj;
29681 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29682 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29683 return SWIG_Py_Void();
29684 }
29685
29686 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29687 return SWIG_Python_InitShadowInstance(args);
29688 }
29689
29690 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29691 PyObject *resultobj = 0;
29692 wxWindow *arg1 = (wxWindow *) NULL ;
29693 wxWindowDestroyEvent *result = 0 ;
29694 void *argp1 = 0 ;
29695 int res1 = 0 ;
29696 PyObject * obj0 = 0 ;
29697 char * kwnames[] = {
29698 (char *) "win", NULL
29699 };
29700
29701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29702 if (obj0) {
29703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29704 if (!SWIG_IsOK(res1)) {
29705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29706 }
29707 arg1 = reinterpret_cast< wxWindow * >(argp1);
29708 }
29709 {
29710 PyThreadState* __tstate = wxPyBeginAllowThreads();
29711 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29712 wxPyEndAllowThreads(__tstate);
29713 if (PyErr_Occurred()) SWIG_fail;
29714 }
29715 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29716 return resultobj;
29717 fail:
29718 return NULL;
29719 }
29720
29721
29722 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29723 PyObject *resultobj = 0;
29724 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29725 wxWindow *result = 0 ;
29726 void *argp1 = 0 ;
29727 int res1 = 0 ;
29728 PyObject *swig_obj[1] ;
29729
29730 if (!args) SWIG_fail;
29731 swig_obj[0] = args;
29732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29733 if (!SWIG_IsOK(res1)) {
29734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29735 }
29736 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29737 {
29738 PyThreadState* __tstate = wxPyBeginAllowThreads();
29739 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29740 wxPyEndAllowThreads(__tstate);
29741 if (PyErr_Occurred()) SWIG_fail;
29742 }
29743 {
29744 resultobj = wxPyMake_wxObject(result, (bool)0);
29745 }
29746 return resultobj;
29747 fail:
29748 return NULL;
29749 }
29750
29751
29752 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29753 PyObject *obj;
29754 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29755 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29756 return SWIG_Py_Void();
29757 }
29758
29759 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29760 return SWIG_Python_InitShadowInstance(args);
29761 }
29762
29763 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29764 PyObject *resultobj = 0;
29765 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29766 int arg2 = (int) 0 ;
29767 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29768 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29769 wxContextMenuEvent *result = 0 ;
29770 int val1 ;
29771 int ecode1 = 0 ;
29772 int val2 ;
29773 int ecode2 = 0 ;
29774 wxPoint temp3 ;
29775 PyObject * obj0 = 0 ;
29776 PyObject * obj1 = 0 ;
29777 PyObject * obj2 = 0 ;
29778 char * kwnames[] = {
29779 (char *) "type",(char *) "winid",(char *) "pt", NULL
29780 };
29781
29782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29783 if (obj0) {
29784 ecode1 = SWIG_AsVal_int(obj0, &val1);
29785 if (!SWIG_IsOK(ecode1)) {
29786 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29787 }
29788 arg1 = static_cast< wxEventType >(val1);
29789 }
29790 if (obj1) {
29791 ecode2 = SWIG_AsVal_int(obj1, &val2);
29792 if (!SWIG_IsOK(ecode2)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29794 }
29795 arg2 = static_cast< int >(val2);
29796 }
29797 if (obj2) {
29798 {
29799 arg3 = &temp3;
29800 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29801 }
29802 }
29803 {
29804 PyThreadState* __tstate = wxPyBeginAllowThreads();
29805 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29810 return resultobj;
29811 fail:
29812 return NULL;
29813 }
29814
29815
29816 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29817 PyObject *resultobj = 0;
29818 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29819 wxPoint *result = 0 ;
29820 void *argp1 = 0 ;
29821 int res1 = 0 ;
29822 PyObject *swig_obj[1] ;
29823
29824 if (!args) SWIG_fail;
29825 swig_obj[0] = args;
29826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29827 if (!SWIG_IsOK(res1)) {
29828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29829 }
29830 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29831 {
29832 PyThreadState* __tstate = wxPyBeginAllowThreads();
29833 {
29834 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29835 result = (wxPoint *) &_result_ref;
29836 }
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29848 PyObject *resultobj = 0;
29849 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29850 wxPoint *arg2 = 0 ;
29851 void *argp1 = 0 ;
29852 int res1 = 0 ;
29853 wxPoint temp2 ;
29854 PyObject * obj0 = 0 ;
29855 PyObject * obj1 = 0 ;
29856 char * kwnames[] = {
29857 (char *) "self",(char *) "pos", NULL
29858 };
29859
29860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29862 if (!SWIG_IsOK(res1)) {
29863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29864 }
29865 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29866 {
29867 arg2 = &temp2;
29868 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29869 }
29870 {
29871 PyThreadState* __tstate = wxPyBeginAllowThreads();
29872 (arg1)->SetPosition((wxPoint const &)*arg2);
29873 wxPyEndAllowThreads(__tstate);
29874 if (PyErr_Occurred()) SWIG_fail;
29875 }
29876 resultobj = SWIG_Py_Void();
29877 return resultobj;
29878 fail:
29879 return NULL;
29880 }
29881
29882
29883 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29884 PyObject *obj;
29885 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29886 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29887 return SWIG_Py_Void();
29888 }
29889
29890 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 return SWIG_Python_InitShadowInstance(args);
29892 }
29893
29894 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29895 PyObject *resultobj = 0;
29896 wxIdleEvent *result = 0 ;
29897
29898 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29899 {
29900 PyThreadState* __tstate = wxPyBeginAllowThreads();
29901 result = (wxIdleEvent *)new wxIdleEvent();
29902 wxPyEndAllowThreads(__tstate);
29903 if (PyErr_Occurred()) SWIG_fail;
29904 }
29905 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29906 return resultobj;
29907 fail:
29908 return NULL;
29909 }
29910
29911
29912 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29913 PyObject *resultobj = 0;
29914 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29915 bool arg2 = (bool) true ;
29916 void *argp1 = 0 ;
29917 int res1 = 0 ;
29918 bool val2 ;
29919 int ecode2 = 0 ;
29920 PyObject * obj0 = 0 ;
29921 PyObject * obj1 = 0 ;
29922 char * kwnames[] = {
29923 (char *) "self",(char *) "needMore", NULL
29924 };
29925
29926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29928 if (!SWIG_IsOK(res1)) {
29929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29930 }
29931 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29932 if (obj1) {
29933 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29934 if (!SWIG_IsOK(ecode2)) {
29935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29936 }
29937 arg2 = static_cast< bool >(val2);
29938 }
29939 {
29940 PyThreadState* __tstate = wxPyBeginAllowThreads();
29941 (arg1)->RequestMore(arg2);
29942 wxPyEndAllowThreads(__tstate);
29943 if (PyErr_Occurred()) SWIG_fail;
29944 }
29945 resultobj = SWIG_Py_Void();
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29953 PyObject *resultobj = 0;
29954 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29955 bool result;
29956 void *argp1 = 0 ;
29957 int res1 = 0 ;
29958 PyObject *swig_obj[1] ;
29959
29960 if (!args) SWIG_fail;
29961 swig_obj[0] = args;
29962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29963 if (!SWIG_IsOK(res1)) {
29964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29965 }
29966 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29967 {
29968 PyThreadState* __tstate = wxPyBeginAllowThreads();
29969 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29970 wxPyEndAllowThreads(__tstate);
29971 if (PyErr_Occurred()) SWIG_fail;
29972 }
29973 {
29974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29975 }
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj = 0;
29984 wxIdleMode arg1 ;
29985 int val1 ;
29986 int ecode1 = 0 ;
29987 PyObject * obj0 = 0 ;
29988 char * kwnames[] = {
29989 (char *) "mode", NULL
29990 };
29991
29992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29993 ecode1 = SWIG_AsVal_int(obj0, &val1);
29994 if (!SWIG_IsOK(ecode1)) {
29995 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29996 }
29997 arg1 = static_cast< wxIdleMode >(val1);
29998 {
29999 PyThreadState* __tstate = wxPyBeginAllowThreads();
30000 wxIdleEvent::SetMode(arg1);
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 resultobj = SWIG_Py_Void();
30005 return resultobj;
30006 fail:
30007 return NULL;
30008 }
30009
30010
30011 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30012 PyObject *resultobj = 0;
30013 wxIdleMode result;
30014
30015 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
30016 {
30017 PyThreadState* __tstate = wxPyBeginAllowThreads();
30018 result = (wxIdleMode)wxIdleEvent::GetMode();
30019 wxPyEndAllowThreads(__tstate);
30020 if (PyErr_Occurred()) SWIG_fail;
30021 }
30022 resultobj = SWIG_From_int(static_cast< int >(result));
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30030 PyObject *resultobj = 0;
30031 wxWindow *arg1 = (wxWindow *) 0 ;
30032 bool result;
30033 void *argp1 = 0 ;
30034 int res1 = 0 ;
30035 PyObject * obj0 = 0 ;
30036 char * kwnames[] = {
30037 (char *) "win", NULL
30038 };
30039
30040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
30041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30042 if (!SWIG_IsOK(res1)) {
30043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
30044 }
30045 arg1 = reinterpret_cast< wxWindow * >(argp1);
30046 {
30047 PyThreadState* __tstate = wxPyBeginAllowThreads();
30048 result = (bool)wxIdleEvent::CanSend(arg1);
30049 wxPyEndAllowThreads(__tstate);
30050 if (PyErr_Occurred()) SWIG_fail;
30051 }
30052 {
30053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30054 }
30055 return resultobj;
30056 fail:
30057 return NULL;
30058 }
30059
30060
30061 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30062 PyObject *obj;
30063 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30064 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
30065 return SWIG_Py_Void();
30066 }
30067
30068 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30069 return SWIG_Python_InitShadowInstance(args);
30070 }
30071
30072 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30073 PyObject *resultobj = 0;
30074 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30075 int arg2 = (int) 0 ;
30076 wxClipboardTextEvent *result = 0 ;
30077 int val1 ;
30078 int ecode1 = 0 ;
30079 int val2 ;
30080 int ecode2 = 0 ;
30081 PyObject * obj0 = 0 ;
30082 PyObject * obj1 = 0 ;
30083 char * kwnames[] = {
30084 (char *) "type",(char *) "winid", NULL
30085 };
30086
30087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30088 if (obj0) {
30089 ecode1 = SWIG_AsVal_int(obj0, &val1);
30090 if (!SWIG_IsOK(ecode1)) {
30091 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30092 }
30093 arg1 = static_cast< wxEventType >(val1);
30094 }
30095 if (obj1) {
30096 ecode2 = SWIG_AsVal_int(obj1, &val2);
30097 if (!SWIG_IsOK(ecode2)) {
30098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
30099 }
30100 arg2 = static_cast< int >(val2);
30101 }
30102 {
30103 PyThreadState* __tstate = wxPyBeginAllowThreads();
30104 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
30105 wxPyEndAllowThreads(__tstate);
30106 if (PyErr_Occurred()) SWIG_fail;
30107 }
30108 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
30109 return resultobj;
30110 fail:
30111 return NULL;
30112 }
30113
30114
30115 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30116 PyObject *obj;
30117 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30118 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
30119 return SWIG_Py_Void();
30120 }
30121
30122 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30123 return SWIG_Python_InitShadowInstance(args);
30124 }
30125
30126 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30127 PyObject *resultobj = 0;
30128 int arg1 = (int) 0 ;
30129 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
30130 wxPyEvent *result = 0 ;
30131 int val1 ;
30132 int ecode1 = 0 ;
30133 int val2 ;
30134 int ecode2 = 0 ;
30135 PyObject * obj0 = 0 ;
30136 PyObject * obj1 = 0 ;
30137 char * kwnames[] = {
30138 (char *) "winid",(char *) "eventType", NULL
30139 };
30140
30141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30142 if (obj0) {
30143 ecode1 = SWIG_AsVal_int(obj0, &val1);
30144 if (!SWIG_IsOK(ecode1)) {
30145 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
30146 }
30147 arg1 = static_cast< int >(val1);
30148 }
30149 if (obj1) {
30150 ecode2 = SWIG_AsVal_int(obj1, &val2);
30151 if (!SWIG_IsOK(ecode2)) {
30152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
30153 }
30154 arg2 = static_cast< wxEventType >(val2);
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30170 PyObject *resultobj = 0;
30171 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30172 void *argp1 = 0 ;
30173 int res1 = 0 ;
30174 PyObject *swig_obj[1] ;
30175
30176 if (!args) SWIG_fail;
30177 swig_obj[0] = args;
30178 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
30179 if (!SWIG_IsOK(res1)) {
30180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30181 }
30182 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30183 {
30184 PyThreadState* __tstate = wxPyBeginAllowThreads();
30185 delete arg1;
30186
30187 wxPyEndAllowThreads(__tstate);
30188 if (PyErr_Occurred()) SWIG_fail;
30189 }
30190 resultobj = SWIG_Py_Void();
30191 return resultobj;
30192 fail:
30193 return NULL;
30194 }
30195
30196
30197 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30198 PyObject *resultobj = 0;
30199 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30200 PyObject *arg2 = (PyObject *) 0 ;
30201 void *argp1 = 0 ;
30202 int res1 = 0 ;
30203 PyObject * obj0 = 0 ;
30204 PyObject * obj1 = 0 ;
30205 char * kwnames[] = {
30206 (char *) "self",(char *) "self", NULL
30207 };
30208
30209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30211 if (!SWIG_IsOK(res1)) {
30212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30213 }
30214 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30215 arg2 = obj1;
30216 {
30217 PyThreadState* __tstate = wxPyBeginAllowThreads();
30218 (arg1)->SetSelf(arg2);
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 resultobj = SWIG_Py_Void();
30223 return resultobj;
30224 fail:
30225 return NULL;
30226 }
30227
30228
30229 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30230 PyObject *resultobj = 0;
30231 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
30232 PyObject *result = 0 ;
30233 void *argp1 = 0 ;
30234 int res1 = 0 ;
30235 PyObject *swig_obj[1] ;
30236
30237 if (!args) SWIG_fail;
30238 swig_obj[0] = args;
30239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
30240 if (!SWIG_IsOK(res1)) {
30241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
30242 }
30243 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
30244 {
30245 PyThreadState* __tstate = wxPyBeginAllowThreads();
30246 result = (PyObject *)(arg1)->GetSelf();
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 resultobj = result;
30251 return resultobj;
30252 fail:
30253 return NULL;
30254 }
30255
30256
30257 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30258 PyObject *obj;
30259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30260 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
30261 return SWIG_Py_Void();
30262 }
30263
30264 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30265 return SWIG_Python_InitShadowInstance(args);
30266 }
30267
30268 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30269 PyObject *resultobj = 0;
30270 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
30271 int arg2 = (int) 0 ;
30272 wxPyCommandEvent *result = 0 ;
30273 int val1 ;
30274 int ecode1 = 0 ;
30275 int val2 ;
30276 int ecode2 = 0 ;
30277 PyObject * obj0 = 0 ;
30278 PyObject * obj1 = 0 ;
30279 char * kwnames[] = {
30280 (char *) "eventType",(char *) "id", NULL
30281 };
30282
30283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
30284 if (obj0) {
30285 ecode1 = SWIG_AsVal_int(obj0, &val1);
30286 if (!SWIG_IsOK(ecode1)) {
30287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
30288 }
30289 arg1 = static_cast< wxEventType >(val1);
30290 }
30291 if (obj1) {
30292 ecode2 = SWIG_AsVal_int(obj1, &val2);
30293 if (!SWIG_IsOK(ecode2)) {
30294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
30295 }
30296 arg2 = static_cast< int >(val2);
30297 }
30298 {
30299 PyThreadState* __tstate = wxPyBeginAllowThreads();
30300 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
30301 wxPyEndAllowThreads(__tstate);
30302 if (PyErr_Occurred()) SWIG_fail;
30303 }
30304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30312 PyObject *resultobj = 0;
30313 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30314 void *argp1 = 0 ;
30315 int res1 = 0 ;
30316 PyObject *swig_obj[1] ;
30317
30318 if (!args) SWIG_fail;
30319 swig_obj[0] = args;
30320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
30321 if (!SWIG_IsOK(res1)) {
30322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30323 }
30324 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30325 {
30326 PyThreadState* __tstate = wxPyBeginAllowThreads();
30327 delete arg1;
30328
30329 wxPyEndAllowThreads(__tstate);
30330 if (PyErr_Occurred()) SWIG_fail;
30331 }
30332 resultobj = SWIG_Py_Void();
30333 return resultobj;
30334 fail:
30335 return NULL;
30336 }
30337
30338
30339 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30340 PyObject *resultobj = 0;
30341 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30342 PyObject *arg2 = (PyObject *) 0 ;
30343 void *argp1 = 0 ;
30344 int res1 = 0 ;
30345 PyObject * obj0 = 0 ;
30346 PyObject * obj1 = 0 ;
30347 char * kwnames[] = {
30348 (char *) "self",(char *) "self", NULL
30349 };
30350
30351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
30352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30353 if (!SWIG_IsOK(res1)) {
30354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30355 }
30356 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30357 arg2 = obj1;
30358 {
30359 PyThreadState* __tstate = wxPyBeginAllowThreads();
30360 (arg1)->SetSelf(arg2);
30361 wxPyEndAllowThreads(__tstate);
30362 if (PyErr_Occurred()) SWIG_fail;
30363 }
30364 resultobj = SWIG_Py_Void();
30365 return resultobj;
30366 fail:
30367 return NULL;
30368 }
30369
30370
30371 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30372 PyObject *resultobj = 0;
30373 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
30374 PyObject *result = 0 ;
30375 void *argp1 = 0 ;
30376 int res1 = 0 ;
30377 PyObject *swig_obj[1] ;
30378
30379 if (!args) SWIG_fail;
30380 swig_obj[0] = args;
30381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
30382 if (!SWIG_IsOK(res1)) {
30383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
30384 }
30385 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
30386 {
30387 PyThreadState* __tstate = wxPyBeginAllowThreads();
30388 result = (PyObject *)(arg1)->GetSelf();
30389 wxPyEndAllowThreads(__tstate);
30390 if (PyErr_Occurred()) SWIG_fail;
30391 }
30392 resultobj = result;
30393 return resultobj;
30394 fail:
30395 return NULL;
30396 }
30397
30398
30399 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30400 PyObject *obj;
30401 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30402 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
30403 return SWIG_Py_Void();
30404 }
30405
30406 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30407 return SWIG_Python_InitShadowInstance(args);
30408 }
30409
30410 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj = 0;
30412 wxWindow *arg1 = (wxWindow *) 0 ;
30413 wxDateTime *arg2 = 0 ;
30414 wxEventType arg3 ;
30415 wxDateEvent *result = 0 ;
30416 void *argp1 = 0 ;
30417 int res1 = 0 ;
30418 void *argp2 = 0 ;
30419 int res2 = 0 ;
30420 int val3 ;
30421 int ecode3 = 0 ;
30422 PyObject * obj0 = 0 ;
30423 PyObject * obj1 = 0 ;
30424 PyObject * obj2 = 0 ;
30425 char * kwnames[] = {
30426 (char *) "win",(char *) "dt",(char *) "type", NULL
30427 };
30428
30429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30431 if (!SWIG_IsOK(res1)) {
30432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
30433 }
30434 arg1 = reinterpret_cast< wxWindow * >(argp1);
30435 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30436 if (!SWIG_IsOK(res2)) {
30437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30438 }
30439 if (!argp2) {
30440 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30441 }
30442 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30443 ecode3 = SWIG_AsVal_int(obj2, &val3);
30444 if (!SWIG_IsOK(ecode3)) {
30445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
30446 }
30447 arg3 = static_cast< wxEventType >(val3);
30448 {
30449 PyThreadState* __tstate = wxPyBeginAllowThreads();
30450 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
30451 wxPyEndAllowThreads(__tstate);
30452 if (PyErr_Occurred()) SWIG_fail;
30453 }
30454 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
30455 return resultobj;
30456 fail:
30457 return NULL;
30458 }
30459
30460
30461 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30462 PyObject *resultobj = 0;
30463 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30464 wxDateTime *result = 0 ;
30465 void *argp1 = 0 ;
30466 int res1 = 0 ;
30467 PyObject *swig_obj[1] ;
30468
30469 if (!args) SWIG_fail;
30470 swig_obj[0] = args;
30471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30472 if (!SWIG_IsOK(res1)) {
30473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
30474 }
30475 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30476 {
30477 PyThreadState* __tstate = wxPyBeginAllowThreads();
30478 {
30479 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
30480 result = (wxDateTime *) &_result_ref;
30481 }
30482 wxPyEndAllowThreads(__tstate);
30483 if (PyErr_Occurred()) SWIG_fail;
30484 }
30485 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
30486 return resultobj;
30487 fail:
30488 return NULL;
30489 }
30490
30491
30492 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30493 PyObject *resultobj = 0;
30494 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
30495 wxDateTime *arg2 = 0 ;
30496 void *argp1 = 0 ;
30497 int res1 = 0 ;
30498 void *argp2 = 0 ;
30499 int res2 = 0 ;
30500 PyObject * obj0 = 0 ;
30501 PyObject * obj1 = 0 ;
30502 char * kwnames[] = {
30503 (char *) "self",(char *) "date", NULL
30504 };
30505
30506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
30507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
30508 if (!SWIG_IsOK(res1)) {
30509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
30510 }
30511 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
30512 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
30513 if (!SWIG_IsOK(res2)) {
30514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30515 }
30516 if (!argp2) {
30517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
30518 }
30519 arg2 = reinterpret_cast< wxDateTime * >(argp2);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 (arg1)->SetDate((wxDateTime const &)*arg2);
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 resultobj = SWIG_Py_Void();
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30534 PyObject *obj;
30535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30536 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
30537 return SWIG_Py_Void();
30538 }
30539
30540 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30541 return SWIG_Python_InitShadowInstance(args);
30542 }
30543
30544 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30545 PyObject *resultobj = 0;
30546 wxWindow *arg1 = (wxWindow *) 0 ;
30547 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
30548 wxEventBlocker *result = 0 ;
30549 void *argp1 = 0 ;
30550 int res1 = 0 ;
30551 int val2 ;
30552 int ecode2 = 0 ;
30553 PyObject * obj0 = 0 ;
30554 PyObject * obj1 = 0 ;
30555 char * kwnames[] = {
30556 (char *) "win",(char *) "type", NULL
30557 };
30558
30559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
30560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30561 if (!SWIG_IsOK(res1)) {
30562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
30563 }
30564 arg1 = reinterpret_cast< wxWindow * >(argp1);
30565 if (obj1) {
30566 ecode2 = SWIG_AsVal_int(obj1, &val2);
30567 if (!SWIG_IsOK(ecode2)) {
30568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
30569 }
30570 arg2 = static_cast< wxEventType >(val2);
30571 }
30572 {
30573 PyThreadState* __tstate = wxPyBeginAllowThreads();
30574 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
30575 wxPyEndAllowThreads(__tstate);
30576 if (PyErr_Occurred()) SWIG_fail;
30577 }
30578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
30579 return resultobj;
30580 fail:
30581 return NULL;
30582 }
30583
30584
30585 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30586 PyObject *resultobj = 0;
30587 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30588 void *argp1 = 0 ;
30589 int res1 = 0 ;
30590 PyObject *swig_obj[1] ;
30591
30592 if (!args) SWIG_fail;
30593 swig_obj[0] = args;
30594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
30595 if (!SWIG_IsOK(res1)) {
30596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30597 }
30598 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30599 {
30600 PyThreadState* __tstate = wxPyBeginAllowThreads();
30601 delete arg1;
30602
30603 wxPyEndAllowThreads(__tstate);
30604 if (PyErr_Occurred()) SWIG_fail;
30605 }
30606 resultobj = SWIG_Py_Void();
30607 return resultobj;
30608 fail:
30609 return NULL;
30610 }
30611
30612
30613 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30614 PyObject *resultobj = 0;
30615 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30616 wxEventType arg2 ;
30617 void *argp1 = 0 ;
30618 int res1 = 0 ;
30619 int val2 ;
30620 int ecode2 = 0 ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 char * kwnames[] = {
30624 (char *) "self",(char *) "type", NULL
30625 };
30626
30627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30629 if (!SWIG_IsOK(res1)) {
30630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30631 }
30632 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30633 ecode2 = SWIG_AsVal_int(obj1, &val2);
30634 if (!SWIG_IsOK(ecode2)) {
30635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30636 }
30637 arg2 = static_cast< wxEventType >(val2);
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 (arg1)->Block(arg2);
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 resultobj = SWIG_Py_Void();
30645 return resultobj;
30646 fail:
30647 return NULL;
30648 }
30649
30650
30651 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30652 PyObject *obj;
30653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30654 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30655 return SWIG_Py_Void();
30656 }
30657
30658 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30659 return SWIG_Python_InitShadowInstance(args);
30660 }
30661
30662 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30663 PyObject *resultobj = 0;
30664 wxPyApp *result = 0 ;
30665
30666 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30667 {
30668 PyThreadState* __tstate = wxPyBeginAllowThreads();
30669 result = (wxPyApp *)new_wxPyApp();
30670 wxPyEndAllowThreads(__tstate);
30671 if (PyErr_Occurred()) SWIG_fail;
30672 }
30673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30674 return resultobj;
30675 fail:
30676 return NULL;
30677 }
30678
30679
30680 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30681 PyObject *resultobj = 0;
30682 wxPyApp *arg1 = (wxPyApp *) 0 ;
30683 void *argp1 = 0 ;
30684 int res1 = 0 ;
30685 PyObject *swig_obj[1] ;
30686
30687 if (!args) SWIG_fail;
30688 swig_obj[0] = args;
30689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30690 if (!SWIG_IsOK(res1)) {
30691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30692 }
30693 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30694 {
30695 PyThreadState* __tstate = wxPyBeginAllowThreads();
30696 delete arg1;
30697
30698 wxPyEndAllowThreads(__tstate);
30699 if (PyErr_Occurred()) SWIG_fail;
30700 }
30701 resultobj = SWIG_Py_Void();
30702 return resultobj;
30703 fail:
30704 return NULL;
30705 }
30706
30707
30708 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30709 PyObject *resultobj = 0;
30710 wxPyApp *arg1 = (wxPyApp *) 0 ;
30711 PyObject *arg2 = (PyObject *) 0 ;
30712 PyObject *arg3 = (PyObject *) 0 ;
30713 bool arg4 = (bool) false ;
30714 void *argp1 = 0 ;
30715 int res1 = 0 ;
30716 bool val4 ;
30717 int ecode4 = 0 ;
30718 PyObject * obj0 = 0 ;
30719 PyObject * obj1 = 0 ;
30720 PyObject * obj2 = 0 ;
30721 PyObject * obj3 = 0 ;
30722 char * kwnames[] = {
30723 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30724 };
30725
30726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30728 if (!SWIG_IsOK(res1)) {
30729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30730 }
30731 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30732 arg2 = obj1;
30733 arg3 = obj2;
30734 if (obj3) {
30735 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30736 if (!SWIG_IsOK(ecode4)) {
30737 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30738 }
30739 arg4 = static_cast< bool >(val4);
30740 }
30741 {
30742 PyThreadState* __tstate = wxPyBeginAllowThreads();
30743 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30744 wxPyEndAllowThreads(__tstate);
30745 if (PyErr_Occurred()) SWIG_fail;
30746 }
30747 resultobj = SWIG_Py_Void();
30748 return resultobj;
30749 fail:
30750 return NULL;
30751 }
30752
30753
30754 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30755 PyObject *resultobj = 0;
30756 wxPyApp *arg1 = (wxPyApp *) 0 ;
30757 wxString result;
30758 void *argp1 = 0 ;
30759 int res1 = 0 ;
30760 PyObject *swig_obj[1] ;
30761
30762 if (!args) SWIG_fail;
30763 swig_obj[0] = args;
30764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30765 if (!SWIG_IsOK(res1)) {
30766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30767 }
30768 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30769 {
30770 PyThreadState* __tstate = wxPyBeginAllowThreads();
30771 result = ((wxPyApp const *)arg1)->GetAppName();
30772 wxPyEndAllowThreads(__tstate);
30773 if (PyErr_Occurred()) SWIG_fail;
30774 }
30775 {
30776 #if wxUSE_UNICODE
30777 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30778 #else
30779 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30780 #endif
30781 }
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30789 PyObject *resultobj = 0;
30790 wxPyApp *arg1 = (wxPyApp *) 0 ;
30791 wxString *arg2 = 0 ;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 bool temp2 = false ;
30795 PyObject * obj0 = 0 ;
30796 PyObject * obj1 = 0 ;
30797 char * kwnames[] = {
30798 (char *) "self",(char *) "name", NULL
30799 };
30800
30801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30803 if (!SWIG_IsOK(res1)) {
30804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30805 }
30806 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30807 {
30808 arg2 = wxString_in_helper(obj1);
30809 if (arg2 == NULL) SWIG_fail;
30810 temp2 = true;
30811 }
30812 {
30813 PyThreadState* __tstate = wxPyBeginAllowThreads();
30814 (arg1)->SetAppName((wxString const &)*arg2);
30815 wxPyEndAllowThreads(__tstate);
30816 if (PyErr_Occurred()) SWIG_fail;
30817 }
30818 resultobj = SWIG_Py_Void();
30819 {
30820 if (temp2)
30821 delete arg2;
30822 }
30823 return resultobj;
30824 fail:
30825 {
30826 if (temp2)
30827 delete arg2;
30828 }
30829 return NULL;
30830 }
30831
30832
30833 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30834 PyObject *resultobj = 0;
30835 wxPyApp *arg1 = (wxPyApp *) 0 ;
30836 wxString result;
30837 void *argp1 = 0 ;
30838 int res1 = 0 ;
30839 PyObject *swig_obj[1] ;
30840
30841 if (!args) SWIG_fail;
30842 swig_obj[0] = args;
30843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30844 if (!SWIG_IsOK(res1)) {
30845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30846 }
30847 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30848 {
30849 PyThreadState* __tstate = wxPyBeginAllowThreads();
30850 result = ((wxPyApp const *)arg1)->GetClassName();
30851 wxPyEndAllowThreads(__tstate);
30852 if (PyErr_Occurred()) SWIG_fail;
30853 }
30854 {
30855 #if wxUSE_UNICODE
30856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30857 #else
30858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30859 #endif
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj = 0;
30869 wxPyApp *arg1 = (wxPyApp *) 0 ;
30870 wxString *arg2 = 0 ;
30871 void *argp1 = 0 ;
30872 int res1 = 0 ;
30873 bool temp2 = false ;
30874 PyObject * obj0 = 0 ;
30875 PyObject * obj1 = 0 ;
30876 char * kwnames[] = {
30877 (char *) "self",(char *) "name", NULL
30878 };
30879
30880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30882 if (!SWIG_IsOK(res1)) {
30883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30884 }
30885 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30886 {
30887 arg2 = wxString_in_helper(obj1);
30888 if (arg2 == NULL) SWIG_fail;
30889 temp2 = true;
30890 }
30891 {
30892 PyThreadState* __tstate = wxPyBeginAllowThreads();
30893 (arg1)->SetClassName((wxString const &)*arg2);
30894 wxPyEndAllowThreads(__tstate);
30895 if (PyErr_Occurred()) SWIG_fail;
30896 }
30897 resultobj = SWIG_Py_Void();
30898 {
30899 if (temp2)
30900 delete arg2;
30901 }
30902 return resultobj;
30903 fail:
30904 {
30905 if (temp2)
30906 delete arg2;
30907 }
30908 return NULL;
30909 }
30910
30911
30912 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30913 PyObject *resultobj = 0;
30914 wxPyApp *arg1 = (wxPyApp *) 0 ;
30915 wxString *result = 0 ;
30916 void *argp1 = 0 ;
30917 int res1 = 0 ;
30918 PyObject *swig_obj[1] ;
30919
30920 if (!args) SWIG_fail;
30921 swig_obj[0] = args;
30922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30923 if (!SWIG_IsOK(res1)) {
30924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30925 }
30926 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30927 {
30928 PyThreadState* __tstate = wxPyBeginAllowThreads();
30929 {
30930 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30931 result = (wxString *) &_result_ref;
30932 }
30933 wxPyEndAllowThreads(__tstate);
30934 if (PyErr_Occurred()) SWIG_fail;
30935 }
30936 {
30937 #if wxUSE_UNICODE
30938 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30939 #else
30940 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30941 #endif
30942 }
30943 return resultobj;
30944 fail:
30945 return NULL;
30946 }
30947
30948
30949 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30950 PyObject *resultobj = 0;
30951 wxPyApp *arg1 = (wxPyApp *) 0 ;
30952 wxString *arg2 = 0 ;
30953 void *argp1 = 0 ;
30954 int res1 = 0 ;
30955 bool temp2 = false ;
30956 PyObject * obj0 = 0 ;
30957 PyObject * obj1 = 0 ;
30958 char * kwnames[] = {
30959 (char *) "self",(char *) "name", NULL
30960 };
30961
30962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30964 if (!SWIG_IsOK(res1)) {
30965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30966 }
30967 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30968 {
30969 arg2 = wxString_in_helper(obj1);
30970 if (arg2 == NULL) SWIG_fail;
30971 temp2 = true;
30972 }
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 (arg1)->SetVendorName((wxString const &)*arg2);
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_Py_Void();
30980 {
30981 if (temp2)
30982 delete arg2;
30983 }
30984 return resultobj;
30985 fail:
30986 {
30987 if (temp2)
30988 delete arg2;
30989 }
30990 return NULL;
30991 }
30992
30993
30994 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30995 PyObject *resultobj = 0;
30996 wxPyApp *arg1 = (wxPyApp *) 0 ;
30997 wxAppTraits *result = 0 ;
30998 void *argp1 = 0 ;
30999 int res1 = 0 ;
31000 PyObject *swig_obj[1] ;
31001
31002 if (!args) SWIG_fail;
31003 swig_obj[0] = args;
31004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31005 if (!SWIG_IsOK(res1)) {
31006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
31007 }
31008 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31009 {
31010 PyThreadState* __tstate = wxPyBeginAllowThreads();
31011 result = (wxAppTraits *)(arg1)->GetTraits();
31012 wxPyEndAllowThreads(__tstate);
31013 if (PyErr_Occurred()) SWIG_fail;
31014 }
31015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
31016 return resultobj;
31017 fail:
31018 return NULL;
31019 }
31020
31021
31022 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31023 PyObject *resultobj = 0;
31024 wxPyApp *arg1 = (wxPyApp *) 0 ;
31025 void *argp1 = 0 ;
31026 int res1 = 0 ;
31027 PyObject *swig_obj[1] ;
31028
31029 if (!args) SWIG_fail;
31030 swig_obj[0] = args;
31031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31032 if (!SWIG_IsOK(res1)) {
31033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31034 }
31035 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 (arg1)->ProcessPendingEvents();
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_Py_Void();
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31050 PyObject *resultobj = 0;
31051 wxPyApp *arg1 = (wxPyApp *) 0 ;
31052 bool arg2 = (bool) false ;
31053 bool result;
31054 void *argp1 = 0 ;
31055 int res1 = 0 ;
31056 bool val2 ;
31057 int ecode2 = 0 ;
31058 PyObject * obj0 = 0 ;
31059 PyObject * obj1 = 0 ;
31060 char * kwnames[] = {
31061 (char *) "self",(char *) "onlyIfNeeded", NULL
31062 };
31063
31064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
31065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31066 if (!SWIG_IsOK(res1)) {
31067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
31068 }
31069 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31070 if (obj1) {
31071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31072 if (!SWIG_IsOK(ecode2)) {
31073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
31074 }
31075 arg2 = static_cast< bool >(val2);
31076 }
31077 {
31078 PyThreadState* __tstate = wxPyBeginAllowThreads();
31079 result = (bool)(arg1)->Yield(arg2);
31080 wxPyEndAllowThreads(__tstate);
31081 if (PyErr_Occurred()) SWIG_fail;
31082 }
31083 {
31084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31085 }
31086 return resultobj;
31087 fail:
31088 return NULL;
31089 }
31090
31091
31092 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31093 PyObject *resultobj = 0;
31094 wxPyApp *arg1 = (wxPyApp *) 0 ;
31095 void *argp1 = 0 ;
31096 int res1 = 0 ;
31097 PyObject *swig_obj[1] ;
31098
31099 if (!args) SWIG_fail;
31100 swig_obj[0] = args;
31101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31102 if (!SWIG_IsOK(res1)) {
31103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31104 }
31105 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31106 {
31107 PyThreadState* __tstate = wxPyBeginAllowThreads();
31108 (arg1)->WakeUpIdle();
31109 wxPyEndAllowThreads(__tstate);
31110 if (PyErr_Occurred()) SWIG_fail;
31111 }
31112 resultobj = SWIG_Py_Void();
31113 return resultobj;
31114 fail:
31115 return NULL;
31116 }
31117
31118
31119 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31120 PyObject *resultobj = 0;
31121 bool result;
31122
31123 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
31124 {
31125 PyThreadState* __tstate = wxPyBeginAllowThreads();
31126 result = (bool)wxPyApp::IsMainLoopRunning();
31127 wxPyEndAllowThreads(__tstate);
31128 if (PyErr_Occurred()) SWIG_fail;
31129 }
31130 {
31131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31132 }
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31140 PyObject *resultobj = 0;
31141 wxPyApp *arg1 = (wxPyApp *) 0 ;
31142 int result;
31143 void *argp1 = 0 ;
31144 int res1 = 0 ;
31145 PyObject *swig_obj[1] ;
31146
31147 if (!args) SWIG_fail;
31148 swig_obj[0] = args;
31149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31150 if (!SWIG_IsOK(res1)) {
31151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31152 }
31153 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 result = (int)(arg1)->MainLoop();
31157 wxPyEndAllowThreads(__tstate);
31158 if (PyErr_Occurred()) SWIG_fail;
31159 }
31160 resultobj = SWIG_From_int(static_cast< int >(result));
31161 return resultobj;
31162 fail:
31163 return NULL;
31164 }
31165
31166
31167 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31168 PyObject *resultobj = 0;
31169 wxPyApp *arg1 = (wxPyApp *) 0 ;
31170 void *argp1 = 0 ;
31171 int res1 = 0 ;
31172 PyObject *swig_obj[1] ;
31173
31174 if (!args) SWIG_fail;
31175 swig_obj[0] = args;
31176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31177 if (!SWIG_IsOK(res1)) {
31178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
31179 }
31180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 (arg1)->Exit();
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_Py_Void();
31188 return resultobj;
31189 fail:
31190 return NULL;
31191 }
31192
31193
31194 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31195 PyObject *resultobj = 0;
31196 wxPyApp *arg1 = (wxPyApp *) 0 ;
31197 wxLayoutDirection result;
31198 void *argp1 = 0 ;
31199 int res1 = 0 ;
31200 PyObject *swig_obj[1] ;
31201
31202 if (!args) SWIG_fail;
31203 swig_obj[0] = args;
31204 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31205 if (!SWIG_IsOK(res1)) {
31206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31207 }
31208 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31209 {
31210 PyThreadState* __tstate = wxPyBeginAllowThreads();
31211 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
31212 wxPyEndAllowThreads(__tstate);
31213 if (PyErr_Occurred()) SWIG_fail;
31214 }
31215 resultobj = SWIG_From_int(static_cast< int >(result));
31216 return resultobj;
31217 fail:
31218 return NULL;
31219 }
31220
31221
31222 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31223 PyObject *resultobj = 0;
31224 wxPyApp *arg1 = (wxPyApp *) 0 ;
31225 void *argp1 = 0 ;
31226 int res1 = 0 ;
31227 PyObject *swig_obj[1] ;
31228
31229 if (!args) SWIG_fail;
31230 swig_obj[0] = args;
31231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31232 if (!SWIG_IsOK(res1)) {
31233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
31234 }
31235 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 (arg1)->ExitMainLoop();
31239 wxPyEndAllowThreads(__tstate);
31240 if (PyErr_Occurred()) SWIG_fail;
31241 }
31242 resultobj = SWIG_Py_Void();
31243 return resultobj;
31244 fail:
31245 return NULL;
31246 }
31247
31248
31249 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31250 PyObject *resultobj = 0;
31251 wxPyApp *arg1 = (wxPyApp *) 0 ;
31252 bool result;
31253 void *argp1 = 0 ;
31254 int res1 = 0 ;
31255 PyObject *swig_obj[1] ;
31256
31257 if (!args) SWIG_fail;
31258 swig_obj[0] = args;
31259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31260 if (!SWIG_IsOK(res1)) {
31261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
31262 }
31263 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31264 {
31265 PyThreadState* __tstate = wxPyBeginAllowThreads();
31266 result = (bool)(arg1)->Pending();
31267 wxPyEndAllowThreads(__tstate);
31268 if (PyErr_Occurred()) SWIG_fail;
31269 }
31270 {
31271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31272 }
31273 return resultobj;
31274 fail:
31275 return NULL;
31276 }
31277
31278
31279 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31280 PyObject *resultobj = 0;
31281 wxPyApp *arg1 = (wxPyApp *) 0 ;
31282 bool result;
31283 void *argp1 = 0 ;
31284 int res1 = 0 ;
31285 PyObject *swig_obj[1] ;
31286
31287 if (!args) SWIG_fail;
31288 swig_obj[0] = args;
31289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31290 if (!SWIG_IsOK(res1)) {
31291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
31292 }
31293 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31294 {
31295 PyThreadState* __tstate = wxPyBeginAllowThreads();
31296 result = (bool)(arg1)->Dispatch();
31297 wxPyEndAllowThreads(__tstate);
31298 if (PyErr_Occurred()) SWIG_fail;
31299 }
31300 {
31301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31302 }
31303 return resultobj;
31304 fail:
31305 return NULL;
31306 }
31307
31308
31309 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31310 PyObject *resultobj = 0;
31311 wxPyApp *arg1 = (wxPyApp *) 0 ;
31312 bool result;
31313 void *argp1 = 0 ;
31314 int res1 = 0 ;
31315 PyObject *swig_obj[1] ;
31316
31317 if (!args) SWIG_fail;
31318 swig_obj[0] = args;
31319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31320 if (!SWIG_IsOK(res1)) {
31321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
31322 }
31323 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31324 {
31325 PyThreadState* __tstate = wxPyBeginAllowThreads();
31326 result = (bool)(arg1)->ProcessIdle();
31327 wxPyEndAllowThreads(__tstate);
31328 if (PyErr_Occurred()) SWIG_fail;
31329 }
31330 {
31331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31332 }
31333 return resultobj;
31334 fail:
31335 return NULL;
31336 }
31337
31338
31339 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31340 PyObject *resultobj = 0;
31341 wxPyApp *arg1 = (wxPyApp *) 0 ;
31342 wxWindow *arg2 = (wxWindow *) 0 ;
31343 wxIdleEvent *arg3 = 0 ;
31344 bool result;
31345 void *argp1 = 0 ;
31346 int res1 = 0 ;
31347 void *argp2 = 0 ;
31348 int res2 = 0 ;
31349 void *argp3 = 0 ;
31350 int res3 = 0 ;
31351 PyObject * obj0 = 0 ;
31352 PyObject * obj1 = 0 ;
31353 PyObject * obj2 = 0 ;
31354 char * kwnames[] = {
31355 (char *) "self",(char *) "win",(char *) "event", NULL
31356 };
31357
31358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31360 if (!SWIG_IsOK(res1)) {
31361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
31362 }
31363 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31364 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31365 if (!SWIG_IsOK(res2)) {
31366 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
31367 }
31368 arg2 = reinterpret_cast< wxWindow * >(argp2);
31369 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
31370 if (!SWIG_IsOK(res3)) {
31371 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31372 }
31373 if (!argp3) {
31374 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
31375 }
31376 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
31377 {
31378 PyThreadState* __tstate = wxPyBeginAllowThreads();
31379 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
31380 wxPyEndAllowThreads(__tstate);
31381 if (PyErr_Occurred()) SWIG_fail;
31382 }
31383 {
31384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31385 }
31386 return resultobj;
31387 fail:
31388 return NULL;
31389 }
31390
31391
31392 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31393 PyObject *resultobj = 0;
31394 wxPyApp *arg1 = (wxPyApp *) 0 ;
31395 bool result;
31396 void *argp1 = 0 ;
31397 int res1 = 0 ;
31398 PyObject *swig_obj[1] ;
31399
31400 if (!args) SWIG_fail;
31401 swig_obj[0] = args;
31402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31403 if (!SWIG_IsOK(res1)) {
31404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31405 }
31406 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31407 {
31408 PyThreadState* __tstate = wxPyBeginAllowThreads();
31409 result = (bool)((wxPyApp const *)arg1)->IsActive();
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 {
31414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31415 }
31416 return resultobj;
31417 fail:
31418 return NULL;
31419 }
31420
31421
31422 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31423 PyObject *resultobj = 0;
31424 wxPyApp *arg1 = (wxPyApp *) 0 ;
31425 wxWindow *arg2 = (wxWindow *) 0 ;
31426 void *argp1 = 0 ;
31427 int res1 = 0 ;
31428 void *argp2 = 0 ;
31429 int res2 = 0 ;
31430 PyObject * obj0 = 0 ;
31431 PyObject * obj1 = 0 ;
31432 char * kwnames[] = {
31433 (char *) "self",(char *) "win", NULL
31434 };
31435
31436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
31437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31438 if (!SWIG_IsOK(res1)) {
31439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
31440 }
31441 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31442 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
31443 if (!SWIG_IsOK(res2)) {
31444 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
31445 }
31446 arg2 = reinterpret_cast< wxWindow * >(argp2);
31447 {
31448 PyThreadState* __tstate = wxPyBeginAllowThreads();
31449 (arg1)->SetTopWindow(arg2);
31450 wxPyEndAllowThreads(__tstate);
31451 if (PyErr_Occurred()) SWIG_fail;
31452 }
31453 resultobj = SWIG_Py_Void();
31454 return resultobj;
31455 fail:
31456 return NULL;
31457 }
31458
31459
31460 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31461 PyObject *resultobj = 0;
31462 wxPyApp *arg1 = (wxPyApp *) 0 ;
31463 wxWindow *result = 0 ;
31464 void *argp1 = 0 ;
31465 int res1 = 0 ;
31466 PyObject *swig_obj[1] ;
31467
31468 if (!args) SWIG_fail;
31469 swig_obj[0] = args;
31470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31471 if (!SWIG_IsOK(res1)) {
31472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31473 }
31474 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
31478 wxPyEndAllowThreads(__tstate);
31479 if (PyErr_Occurred()) SWIG_fail;
31480 }
31481 {
31482 resultobj = wxPyMake_wxObject(result, (bool)0);
31483 }
31484 return resultobj;
31485 fail:
31486 return NULL;
31487 }
31488
31489
31490 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31491 PyObject *resultobj = 0;
31492 wxPyApp *arg1 = (wxPyApp *) 0 ;
31493 bool arg2 ;
31494 void *argp1 = 0 ;
31495 int res1 = 0 ;
31496 bool val2 ;
31497 int ecode2 = 0 ;
31498 PyObject * obj0 = 0 ;
31499 PyObject * obj1 = 0 ;
31500 char * kwnames[] = {
31501 (char *) "self",(char *) "flag", NULL
31502 };
31503
31504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
31505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31506 if (!SWIG_IsOK(res1)) {
31507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
31508 }
31509 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31510 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31511 if (!SWIG_IsOK(ecode2)) {
31512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
31513 }
31514 arg2 = static_cast< bool >(val2);
31515 {
31516 PyThreadState* __tstate = wxPyBeginAllowThreads();
31517 (arg1)->SetExitOnFrameDelete(arg2);
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 resultobj = SWIG_Py_Void();
31522 return resultobj;
31523 fail:
31524 return NULL;
31525 }
31526
31527
31528 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31529 PyObject *resultobj = 0;
31530 wxPyApp *arg1 = (wxPyApp *) 0 ;
31531 bool result;
31532 void *argp1 = 0 ;
31533 int res1 = 0 ;
31534 PyObject *swig_obj[1] ;
31535
31536 if (!args) SWIG_fail;
31537 swig_obj[0] = args;
31538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31539 if (!SWIG_IsOK(res1)) {
31540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31541 }
31542 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31543 {
31544 PyThreadState* __tstate = wxPyBeginAllowThreads();
31545 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
31546 wxPyEndAllowThreads(__tstate);
31547 if (PyErr_Occurred()) SWIG_fail;
31548 }
31549 {
31550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31551 }
31552 return resultobj;
31553 fail:
31554 return NULL;
31555 }
31556
31557
31558 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31559 PyObject *resultobj = 0;
31560 wxPyApp *arg1 = (wxPyApp *) 0 ;
31561 bool arg2 ;
31562 bool arg3 = (bool) false ;
31563 void *argp1 = 0 ;
31564 int res1 = 0 ;
31565 bool val2 ;
31566 int ecode2 = 0 ;
31567 bool val3 ;
31568 int ecode3 = 0 ;
31569 PyObject * obj0 = 0 ;
31570 PyObject * obj1 = 0 ;
31571 PyObject * obj2 = 0 ;
31572 char * kwnames[] = {
31573 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
31574 };
31575
31576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31578 if (!SWIG_IsOK(res1)) {
31579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
31580 }
31581 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31582 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31583 if (!SWIG_IsOK(ecode2)) {
31584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
31585 }
31586 arg2 = static_cast< bool >(val2);
31587 if (obj2) {
31588 ecode3 = SWIG_AsVal_bool(obj2, &val3);
31589 if (!SWIG_IsOK(ecode3)) {
31590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
31591 }
31592 arg3 = static_cast< bool >(val3);
31593 }
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 (arg1)->SetUseBestVisual(arg2,arg3);
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 resultobj = SWIG_Py_Void();
31601 return resultobj;
31602 fail:
31603 return NULL;
31604 }
31605
31606
31607 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31608 PyObject *resultobj = 0;
31609 wxPyApp *arg1 = (wxPyApp *) 0 ;
31610 bool result;
31611 void *argp1 = 0 ;
31612 int res1 = 0 ;
31613 PyObject *swig_obj[1] ;
31614
31615 if (!args) SWIG_fail;
31616 swig_obj[0] = args;
31617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31618 if (!SWIG_IsOK(res1)) {
31619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31620 }
31621 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31622 {
31623 PyThreadState* __tstate = wxPyBeginAllowThreads();
31624 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31625 wxPyEndAllowThreads(__tstate);
31626 if (PyErr_Occurred()) SWIG_fail;
31627 }
31628 {
31629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31630 }
31631 return resultobj;
31632 fail:
31633 return NULL;
31634 }
31635
31636
31637 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31638 PyObject *resultobj = 0;
31639 wxPyApp *arg1 = (wxPyApp *) 0 ;
31640 int arg2 ;
31641 void *argp1 = 0 ;
31642 int res1 = 0 ;
31643 int val2 ;
31644 int ecode2 = 0 ;
31645 PyObject * obj0 = 0 ;
31646 PyObject * obj1 = 0 ;
31647 char * kwnames[] = {
31648 (char *) "self",(char *) "mode", NULL
31649 };
31650
31651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31653 if (!SWIG_IsOK(res1)) {
31654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31655 }
31656 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31657 ecode2 = SWIG_AsVal_int(obj1, &val2);
31658 if (!SWIG_IsOK(ecode2)) {
31659 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31660 }
31661 arg2 = static_cast< int >(val2);
31662 {
31663 PyThreadState* __tstate = wxPyBeginAllowThreads();
31664 (arg1)->SetPrintMode(arg2);
31665 wxPyEndAllowThreads(__tstate);
31666 if (PyErr_Occurred()) SWIG_fail;
31667 }
31668 resultobj = SWIG_Py_Void();
31669 return resultobj;
31670 fail:
31671 return NULL;
31672 }
31673
31674
31675 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31676 PyObject *resultobj = 0;
31677 wxPyApp *arg1 = (wxPyApp *) 0 ;
31678 int result;
31679 void *argp1 = 0 ;
31680 int res1 = 0 ;
31681 PyObject *swig_obj[1] ;
31682
31683 if (!args) SWIG_fail;
31684 swig_obj[0] = args;
31685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31686 if (!SWIG_IsOK(res1)) {
31687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31688 }
31689 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31690 {
31691 PyThreadState* __tstate = wxPyBeginAllowThreads();
31692 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31693 wxPyEndAllowThreads(__tstate);
31694 if (PyErr_Occurred()) SWIG_fail;
31695 }
31696 resultobj = SWIG_From_int(static_cast< int >(result));
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31704 PyObject *resultobj = 0;
31705 wxPyApp *arg1 = (wxPyApp *) 0 ;
31706 int arg2 ;
31707 void *argp1 = 0 ;
31708 int res1 = 0 ;
31709 int val2 ;
31710 int ecode2 = 0 ;
31711 PyObject * obj0 = 0 ;
31712 PyObject * obj1 = 0 ;
31713 char * kwnames[] = {
31714 (char *) "self",(char *) "mode", NULL
31715 };
31716
31717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31719 if (!SWIG_IsOK(res1)) {
31720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31721 }
31722 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31723 ecode2 = SWIG_AsVal_int(obj1, &val2);
31724 if (!SWIG_IsOK(ecode2)) {
31725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31726 }
31727 arg2 = static_cast< int >(val2);
31728 {
31729 PyThreadState* __tstate = wxPyBeginAllowThreads();
31730 (arg1)->SetAssertMode(arg2);
31731 wxPyEndAllowThreads(__tstate);
31732 if (PyErr_Occurred()) SWIG_fail;
31733 }
31734 resultobj = SWIG_Py_Void();
31735 return resultobj;
31736 fail:
31737 return NULL;
31738 }
31739
31740
31741 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31742 PyObject *resultobj = 0;
31743 wxPyApp *arg1 = (wxPyApp *) 0 ;
31744 int result;
31745 void *argp1 = 0 ;
31746 int res1 = 0 ;
31747 PyObject *swig_obj[1] ;
31748
31749 if (!args) SWIG_fail;
31750 swig_obj[0] = args;
31751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31752 if (!SWIG_IsOK(res1)) {
31753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31754 }
31755 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31756 {
31757 PyThreadState* __tstate = wxPyBeginAllowThreads();
31758 result = (int)(arg1)->GetAssertMode();
31759 wxPyEndAllowThreads(__tstate);
31760 if (PyErr_Occurred()) SWIG_fail;
31761 }
31762 resultobj = SWIG_From_int(static_cast< int >(result));
31763 return resultobj;
31764 fail:
31765 return NULL;
31766 }
31767
31768
31769 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31770 PyObject *resultobj = 0;
31771 bool result;
31772
31773 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 {
31781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31782 }
31783 return resultobj;
31784 fail:
31785 return NULL;
31786 }
31787
31788
31789 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31790 PyObject *resultobj = 0;
31791 long result;
31792
31793 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31794 {
31795 PyThreadState* __tstate = wxPyBeginAllowThreads();
31796 result = (long)wxPyApp::GetMacAboutMenuItemId();
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 resultobj = SWIG_From_long(static_cast< long >(result));
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31808 PyObject *resultobj = 0;
31809 long result;
31810
31811 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31812 {
31813 PyThreadState* __tstate = wxPyBeginAllowThreads();
31814 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31815 wxPyEndAllowThreads(__tstate);
31816 if (PyErr_Occurred()) SWIG_fail;
31817 }
31818 resultobj = SWIG_From_long(static_cast< long >(result));
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31826 PyObject *resultobj = 0;
31827 long result;
31828
31829 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = (long)wxPyApp::GetMacExitMenuItemId();
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 resultobj = SWIG_From_long(static_cast< long >(result));
31837 return resultobj;
31838 fail:
31839 return NULL;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31844 PyObject *resultobj = 0;
31845 wxString result;
31846
31847 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 result = wxPyApp::GetMacHelpMenuTitleName();
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 {
31855 #if wxUSE_UNICODE
31856 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31857 #else
31858 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31859 #endif
31860 }
31861 return resultobj;
31862 fail:
31863 return NULL;
31864 }
31865
31866
31867 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31868 PyObject *resultobj = 0;
31869 bool arg1 ;
31870 bool val1 ;
31871 int ecode1 = 0 ;
31872 PyObject * obj0 = 0 ;
31873 char * kwnames[] = {
31874 (char *) "val", NULL
31875 };
31876
31877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31878 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31879 if (!SWIG_IsOK(ecode1)) {
31880 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31881 }
31882 arg1 = static_cast< bool >(val1);
31883 {
31884 PyThreadState* __tstate = wxPyBeginAllowThreads();
31885 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31886 wxPyEndAllowThreads(__tstate);
31887 if (PyErr_Occurred()) SWIG_fail;
31888 }
31889 resultobj = SWIG_Py_Void();
31890 return resultobj;
31891 fail:
31892 return NULL;
31893 }
31894
31895
31896 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31897 PyObject *resultobj = 0;
31898 long arg1 ;
31899 long val1 ;
31900 int ecode1 = 0 ;
31901 PyObject * obj0 = 0 ;
31902 char * kwnames[] = {
31903 (char *) "val", NULL
31904 };
31905
31906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31907 ecode1 = SWIG_AsVal_long(obj0, &val1);
31908 if (!SWIG_IsOK(ecode1)) {
31909 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31910 }
31911 arg1 = static_cast< long >(val1);
31912 {
31913 PyThreadState* __tstate = wxPyBeginAllowThreads();
31914 wxPyApp::SetMacAboutMenuItemId(arg1);
31915 wxPyEndAllowThreads(__tstate);
31916 if (PyErr_Occurred()) SWIG_fail;
31917 }
31918 resultobj = SWIG_Py_Void();
31919 return resultobj;
31920 fail:
31921 return NULL;
31922 }
31923
31924
31925 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31926 PyObject *resultobj = 0;
31927 long arg1 ;
31928 long val1 ;
31929 int ecode1 = 0 ;
31930 PyObject * obj0 = 0 ;
31931 char * kwnames[] = {
31932 (char *) "val", NULL
31933 };
31934
31935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31936 ecode1 = SWIG_AsVal_long(obj0, &val1);
31937 if (!SWIG_IsOK(ecode1)) {
31938 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31939 }
31940 arg1 = static_cast< long >(val1);
31941 {
31942 PyThreadState* __tstate = wxPyBeginAllowThreads();
31943 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31944 wxPyEndAllowThreads(__tstate);
31945 if (PyErr_Occurred()) SWIG_fail;
31946 }
31947 resultobj = SWIG_Py_Void();
31948 return resultobj;
31949 fail:
31950 return NULL;
31951 }
31952
31953
31954 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31955 PyObject *resultobj = 0;
31956 long arg1 ;
31957 long val1 ;
31958 int ecode1 = 0 ;
31959 PyObject * obj0 = 0 ;
31960 char * kwnames[] = {
31961 (char *) "val", NULL
31962 };
31963
31964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31965 ecode1 = SWIG_AsVal_long(obj0, &val1);
31966 if (!SWIG_IsOK(ecode1)) {
31967 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31968 }
31969 arg1 = static_cast< long >(val1);
31970 {
31971 PyThreadState* __tstate = wxPyBeginAllowThreads();
31972 wxPyApp::SetMacExitMenuItemId(arg1);
31973 wxPyEndAllowThreads(__tstate);
31974 if (PyErr_Occurred()) SWIG_fail;
31975 }
31976 resultobj = SWIG_Py_Void();
31977 return resultobj;
31978 fail:
31979 return NULL;
31980 }
31981
31982
31983 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31984 PyObject *resultobj = 0;
31985 wxString *arg1 = 0 ;
31986 bool temp1 = false ;
31987 PyObject * obj0 = 0 ;
31988 char * kwnames[] = {
31989 (char *) "val", NULL
31990 };
31991
31992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31993 {
31994 arg1 = wxString_in_helper(obj0);
31995 if (arg1 == NULL) SWIG_fail;
31996 temp1 = true;
31997 }
31998 {
31999 PyThreadState* __tstate = wxPyBeginAllowThreads();
32000 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
32001 wxPyEndAllowThreads(__tstate);
32002 if (PyErr_Occurred()) SWIG_fail;
32003 }
32004 resultobj = SWIG_Py_Void();
32005 {
32006 if (temp1)
32007 delete arg1;
32008 }
32009 return resultobj;
32010 fail:
32011 {
32012 if (temp1)
32013 delete arg1;
32014 }
32015 return NULL;
32016 }
32017
32018
32019 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32020 PyObject *resultobj = 0;
32021 wxPyApp *arg1 = (wxPyApp *) 0 ;
32022 void *argp1 = 0 ;
32023 int res1 = 0 ;
32024 PyObject *swig_obj[1] ;
32025
32026 if (!args) SWIG_fail;
32027 swig_obj[0] = args;
32028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
32029 if (!SWIG_IsOK(res1)) {
32030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
32031 }
32032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 (arg1)->_BootstrapApp();
32036 wxPyEndAllowThreads(__tstate);
32037 if (PyErr_Occurred()) SWIG_fail;
32038 }
32039 resultobj = SWIG_Py_Void();
32040 return resultobj;
32041 fail:
32042 return NULL;
32043 }
32044
32045
32046 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32047 PyObject *resultobj = 0;
32048 int result;
32049
32050 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
32051 {
32052 PyThreadState* __tstate = wxPyBeginAllowThreads();
32053 result = (int)wxPyApp_GetComCtl32Version();
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 resultobj = SWIG_From_int(static_cast< int >(result));
32058 return resultobj;
32059 fail:
32060 return NULL;
32061 }
32062
32063
32064 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32065 PyObject *resultobj = 0;
32066 bool result;
32067
32068 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
32069 {
32070 PyThreadState* __tstate = wxPyBeginAllowThreads();
32071 result = (bool)wxPyApp_IsDisplayAvailable();
32072 wxPyEndAllowThreads(__tstate);
32073 if (PyErr_Occurred()) SWIG_fail;
32074 }
32075 {
32076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32077 }
32078 return resultobj;
32079 fail:
32080 return NULL;
32081 }
32082
32083
32084 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32085 PyObject *obj;
32086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32087 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
32088 return SWIG_Py_Void();
32089 }
32090
32091 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32092 return SWIG_Python_InitShadowInstance(args);
32093 }
32094
32095 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32096 PyObject *resultobj = 0;
32097
32098 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
32099 {
32100 PyThreadState* __tstate = wxPyBeginAllowThreads();
32101 wxExit();
32102 wxPyEndAllowThreads(__tstate);
32103 if (PyErr_Occurred()) SWIG_fail;
32104 }
32105 resultobj = SWIG_Py_Void();
32106 return resultobj;
32107 fail:
32108 return NULL;
32109 }
32110
32111
32112 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32113 PyObject *resultobj = 0;
32114 bool result;
32115
32116 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
32117 {
32118 PyThreadState* __tstate = wxPyBeginAllowThreads();
32119 result = (bool)wxYield();
32120 wxPyEndAllowThreads(__tstate);
32121 if (PyErr_Occurred()) SWIG_fail;
32122 }
32123 {
32124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32125 }
32126 return resultobj;
32127 fail:
32128 return NULL;
32129 }
32130
32131
32132 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32133 PyObject *resultobj = 0;
32134 bool result;
32135
32136 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
32137 {
32138 PyThreadState* __tstate = wxPyBeginAllowThreads();
32139 result = (bool)wxYieldIfNeeded();
32140 wxPyEndAllowThreads(__tstate);
32141 if (PyErr_Occurred()) SWIG_fail;
32142 }
32143 {
32144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32145 }
32146 return resultobj;
32147 fail:
32148 return NULL;
32149 }
32150
32151
32152 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32153 PyObject *resultobj = 0;
32154 wxWindow *arg1 = (wxWindow *) NULL ;
32155 bool arg2 = (bool) false ;
32156 bool result;
32157 void *argp1 = 0 ;
32158 int res1 = 0 ;
32159 bool val2 ;
32160 int ecode2 = 0 ;
32161 PyObject * obj0 = 0 ;
32162 PyObject * obj1 = 0 ;
32163 char * kwnames[] = {
32164 (char *) "win",(char *) "onlyIfNeeded", NULL
32165 };
32166
32167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
32168 if (obj0) {
32169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32170 if (!SWIG_IsOK(res1)) {
32171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
32172 }
32173 arg1 = reinterpret_cast< wxWindow * >(argp1);
32174 }
32175 if (obj1) {
32176 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32177 if (!SWIG_IsOK(ecode2)) {
32178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
32179 }
32180 arg2 = static_cast< bool >(val2);
32181 }
32182 {
32183 PyThreadState* __tstate = wxPyBeginAllowThreads();
32184 result = (bool)wxSafeYield(arg1,arg2);
32185 wxPyEndAllowThreads(__tstate);
32186 if (PyErr_Occurred()) SWIG_fail;
32187 }
32188 {
32189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32190 }
32191 return resultobj;
32192 fail:
32193 return NULL;
32194 }
32195
32196
32197 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32198 PyObject *resultobj = 0;
32199
32200 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 wxWakeUpIdle();
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 resultobj = SWIG_Py_Void();
32208 return resultobj;
32209 fail:
32210 return NULL;
32211 }
32212
32213
32214 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32215 PyObject *resultobj = 0;
32216 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
32217 wxEvent *arg2 = 0 ;
32218 void *argp1 = 0 ;
32219 int res1 = 0 ;
32220 void *argp2 = 0 ;
32221 int res2 = 0 ;
32222 PyObject * obj0 = 0 ;
32223 PyObject * obj1 = 0 ;
32224 char * kwnames[] = {
32225 (char *) "dest",(char *) "event", NULL
32226 };
32227
32228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
32229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
32230 if (!SWIG_IsOK(res1)) {
32231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
32232 }
32233 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
32234 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
32235 if (!SWIG_IsOK(res2)) {
32236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32237 }
32238 if (!argp2) {
32239 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
32240 }
32241 arg2 = reinterpret_cast< wxEvent * >(argp2);
32242 {
32243 PyThreadState* __tstate = wxPyBeginAllowThreads();
32244 wxPostEvent(arg1,*arg2);
32245 wxPyEndAllowThreads(__tstate);
32246 if (PyErr_Occurred()) SWIG_fail;
32247 }
32248 resultobj = SWIG_Py_Void();
32249 return resultobj;
32250 fail:
32251 return NULL;
32252 }
32253
32254
32255 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32256 PyObject *resultobj = 0;
32257
32258 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
32259 {
32260 PyThreadState* __tstate = wxPyBeginAllowThreads();
32261 wxApp_CleanUp();
32262 wxPyEndAllowThreads(__tstate);
32263 if (PyErr_Occurred()) SWIG_fail;
32264 }
32265 resultobj = SWIG_Py_Void();
32266 return resultobj;
32267 fail:
32268 return NULL;
32269 }
32270
32271
32272 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32273 PyObject *resultobj = 0;
32274 wxPyApp *result = 0 ;
32275
32276 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
32277 {
32278 PyThreadState* __tstate = wxPyBeginAllowThreads();
32279 result = (wxPyApp *)wxPyGetApp();
32280 wxPyEndAllowThreads(__tstate);
32281 if (PyErr_Occurred()) SWIG_fail;
32282 }
32283 {
32284 resultobj = wxPyMake_wxObject(result, 0);
32285 }
32286 return resultobj;
32287 fail:
32288 return NULL;
32289 }
32290
32291
32292 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32293 PyObject *resultobj = 0;
32294 char *arg1 = (char *) 0 ;
32295 int res1 ;
32296 char *buf1 = 0 ;
32297 int alloc1 = 0 ;
32298 PyObject * obj0 = 0 ;
32299 char * kwnames[] = {
32300 (char *) "encoding", NULL
32301 };
32302
32303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
32304 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
32305 if (!SWIG_IsOK(res1)) {
32306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
32307 }
32308 arg1 = buf1;
32309 {
32310 PyThreadState* __tstate = wxPyBeginAllowThreads();
32311 wxSetDefaultPyEncoding((char const *)arg1);
32312 wxPyEndAllowThreads(__tstate);
32313 if (PyErr_Occurred()) SWIG_fail;
32314 }
32315 resultobj = SWIG_Py_Void();
32316 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32317 return resultobj;
32318 fail:
32319 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
32320 return NULL;
32321 }
32322
32323
32324 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32325 PyObject *resultobj = 0;
32326 char *result = 0 ;
32327
32328 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
32329 {
32330 PyThreadState* __tstate = wxPyBeginAllowThreads();
32331 result = (char *)wxGetDefaultPyEncoding();
32332 wxPyEndAllowThreads(__tstate);
32333 if (PyErr_Occurred()) SWIG_fail;
32334 }
32335 resultobj = SWIG_FromCharPtr(result);
32336 return resultobj;
32337 fail:
32338 return NULL;
32339 }
32340
32341
32342 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32343 PyObject *resultobj = 0;
32344 wxEventLoop *result = 0 ;
32345
32346 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
32347 {
32348 PyThreadState* __tstate = wxPyBeginAllowThreads();
32349 result = (wxEventLoop *)new wxEventLoop();
32350 wxPyEndAllowThreads(__tstate);
32351 if (PyErr_Occurred()) SWIG_fail;
32352 }
32353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
32354 return resultobj;
32355 fail:
32356 return NULL;
32357 }
32358
32359
32360 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32361 PyObject *resultobj = 0;
32362 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32363 void *argp1 = 0 ;
32364 int res1 = 0 ;
32365 PyObject *swig_obj[1] ;
32366
32367 if (!args) SWIG_fail;
32368 swig_obj[0] = args;
32369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
32370 if (!SWIG_IsOK(res1)) {
32371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32372 }
32373 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32374 {
32375 PyThreadState* __tstate = wxPyBeginAllowThreads();
32376 delete arg1;
32377
32378 wxPyEndAllowThreads(__tstate);
32379 if (PyErr_Occurred()) SWIG_fail;
32380 }
32381 resultobj = SWIG_Py_Void();
32382 return resultobj;
32383 fail:
32384 return NULL;
32385 }
32386
32387
32388 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32389 PyObject *resultobj = 0;
32390 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32391 int result;
32392 void *argp1 = 0 ;
32393 int res1 = 0 ;
32394 PyObject *swig_obj[1] ;
32395
32396 if (!args) SWIG_fail;
32397 swig_obj[0] = args;
32398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32399 if (!SWIG_IsOK(res1)) {
32400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32401 }
32402 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32403 {
32404 PyThreadState* __tstate = wxPyBeginAllowThreads();
32405 result = (int)(arg1)->Run();
32406 wxPyEndAllowThreads(__tstate);
32407 if (PyErr_Occurred()) SWIG_fail;
32408 }
32409 resultobj = SWIG_From_int(static_cast< int >(result));
32410 return resultobj;
32411 fail:
32412 return NULL;
32413 }
32414
32415
32416 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32417 PyObject *resultobj = 0;
32418 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32419 int arg2 = (int) 0 ;
32420 void *argp1 = 0 ;
32421 int res1 = 0 ;
32422 int val2 ;
32423 int ecode2 = 0 ;
32424 PyObject * obj0 = 0 ;
32425 PyObject * obj1 = 0 ;
32426 char * kwnames[] = {
32427 (char *) "self",(char *) "rc", NULL
32428 };
32429
32430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
32431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32432 if (!SWIG_IsOK(res1)) {
32433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32434 }
32435 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32436 if (obj1) {
32437 ecode2 = SWIG_AsVal_int(obj1, &val2);
32438 if (!SWIG_IsOK(ecode2)) {
32439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
32440 }
32441 arg2 = static_cast< int >(val2);
32442 }
32443 {
32444 PyThreadState* __tstate = wxPyBeginAllowThreads();
32445 (arg1)->Exit(arg2);
32446 wxPyEndAllowThreads(__tstate);
32447 if (PyErr_Occurred()) SWIG_fail;
32448 }
32449 resultobj = SWIG_Py_Void();
32450 return resultobj;
32451 fail:
32452 return NULL;
32453 }
32454
32455
32456 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32457 PyObject *resultobj = 0;
32458 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32459 bool result;
32460 void *argp1 = 0 ;
32461 int res1 = 0 ;
32462 PyObject *swig_obj[1] ;
32463
32464 if (!args) SWIG_fail;
32465 swig_obj[0] = args;
32466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32467 if (!SWIG_IsOK(res1)) {
32468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32469 }
32470 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32471 {
32472 PyThreadState* __tstate = wxPyBeginAllowThreads();
32473 result = (bool)((wxEventLoop const *)arg1)->Pending();
32474 wxPyEndAllowThreads(__tstate);
32475 if (PyErr_Occurred()) SWIG_fail;
32476 }
32477 {
32478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32479 }
32480 return resultobj;
32481 fail:
32482 return NULL;
32483 }
32484
32485
32486 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32487 PyObject *resultobj = 0;
32488 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32489 bool result;
32490 void *argp1 = 0 ;
32491 int res1 = 0 ;
32492 PyObject *swig_obj[1] ;
32493
32494 if (!args) SWIG_fail;
32495 swig_obj[0] = args;
32496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32497 if (!SWIG_IsOK(res1)) {
32498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32499 }
32500 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32501 {
32502 PyThreadState* __tstate = wxPyBeginAllowThreads();
32503 result = (bool)(arg1)->Dispatch();
32504 wxPyEndAllowThreads(__tstate);
32505 if (PyErr_Occurred()) SWIG_fail;
32506 }
32507 {
32508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32509 }
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *resultobj = 0;
32518 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32519 bool result;
32520 void *argp1 = 0 ;
32521 int res1 = 0 ;
32522 PyObject *swig_obj[1] ;
32523
32524 if (!args) SWIG_fail;
32525 swig_obj[0] = args;
32526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32527 if (!SWIG_IsOK(res1)) {
32528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
32529 }
32530 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
32534 wxPyEndAllowThreads(__tstate);
32535 if (PyErr_Occurred()) SWIG_fail;
32536 }
32537 {
32538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32539 }
32540 return resultobj;
32541 fail:
32542 return NULL;
32543 }
32544
32545
32546 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32547 PyObject *resultobj = 0;
32548 wxEventLoop *result = 0 ;
32549
32550 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
32551 {
32552 PyThreadState* __tstate = wxPyBeginAllowThreads();
32553 result = (wxEventLoop *)wxEventLoop::GetActive();
32554 wxPyEndAllowThreads(__tstate);
32555 if (PyErr_Occurred()) SWIG_fail;
32556 }
32557 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
32558 return resultobj;
32559 fail:
32560 return NULL;
32561 }
32562
32563
32564 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32565 PyObject *resultobj = 0;
32566 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32567 void *argp1 = 0 ;
32568 int res1 = 0 ;
32569 PyObject * obj0 = 0 ;
32570 char * kwnames[] = {
32571 (char *) "loop", NULL
32572 };
32573
32574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
32575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32576 if (!SWIG_IsOK(res1)) {
32577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32578 }
32579 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32580 {
32581 PyThreadState* __tstate = wxPyBeginAllowThreads();
32582 wxEventLoop::SetActive(arg1);
32583 wxPyEndAllowThreads(__tstate);
32584 if (PyErr_Occurred()) SWIG_fail;
32585 }
32586 resultobj = SWIG_Py_Void();
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32594 PyObject *obj;
32595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32596 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
32597 return SWIG_Py_Void();
32598 }
32599
32600 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32601 return SWIG_Python_InitShadowInstance(args);
32602 }
32603
32604 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32605 PyObject *resultobj = 0;
32606 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
32607 wxEventLoopActivator *result = 0 ;
32608 void *argp1 = 0 ;
32609 int res1 = 0 ;
32610 PyObject * obj0 = 0 ;
32611 char * kwnames[] = {
32612 (char *) "evtLoop", NULL
32613 };
32614
32615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32617 if (!SWIG_IsOK(res1)) {
32618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32619 }
32620 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32621 {
32622 PyThreadState* __tstate = wxPyBeginAllowThreads();
32623 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32624 wxPyEndAllowThreads(__tstate);
32625 if (PyErr_Occurred()) SWIG_fail;
32626 }
32627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32628 return resultobj;
32629 fail:
32630 return NULL;
32631 }
32632
32633
32634 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32635 PyObject *resultobj = 0;
32636 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32637 void *argp1 = 0 ;
32638 int res1 = 0 ;
32639 PyObject *swig_obj[1] ;
32640
32641 if (!args) SWIG_fail;
32642 swig_obj[0] = args;
32643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32644 if (!SWIG_IsOK(res1)) {
32645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32646 }
32647 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32648 {
32649 PyThreadState* __tstate = wxPyBeginAllowThreads();
32650 delete arg1;
32651
32652 wxPyEndAllowThreads(__tstate);
32653 if (PyErr_Occurred()) SWIG_fail;
32654 }
32655 resultobj = SWIG_Py_Void();
32656 return resultobj;
32657 fail:
32658 return NULL;
32659 }
32660
32661
32662 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32663 PyObject *obj;
32664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32665 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32666 return SWIG_Py_Void();
32667 }
32668
32669 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32670 return SWIG_Python_InitShadowInstance(args);
32671 }
32672
32673 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32674 PyObject *resultobj = 0;
32675 int arg1 = (int) 0 ;
32676 int arg2 = (int) 0 ;
32677 int arg3 = (int) 0 ;
32678 wxAcceleratorEntry *result = 0 ;
32679 int val1 ;
32680 int ecode1 = 0 ;
32681 int val2 ;
32682 int ecode2 = 0 ;
32683 int val3 ;
32684 int ecode3 = 0 ;
32685 PyObject * obj0 = 0 ;
32686 PyObject * obj1 = 0 ;
32687 PyObject * obj2 = 0 ;
32688 char * kwnames[] = {
32689 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32690 };
32691
32692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32693 if (obj0) {
32694 ecode1 = SWIG_AsVal_int(obj0, &val1);
32695 if (!SWIG_IsOK(ecode1)) {
32696 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32697 }
32698 arg1 = static_cast< int >(val1);
32699 }
32700 if (obj1) {
32701 ecode2 = SWIG_AsVal_int(obj1, &val2);
32702 if (!SWIG_IsOK(ecode2)) {
32703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32704 }
32705 arg2 = static_cast< int >(val2);
32706 }
32707 if (obj2) {
32708 ecode3 = SWIG_AsVal_int(obj2, &val3);
32709 if (!SWIG_IsOK(ecode3)) {
32710 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32711 }
32712 arg3 = static_cast< int >(val3);
32713 }
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32728 PyObject *resultobj = 0;
32729 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32730 void *argp1 = 0 ;
32731 int res1 = 0 ;
32732 PyObject *swig_obj[1] ;
32733
32734 if (!args) SWIG_fail;
32735 swig_obj[0] = args;
32736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32737 if (!SWIG_IsOK(res1)) {
32738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32739 }
32740 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32741 {
32742 PyThreadState* __tstate = wxPyBeginAllowThreads();
32743 delete arg1;
32744
32745 wxPyEndAllowThreads(__tstate);
32746 if (PyErr_Occurred()) SWIG_fail;
32747 }
32748 resultobj = SWIG_Py_Void();
32749 return resultobj;
32750 fail:
32751 return NULL;
32752 }
32753
32754
32755 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32756 PyObject *resultobj = 0;
32757 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32758 int arg2 ;
32759 int arg3 ;
32760 int arg4 ;
32761 void *argp1 = 0 ;
32762 int res1 = 0 ;
32763 int val2 ;
32764 int ecode2 = 0 ;
32765 int val3 ;
32766 int ecode3 = 0 ;
32767 int val4 ;
32768 int ecode4 = 0 ;
32769 PyObject * obj0 = 0 ;
32770 PyObject * obj1 = 0 ;
32771 PyObject * obj2 = 0 ;
32772 PyObject * obj3 = 0 ;
32773 char * kwnames[] = {
32774 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32775 };
32776
32777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32779 if (!SWIG_IsOK(res1)) {
32780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32781 }
32782 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32783 ecode2 = SWIG_AsVal_int(obj1, &val2);
32784 if (!SWIG_IsOK(ecode2)) {
32785 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32786 }
32787 arg2 = static_cast< int >(val2);
32788 ecode3 = SWIG_AsVal_int(obj2, &val3);
32789 if (!SWIG_IsOK(ecode3)) {
32790 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32791 }
32792 arg3 = static_cast< int >(val3);
32793 ecode4 = SWIG_AsVal_int(obj3, &val4);
32794 if (!SWIG_IsOK(ecode4)) {
32795 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32796 }
32797 arg4 = static_cast< int >(val4);
32798 {
32799 PyThreadState* __tstate = wxPyBeginAllowThreads();
32800 (arg1)->Set(arg2,arg3,arg4);
32801 wxPyEndAllowThreads(__tstate);
32802 if (PyErr_Occurred()) SWIG_fail;
32803 }
32804 resultobj = SWIG_Py_Void();
32805 return resultobj;
32806 fail:
32807 return NULL;
32808 }
32809
32810
32811 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32812 PyObject *resultobj = 0;
32813 wxString *arg1 = 0 ;
32814 wxAcceleratorEntry *result = 0 ;
32815 bool temp1 = false ;
32816 PyObject * obj0 = 0 ;
32817 char * kwnames[] = {
32818 (char *) "str", NULL
32819 };
32820
32821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32822 {
32823 arg1 = wxString_in_helper(obj0);
32824 if (arg1 == NULL) SWIG_fail;
32825 temp1 = true;
32826 }
32827 {
32828 PyThreadState* __tstate = wxPyBeginAllowThreads();
32829 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32830 wxPyEndAllowThreads(__tstate);
32831 if (PyErr_Occurred()) SWIG_fail;
32832 }
32833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32834 {
32835 if (temp1)
32836 delete arg1;
32837 }
32838 return resultobj;
32839 fail:
32840 {
32841 if (temp1)
32842 delete arg1;
32843 }
32844 return NULL;
32845 }
32846
32847
32848 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32849 PyObject *resultobj = 0;
32850 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32851 int result;
32852 void *argp1 = 0 ;
32853 int res1 = 0 ;
32854 PyObject *swig_obj[1] ;
32855
32856 if (!args) SWIG_fail;
32857 swig_obj[0] = args;
32858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32859 if (!SWIG_IsOK(res1)) {
32860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32861 }
32862 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32863 {
32864 PyThreadState* __tstate = wxPyBeginAllowThreads();
32865 result = (int)(arg1)->GetFlags();
32866 wxPyEndAllowThreads(__tstate);
32867 if (PyErr_Occurred()) SWIG_fail;
32868 }
32869 resultobj = SWIG_From_int(static_cast< int >(result));
32870 return resultobj;
32871 fail:
32872 return NULL;
32873 }
32874
32875
32876 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32877 PyObject *resultobj = 0;
32878 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32879 int result;
32880 void *argp1 = 0 ;
32881 int res1 = 0 ;
32882 PyObject *swig_obj[1] ;
32883
32884 if (!args) SWIG_fail;
32885 swig_obj[0] = args;
32886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32889 }
32890 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32891 {
32892 PyThreadState* __tstate = wxPyBeginAllowThreads();
32893 result = (int)(arg1)->GetKeyCode();
32894 wxPyEndAllowThreads(__tstate);
32895 if (PyErr_Occurred()) SWIG_fail;
32896 }
32897 resultobj = SWIG_From_int(static_cast< int >(result));
32898 return resultobj;
32899 fail:
32900 return NULL;
32901 }
32902
32903
32904 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32905 PyObject *resultobj = 0;
32906 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32907 int result;
32908 void *argp1 = 0 ;
32909 int res1 = 0 ;
32910 PyObject *swig_obj[1] ;
32911
32912 if (!args) SWIG_fail;
32913 swig_obj[0] = args;
32914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32915 if (!SWIG_IsOK(res1)) {
32916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32917 }
32918 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32919 {
32920 PyThreadState* __tstate = wxPyBeginAllowThreads();
32921 result = (int)(arg1)->GetCommand();
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 resultobj = SWIG_From_int(static_cast< int >(result));
32926 return resultobj;
32927 fail:
32928 return NULL;
32929 }
32930
32931
32932 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32933 PyObject *resultobj = 0;
32934 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32935 bool result;
32936 void *argp1 = 0 ;
32937 int res1 = 0 ;
32938 PyObject *swig_obj[1] ;
32939
32940 if (!args) SWIG_fail;
32941 swig_obj[0] = args;
32942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32943 if (!SWIG_IsOK(res1)) {
32944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32945 }
32946 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32947 {
32948 PyThreadState* __tstate = wxPyBeginAllowThreads();
32949 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32950 wxPyEndAllowThreads(__tstate);
32951 if (PyErr_Occurred()) SWIG_fail;
32952 }
32953 {
32954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32955 }
32956 return resultobj;
32957 fail:
32958 return NULL;
32959 }
32960
32961
32962 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32963 PyObject *resultobj = 0;
32964 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32965 wxString result;
32966 void *argp1 = 0 ;
32967 int res1 = 0 ;
32968 PyObject *swig_obj[1] ;
32969
32970 if (!args) SWIG_fail;
32971 swig_obj[0] = args;
32972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32973 if (!SWIG_IsOK(res1)) {
32974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32975 }
32976 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32977 {
32978 PyThreadState* __tstate = wxPyBeginAllowThreads();
32979 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32980 wxPyEndAllowThreads(__tstate);
32981 if (PyErr_Occurred()) SWIG_fail;
32982 }
32983 {
32984 #if wxUSE_UNICODE
32985 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32986 #else
32987 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32988 #endif
32989 }
32990 return resultobj;
32991 fail:
32992 return NULL;
32993 }
32994
32995
32996 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32997 PyObject *resultobj = 0;
32998 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32999 wxString *arg2 = 0 ;
33000 bool result;
33001 void *argp1 = 0 ;
33002 int res1 = 0 ;
33003 bool temp2 = false ;
33004 PyObject * obj0 = 0 ;
33005 PyObject * obj1 = 0 ;
33006 char * kwnames[] = {
33007 (char *) "self",(char *) "str", NULL
33008 };
33009
33010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
33011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
33012 if (!SWIG_IsOK(res1)) {
33013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
33014 }
33015 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
33016 {
33017 arg2 = wxString_in_helper(obj1);
33018 if (arg2 == NULL) SWIG_fail;
33019 temp2 = true;
33020 }
33021 {
33022 PyThreadState* __tstate = wxPyBeginAllowThreads();
33023 result = (bool)(arg1)->FromString((wxString const &)*arg2);
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 {
33028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33029 }
33030 {
33031 if (temp2)
33032 delete arg2;
33033 }
33034 return resultobj;
33035 fail:
33036 {
33037 if (temp2)
33038 delete arg2;
33039 }
33040 return NULL;
33041 }
33042
33043
33044 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33045 PyObject *obj;
33046 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33047 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
33048 return SWIG_Py_Void();
33049 }
33050
33051 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33052 return SWIG_Python_InitShadowInstance(args);
33053 }
33054
33055 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33056 PyObject *resultobj = 0;
33057 int arg1 ;
33058 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
33059 wxAcceleratorTable *result = 0 ;
33060 PyObject * obj0 = 0 ;
33061 char * kwnames[] = {
33062 (char *) "n", NULL
33063 };
33064
33065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
33066 {
33067 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
33068 if (arg2) arg1 = PyList_Size(obj0);
33069 else arg1 = 0;
33070 }
33071 {
33072 PyThreadState* __tstate = wxPyBeginAllowThreads();
33073 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
33074 wxPyEndAllowThreads(__tstate);
33075 if (PyErr_Occurred()) SWIG_fail;
33076 }
33077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
33078 return resultobj;
33079 fail:
33080 return NULL;
33081 }
33082
33083
33084 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33085 PyObject *resultobj = 0;
33086 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33087 void *argp1 = 0 ;
33088 int res1 = 0 ;
33089 PyObject *swig_obj[1] ;
33090
33091 if (!args) SWIG_fail;
33092 swig_obj[0] = args;
33093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
33094 if (!SWIG_IsOK(res1)) {
33095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
33096 }
33097 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33098 {
33099 PyThreadState* __tstate = wxPyBeginAllowThreads();
33100 delete arg1;
33101
33102 wxPyEndAllowThreads(__tstate);
33103 if (PyErr_Occurred()) SWIG_fail;
33104 }
33105 resultobj = SWIG_Py_Void();
33106 return resultobj;
33107 fail:
33108 return NULL;
33109 }
33110
33111
33112 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33113 PyObject *resultobj = 0;
33114 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
33115 bool result;
33116 void *argp1 = 0 ;
33117 int res1 = 0 ;
33118 PyObject *swig_obj[1] ;
33119
33120 if (!args) SWIG_fail;
33121 swig_obj[0] = args;
33122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33123 if (!SWIG_IsOK(res1)) {
33124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
33125 }
33126 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 {
33134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33135 }
33136 return resultobj;
33137 fail:
33138 return NULL;
33139 }
33140
33141
33142 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33143 PyObject *obj;
33144 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33145 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
33146 return SWIG_Py_Void();
33147 }
33148
33149 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33150 return SWIG_Python_InitShadowInstance(args);
33151 }
33152
33153 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
33154 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
33155 return 1;
33156 }
33157
33158
33159 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
33160 PyObject *pyobj = 0;
33161
33162 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
33163 return pyobj;
33164 }
33165
33166
33167 SWIGINTERN int PanelNameStr_set(PyObject *) {
33168 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
33169 return 1;
33170 }
33171
33172
33173 SWIGINTERN PyObject *PanelNameStr_get(void) {
33174 PyObject *pyobj = 0;
33175
33176 {
33177 #if wxUSE_UNICODE
33178 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33179 #else
33180 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
33181 #endif
33182 }
33183 return pyobj;
33184 }
33185
33186
33187 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33188 PyObject *resultobj = 0;
33189 wxVisualAttributes *result = 0 ;
33190
33191 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
33192 {
33193 PyThreadState* __tstate = wxPyBeginAllowThreads();
33194 result = (wxVisualAttributes *)new_wxVisualAttributes();
33195 wxPyEndAllowThreads(__tstate);
33196 if (PyErr_Occurred()) SWIG_fail;
33197 }
33198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
33199 return resultobj;
33200 fail:
33201 return NULL;
33202 }
33203
33204
33205 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33206 PyObject *resultobj = 0;
33207 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33208 void *argp1 = 0 ;
33209 int res1 = 0 ;
33210 PyObject *swig_obj[1] ;
33211
33212 if (!args) SWIG_fail;
33213 swig_obj[0] = args;
33214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
33215 if (!SWIG_IsOK(res1)) {
33216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33217 }
33218 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33219 {
33220 PyThreadState* __tstate = wxPyBeginAllowThreads();
33221 delete_wxVisualAttributes(arg1);
33222
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 resultobj = SWIG_Py_Void();
33227 return resultobj;
33228 fail:
33229 return NULL;
33230 }
33231
33232
33233 SWIGINTERN PyObject *_wrap_VisualAttributes__get_font(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33234 PyObject *resultobj = 0;
33235 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33236 wxFont result;
33237 void *argp1 = 0 ;
33238 int res1 = 0 ;
33239 PyObject *swig_obj[1] ;
33240
33241 if (!args) SWIG_fail;
33242 swig_obj[0] = args;
33243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33244 if (!SWIG_IsOK(res1)) {
33245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_font" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33246 }
33247 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33248 {
33249 PyThreadState* __tstate = wxPyBeginAllowThreads();
33250 result = wxVisualAttributes__get_font(arg1);
33251 wxPyEndAllowThreads(__tstate);
33252 if (PyErr_Occurred()) SWIG_fail;
33253 }
33254 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
33255 return resultobj;
33256 fail:
33257 return NULL;
33258 }
33259
33260
33261 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colFg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33262 PyObject *resultobj = 0;
33263 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33264 wxColour result;
33265 void *argp1 = 0 ;
33266 int res1 = 0 ;
33267 PyObject *swig_obj[1] ;
33268
33269 if (!args) SWIG_fail;
33270 swig_obj[0] = args;
33271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33272 if (!SWIG_IsOK(res1)) {
33273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colFg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33274 }
33275 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33276 {
33277 PyThreadState* __tstate = wxPyBeginAllowThreads();
33278 result = wxVisualAttributes__get_colFg(arg1);
33279 wxPyEndAllowThreads(__tstate);
33280 if (PyErr_Occurred()) SWIG_fail;
33281 }
33282 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33283 return resultobj;
33284 fail:
33285 return NULL;
33286 }
33287
33288
33289 SWIGINTERN PyObject *_wrap_VisualAttributes__get_colBg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33290 PyObject *resultobj = 0;
33291 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
33292 wxColour result;
33293 void *argp1 = 0 ;
33294 int res1 = 0 ;
33295 PyObject *swig_obj[1] ;
33296
33297 if (!args) SWIG_fail;
33298 swig_obj[0] = args;
33299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
33300 if (!SWIG_IsOK(res1)) {
33301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes__get_colBg" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
33302 }
33303 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = wxVisualAttributes__get_colBg(arg1);
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
33311 return resultobj;
33312 fail:
33313 return NULL;
33314 }
33315
33316
33317 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33318 PyObject *obj;
33319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
33320 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
33321 return SWIG_Py_Void();
33322 }
33323
33324 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33325 return SWIG_Python_InitShadowInstance(args);
33326 }
33327
33328 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33329 PyObject *resultobj = 0;
33330 wxWindow *arg1 = (wxWindow *) 0 ;
33331 int arg2 = (int) (int)-1 ;
33332 wxPoint const &arg3_defvalue = wxDefaultPosition ;
33333 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
33334 wxSize const &arg4_defvalue = wxDefaultSize ;
33335 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
33336 long arg5 = (long) 0 ;
33337 wxString const &arg6_defvalue = wxPyPanelNameStr ;
33338 wxString *arg6 = (wxString *) &arg6_defvalue ;
33339 wxWindow *result = 0 ;
33340 void *argp1 = 0 ;
33341 int res1 = 0 ;
33342 int val2 ;
33343 int ecode2 = 0 ;
33344 wxPoint temp3 ;
33345 wxSize temp4 ;
33346 long val5 ;
33347 int ecode5 = 0 ;
33348 bool temp6 = false ;
33349 PyObject * obj0 = 0 ;
33350 PyObject * obj1 = 0 ;
33351 PyObject * obj2 = 0 ;
33352 PyObject * obj3 = 0 ;
33353 PyObject * obj4 = 0 ;
33354 PyObject * obj5 = 0 ;
33355 char * kwnames[] = {
33356 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33357 };
33358
33359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33361 if (!SWIG_IsOK(res1)) {
33362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
33363 }
33364 arg1 = reinterpret_cast< wxWindow * >(argp1);
33365 if (obj1) {
33366 ecode2 = SWIG_AsVal_int(obj1, &val2);
33367 if (!SWIG_IsOK(ecode2)) {
33368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
33369 }
33370 arg2 = static_cast< int >(val2);
33371 }
33372 if (obj2) {
33373 {
33374 arg3 = &temp3;
33375 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
33376 }
33377 }
33378 if (obj3) {
33379 {
33380 arg4 = &temp4;
33381 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
33382 }
33383 }
33384 if (obj4) {
33385 ecode5 = SWIG_AsVal_long(obj4, &val5);
33386 if (!SWIG_IsOK(ecode5)) {
33387 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
33388 }
33389 arg5 = static_cast< long >(val5);
33390 }
33391 if (obj5) {
33392 {
33393 arg6 = wxString_in_helper(obj5);
33394 if (arg6 == NULL) SWIG_fail;
33395 temp6 = true;
33396 }
33397 }
33398 {
33399 if (!wxPyCheckForApp()) SWIG_fail;
33400 PyThreadState* __tstate = wxPyBeginAllowThreads();
33401 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
33402 wxPyEndAllowThreads(__tstate);
33403 if (PyErr_Occurred()) SWIG_fail;
33404 }
33405 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
33406 {
33407 if (temp6)
33408 delete arg6;
33409 }
33410 return resultobj;
33411 fail:
33412 {
33413 if (temp6)
33414 delete arg6;
33415 }
33416 return NULL;
33417 }
33418
33419
33420 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33421 PyObject *resultobj = 0;
33422 wxWindow *result = 0 ;
33423
33424 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
33425 {
33426 if (!wxPyCheckForApp()) SWIG_fail;
33427 PyThreadState* __tstate = wxPyBeginAllowThreads();
33428 result = (wxWindow *)new wxWindow();
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
33433 return resultobj;
33434 fail:
33435 return NULL;
33436 }
33437
33438
33439 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33440 PyObject *resultobj = 0;
33441 wxWindow *arg1 = (wxWindow *) 0 ;
33442 wxWindow *arg2 = (wxWindow *) 0 ;
33443 int arg3 = (int) (int)-1 ;
33444 wxPoint const &arg4_defvalue = wxDefaultPosition ;
33445 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
33446 wxSize const &arg5_defvalue = wxDefaultSize ;
33447 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
33448 long arg6 = (long) 0 ;
33449 wxString const &arg7_defvalue = wxPyPanelNameStr ;
33450 wxString *arg7 = (wxString *) &arg7_defvalue ;
33451 bool result;
33452 void *argp1 = 0 ;
33453 int res1 = 0 ;
33454 void *argp2 = 0 ;
33455 int res2 = 0 ;
33456 int val3 ;
33457 int ecode3 = 0 ;
33458 wxPoint temp4 ;
33459 wxSize temp5 ;
33460 long val6 ;
33461 int ecode6 = 0 ;
33462 bool temp7 = false ;
33463 PyObject * obj0 = 0 ;
33464 PyObject * obj1 = 0 ;
33465 PyObject * obj2 = 0 ;
33466 PyObject * obj3 = 0 ;
33467 PyObject * obj4 = 0 ;
33468 PyObject * obj5 = 0 ;
33469 PyObject * obj6 = 0 ;
33470 char * kwnames[] = {
33471 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
33472 };
33473
33474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
33475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33476 if (!SWIG_IsOK(res1)) {
33477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
33478 }
33479 arg1 = reinterpret_cast< wxWindow * >(argp1);
33480 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33481 if (!SWIG_IsOK(res2)) {
33482 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
33483 }
33484 arg2 = reinterpret_cast< wxWindow * >(argp2);
33485 if (obj2) {
33486 ecode3 = SWIG_AsVal_int(obj2, &val3);
33487 if (!SWIG_IsOK(ecode3)) {
33488 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
33489 }
33490 arg3 = static_cast< int >(val3);
33491 }
33492 if (obj3) {
33493 {
33494 arg4 = &temp4;
33495 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
33496 }
33497 }
33498 if (obj4) {
33499 {
33500 arg5 = &temp5;
33501 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33502 }
33503 }
33504 if (obj5) {
33505 ecode6 = SWIG_AsVal_long(obj5, &val6);
33506 if (!SWIG_IsOK(ecode6)) {
33507 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33508 }
33509 arg6 = static_cast< long >(val6);
33510 }
33511 if (obj6) {
33512 {
33513 arg7 = wxString_in_helper(obj6);
33514 if (arg7 == NULL) SWIG_fail;
33515 temp7 = true;
33516 }
33517 }
33518 {
33519 PyThreadState* __tstate = wxPyBeginAllowThreads();
33520 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33521 wxPyEndAllowThreads(__tstate);
33522 if (PyErr_Occurred()) SWIG_fail;
33523 }
33524 {
33525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33526 }
33527 {
33528 if (temp7)
33529 delete arg7;
33530 }
33531 return resultobj;
33532 fail:
33533 {
33534 if (temp7)
33535 delete arg7;
33536 }
33537 return NULL;
33538 }
33539
33540
33541 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33542 PyObject *resultobj = 0;
33543 wxWindow *arg1 = (wxWindow *) 0 ;
33544 bool arg2 = (bool) false ;
33545 bool result;
33546 void *argp1 = 0 ;
33547 int res1 = 0 ;
33548 bool val2 ;
33549 int ecode2 = 0 ;
33550 PyObject * obj0 = 0 ;
33551 PyObject * obj1 = 0 ;
33552 char * kwnames[] = {
33553 (char *) "self",(char *) "force", NULL
33554 };
33555
33556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33558 if (!SWIG_IsOK(res1)) {
33559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33560 }
33561 arg1 = reinterpret_cast< wxWindow * >(argp1);
33562 if (obj1) {
33563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33564 if (!SWIG_IsOK(ecode2)) {
33565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33566 }
33567 arg2 = static_cast< bool >(val2);
33568 }
33569 {
33570 PyThreadState* __tstate = wxPyBeginAllowThreads();
33571 result = (bool)(arg1)->Close(arg2);
33572 wxPyEndAllowThreads(__tstate);
33573 if (PyErr_Occurred()) SWIG_fail;
33574 }
33575 {
33576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33577 }
33578 return resultobj;
33579 fail:
33580 return NULL;
33581 }
33582
33583
33584 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 PyObject *resultobj = 0;
33586 wxWindow *arg1 = (wxWindow *) 0 ;
33587 bool result;
33588 void *argp1 = 0 ;
33589 int res1 = 0 ;
33590 PyObject *swig_obj[1] ;
33591
33592 if (!args) SWIG_fail;
33593 swig_obj[0] = args;
33594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33595 if (!SWIG_IsOK(res1)) {
33596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33597 }
33598 arg1 = reinterpret_cast< wxWindow * >(argp1);
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = (bool)(arg1)->Destroy();
33602 wxPyEndAllowThreads(__tstate);
33603 if (PyErr_Occurred()) SWIG_fail;
33604 }
33605 {
33606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33607 }
33608 return resultobj;
33609 fail:
33610 return NULL;
33611 }
33612
33613
33614 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33615 PyObject *resultobj = 0;
33616 wxWindow *arg1 = (wxWindow *) 0 ;
33617 bool result;
33618 void *argp1 = 0 ;
33619 int res1 = 0 ;
33620 PyObject *swig_obj[1] ;
33621
33622 if (!args) SWIG_fail;
33623 swig_obj[0] = args;
33624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33625 if (!SWIG_IsOK(res1)) {
33626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33627 }
33628 arg1 = reinterpret_cast< wxWindow * >(argp1);
33629 {
33630 PyThreadState* __tstate = wxPyBeginAllowThreads();
33631 result = (bool)(arg1)->DestroyChildren();
33632 wxPyEndAllowThreads(__tstate);
33633 if (PyErr_Occurred()) SWIG_fail;
33634 }
33635 {
33636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33637 }
33638 return resultobj;
33639 fail:
33640 return NULL;
33641 }
33642
33643
33644 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33645 PyObject *resultobj = 0;
33646 wxWindow *arg1 = (wxWindow *) 0 ;
33647 bool result;
33648 void *argp1 = 0 ;
33649 int res1 = 0 ;
33650 PyObject *swig_obj[1] ;
33651
33652 if (!args) SWIG_fail;
33653 swig_obj[0] = args;
33654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33655 if (!SWIG_IsOK(res1)) {
33656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33657 }
33658 arg1 = reinterpret_cast< wxWindow * >(argp1);
33659 {
33660 PyThreadState* __tstate = wxPyBeginAllowThreads();
33661 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33662 wxPyEndAllowThreads(__tstate);
33663 if (PyErr_Occurred()) SWIG_fail;
33664 }
33665 {
33666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33667 }
33668 return resultobj;
33669 fail:
33670 return NULL;
33671 }
33672
33673
33674 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33675 PyObject *resultobj = 0;
33676 wxWindow *arg1 = (wxWindow *) 0 ;
33677 wxString *arg2 = 0 ;
33678 void *argp1 = 0 ;
33679 int res1 = 0 ;
33680 bool temp2 = false ;
33681 PyObject * obj0 = 0 ;
33682 PyObject * obj1 = 0 ;
33683 char * kwnames[] = {
33684 (char *) "self",(char *) "label", NULL
33685 };
33686
33687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33689 if (!SWIG_IsOK(res1)) {
33690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33691 }
33692 arg1 = reinterpret_cast< wxWindow * >(argp1);
33693 {
33694 arg2 = wxString_in_helper(obj1);
33695 if (arg2 == NULL) SWIG_fail;
33696 temp2 = true;
33697 }
33698 {
33699 PyThreadState* __tstate = wxPyBeginAllowThreads();
33700 (arg1)->SetLabel((wxString const &)*arg2);
33701 wxPyEndAllowThreads(__tstate);
33702 if (PyErr_Occurred()) SWIG_fail;
33703 }
33704 resultobj = SWIG_Py_Void();
33705 {
33706 if (temp2)
33707 delete arg2;
33708 }
33709 return resultobj;
33710 fail:
33711 {
33712 if (temp2)
33713 delete arg2;
33714 }
33715 return NULL;
33716 }
33717
33718
33719 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33720 PyObject *resultobj = 0;
33721 wxWindow *arg1 = (wxWindow *) 0 ;
33722 wxString result;
33723 void *argp1 = 0 ;
33724 int res1 = 0 ;
33725 PyObject *swig_obj[1] ;
33726
33727 if (!args) SWIG_fail;
33728 swig_obj[0] = args;
33729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33730 if (!SWIG_IsOK(res1)) {
33731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33732 }
33733 arg1 = reinterpret_cast< wxWindow * >(argp1);
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 result = ((wxWindow const *)arg1)->GetLabel();
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 {
33741 #if wxUSE_UNICODE
33742 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33743 #else
33744 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33745 #endif
33746 }
33747 return resultobj;
33748 fail:
33749 return NULL;
33750 }
33751
33752
33753 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33754 PyObject *resultobj = 0;
33755 wxWindow *arg1 = (wxWindow *) 0 ;
33756 wxString *arg2 = 0 ;
33757 void *argp1 = 0 ;
33758 int res1 = 0 ;
33759 bool temp2 = false ;
33760 PyObject * obj0 = 0 ;
33761 PyObject * obj1 = 0 ;
33762 char * kwnames[] = {
33763 (char *) "self",(char *) "name", NULL
33764 };
33765
33766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33768 if (!SWIG_IsOK(res1)) {
33769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33770 }
33771 arg1 = reinterpret_cast< wxWindow * >(argp1);
33772 {
33773 arg2 = wxString_in_helper(obj1);
33774 if (arg2 == NULL) SWIG_fail;
33775 temp2 = true;
33776 }
33777 {
33778 PyThreadState* __tstate = wxPyBeginAllowThreads();
33779 (arg1)->SetName((wxString const &)*arg2);
33780 wxPyEndAllowThreads(__tstate);
33781 if (PyErr_Occurred()) SWIG_fail;
33782 }
33783 resultobj = SWIG_Py_Void();
33784 {
33785 if (temp2)
33786 delete arg2;
33787 }
33788 return resultobj;
33789 fail:
33790 {
33791 if (temp2)
33792 delete arg2;
33793 }
33794 return NULL;
33795 }
33796
33797
33798 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33799 PyObject *resultobj = 0;
33800 wxWindow *arg1 = (wxWindow *) 0 ;
33801 wxString result;
33802 void *argp1 = 0 ;
33803 int res1 = 0 ;
33804 PyObject *swig_obj[1] ;
33805
33806 if (!args) SWIG_fail;
33807 swig_obj[0] = args;
33808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33809 if (!SWIG_IsOK(res1)) {
33810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33811 }
33812 arg1 = reinterpret_cast< wxWindow * >(argp1);
33813 {
33814 PyThreadState* __tstate = wxPyBeginAllowThreads();
33815 result = ((wxWindow const *)arg1)->GetName();
33816 wxPyEndAllowThreads(__tstate);
33817 if (PyErr_Occurred()) SWIG_fail;
33818 }
33819 {
33820 #if wxUSE_UNICODE
33821 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33822 #else
33823 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33824 #endif
33825 }
33826 return resultobj;
33827 fail:
33828 return NULL;
33829 }
33830
33831
33832 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33833 PyObject *resultobj = 0;
33834 wxWindow *arg1 = (wxWindow *) 0 ;
33835 wxWindowVariant arg2 ;
33836 void *argp1 = 0 ;
33837 int res1 = 0 ;
33838 int val2 ;
33839 int ecode2 = 0 ;
33840 PyObject * obj0 = 0 ;
33841 PyObject * obj1 = 0 ;
33842 char * kwnames[] = {
33843 (char *) "self",(char *) "variant", NULL
33844 };
33845
33846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33848 if (!SWIG_IsOK(res1)) {
33849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33850 }
33851 arg1 = reinterpret_cast< wxWindow * >(argp1);
33852 ecode2 = SWIG_AsVal_int(obj1, &val2);
33853 if (!SWIG_IsOK(ecode2)) {
33854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33855 }
33856 arg2 = static_cast< wxWindowVariant >(val2);
33857 {
33858 PyThreadState* __tstate = wxPyBeginAllowThreads();
33859 (arg1)->SetWindowVariant(arg2);
33860 wxPyEndAllowThreads(__tstate);
33861 if (PyErr_Occurred()) SWIG_fail;
33862 }
33863 resultobj = SWIG_Py_Void();
33864 return resultobj;
33865 fail:
33866 return NULL;
33867 }
33868
33869
33870 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33871 PyObject *resultobj = 0;
33872 wxWindow *arg1 = (wxWindow *) 0 ;
33873 wxWindowVariant result;
33874 void *argp1 = 0 ;
33875 int res1 = 0 ;
33876 PyObject *swig_obj[1] ;
33877
33878 if (!args) SWIG_fail;
33879 swig_obj[0] = args;
33880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33881 if (!SWIG_IsOK(res1)) {
33882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33883 }
33884 arg1 = reinterpret_cast< wxWindow * >(argp1);
33885 {
33886 PyThreadState* __tstate = wxPyBeginAllowThreads();
33887 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 resultobj = SWIG_From_int(static_cast< int >(result));
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33899 PyObject *resultobj = 0;
33900 wxWindow *arg1 = (wxWindow *) 0 ;
33901 int arg2 ;
33902 void *argp1 = 0 ;
33903 int res1 = 0 ;
33904 int val2 ;
33905 int ecode2 = 0 ;
33906 PyObject * obj0 = 0 ;
33907 PyObject * obj1 = 0 ;
33908 char * kwnames[] = {
33909 (char *) "self",(char *) "winid", NULL
33910 };
33911
33912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33914 if (!SWIG_IsOK(res1)) {
33915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33916 }
33917 arg1 = reinterpret_cast< wxWindow * >(argp1);
33918 ecode2 = SWIG_AsVal_int(obj1, &val2);
33919 if (!SWIG_IsOK(ecode2)) {
33920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33921 }
33922 arg2 = static_cast< int >(val2);
33923 {
33924 PyThreadState* __tstate = wxPyBeginAllowThreads();
33925 (arg1)->SetId(arg2);
33926 wxPyEndAllowThreads(__tstate);
33927 if (PyErr_Occurred()) SWIG_fail;
33928 }
33929 resultobj = SWIG_Py_Void();
33930 return resultobj;
33931 fail:
33932 return NULL;
33933 }
33934
33935
33936 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33937 PyObject *resultobj = 0;
33938 wxWindow *arg1 = (wxWindow *) 0 ;
33939 int result;
33940 void *argp1 = 0 ;
33941 int res1 = 0 ;
33942 PyObject *swig_obj[1] ;
33943
33944 if (!args) SWIG_fail;
33945 swig_obj[0] = args;
33946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33947 if (!SWIG_IsOK(res1)) {
33948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33949 }
33950 arg1 = reinterpret_cast< wxWindow * >(argp1);
33951 {
33952 PyThreadState* __tstate = wxPyBeginAllowThreads();
33953 result = (int)((wxWindow const *)arg1)->GetId();
33954 wxPyEndAllowThreads(__tstate);
33955 if (PyErr_Occurred()) SWIG_fail;
33956 }
33957 resultobj = SWIG_From_int(static_cast< int >(result));
33958 return resultobj;
33959 fail:
33960 return NULL;
33961 }
33962
33963
33964 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33965 PyObject *resultobj = 0;
33966 int result;
33967
33968 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33969 {
33970 PyThreadState* __tstate = wxPyBeginAllowThreads();
33971 result = (int)wxWindow::NewControlId();
33972 wxPyEndAllowThreads(__tstate);
33973 if (PyErr_Occurred()) SWIG_fail;
33974 }
33975 resultobj = SWIG_From_int(static_cast< int >(result));
33976 return resultobj;
33977 fail:
33978 return NULL;
33979 }
33980
33981
33982 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33983 PyObject *resultobj = 0;
33984 int arg1 ;
33985 int result;
33986 int val1 ;
33987 int ecode1 = 0 ;
33988 PyObject * obj0 = 0 ;
33989 char * kwnames[] = {
33990 (char *) "winid", NULL
33991 };
33992
33993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33994 ecode1 = SWIG_AsVal_int(obj0, &val1);
33995 if (!SWIG_IsOK(ecode1)) {
33996 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33997 }
33998 arg1 = static_cast< int >(val1);
33999 {
34000 PyThreadState* __tstate = wxPyBeginAllowThreads();
34001 result = (int)wxWindow::NextControlId(arg1);
34002 wxPyEndAllowThreads(__tstate);
34003 if (PyErr_Occurred()) SWIG_fail;
34004 }
34005 resultobj = SWIG_From_int(static_cast< int >(result));
34006 return resultobj;
34007 fail:
34008 return NULL;
34009 }
34010
34011
34012 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34013 PyObject *resultobj = 0;
34014 int arg1 ;
34015 int result;
34016 int val1 ;
34017 int ecode1 = 0 ;
34018 PyObject * obj0 = 0 ;
34019 char * kwnames[] = {
34020 (char *) "winid", NULL
34021 };
34022
34023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
34024 ecode1 = SWIG_AsVal_int(obj0, &val1);
34025 if (!SWIG_IsOK(ecode1)) {
34026 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
34027 }
34028 arg1 = static_cast< int >(val1);
34029 {
34030 PyThreadState* __tstate = wxPyBeginAllowThreads();
34031 result = (int)wxWindow::PrevControlId(arg1);
34032 wxPyEndAllowThreads(__tstate);
34033 if (PyErr_Occurred()) SWIG_fail;
34034 }
34035 resultobj = SWIG_From_int(static_cast< int >(result));
34036 return resultobj;
34037 fail:
34038 return NULL;
34039 }
34040
34041
34042 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34043 PyObject *resultobj = 0;
34044 wxWindow *arg1 = (wxWindow *) 0 ;
34045 wxLayoutDirection result;
34046 void *argp1 = 0 ;
34047 int res1 = 0 ;
34048 PyObject *swig_obj[1] ;
34049
34050 if (!args) SWIG_fail;
34051 swig_obj[0] = args;
34052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34055 }
34056 arg1 = reinterpret_cast< wxWindow * >(argp1);
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 resultobj = SWIG_From_int(static_cast< int >(result));
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxWindow *arg1 = (wxWindow *) 0 ;
34073 wxLayoutDirection arg2 ;
34074 void *argp1 = 0 ;
34075 int res1 = 0 ;
34076 int val2 ;
34077 int ecode2 = 0 ;
34078 PyObject * obj0 = 0 ;
34079 PyObject * obj1 = 0 ;
34080 char * kwnames[] = {
34081 (char *) "self",(char *) "dir", NULL
34082 };
34083
34084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
34085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34086 if (!SWIG_IsOK(res1)) {
34087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
34088 }
34089 arg1 = reinterpret_cast< wxWindow * >(argp1);
34090 ecode2 = SWIG_AsVal_int(obj1, &val2);
34091 if (!SWIG_IsOK(ecode2)) {
34092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
34093 }
34094 arg2 = static_cast< wxLayoutDirection >(val2);
34095 {
34096 PyThreadState* __tstate = wxPyBeginAllowThreads();
34097 (arg1)->SetLayoutDirection(arg2);
34098 wxPyEndAllowThreads(__tstate);
34099 if (PyErr_Occurred()) SWIG_fail;
34100 }
34101 resultobj = SWIG_Py_Void();
34102 return resultobj;
34103 fail:
34104 return NULL;
34105 }
34106
34107
34108 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34109 PyObject *resultobj = 0;
34110 wxWindow *arg1 = (wxWindow *) 0 ;
34111 int arg2 ;
34112 int arg3 ;
34113 int arg4 ;
34114 int result;
34115 void *argp1 = 0 ;
34116 int res1 = 0 ;
34117 int val2 ;
34118 int ecode2 = 0 ;
34119 int val3 ;
34120 int ecode3 = 0 ;
34121 int val4 ;
34122 int ecode4 = 0 ;
34123 PyObject * obj0 = 0 ;
34124 PyObject * obj1 = 0 ;
34125 PyObject * obj2 = 0 ;
34126 PyObject * obj3 = 0 ;
34127 char * kwnames[] = {
34128 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
34129 };
34130
34131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34133 if (!SWIG_IsOK(res1)) {
34134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
34135 }
34136 arg1 = reinterpret_cast< wxWindow * >(argp1);
34137 ecode2 = SWIG_AsVal_int(obj1, &val2);
34138 if (!SWIG_IsOK(ecode2)) {
34139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
34140 }
34141 arg2 = static_cast< int >(val2);
34142 ecode3 = SWIG_AsVal_int(obj2, &val3);
34143 if (!SWIG_IsOK(ecode3)) {
34144 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
34145 }
34146 arg3 = static_cast< int >(val3);
34147 ecode4 = SWIG_AsVal_int(obj3, &val4);
34148 if (!SWIG_IsOK(ecode4)) {
34149 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
34150 }
34151 arg4 = static_cast< int >(val4);
34152 {
34153 PyThreadState* __tstate = wxPyBeginAllowThreads();
34154 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
34155 wxPyEndAllowThreads(__tstate);
34156 if (PyErr_Occurred()) SWIG_fail;
34157 }
34158 resultobj = SWIG_From_int(static_cast< int >(result));
34159 return resultobj;
34160 fail:
34161 return NULL;
34162 }
34163
34164
34165 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34166 PyObject *resultobj = 0;
34167 wxWindow *arg1 = (wxWindow *) 0 ;
34168 wxSize *arg2 = 0 ;
34169 void *argp1 = 0 ;
34170 int res1 = 0 ;
34171 wxSize temp2 ;
34172 PyObject * obj0 = 0 ;
34173 PyObject * obj1 = 0 ;
34174 char * kwnames[] = {
34175 (char *) "self",(char *) "size", NULL
34176 };
34177
34178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
34179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34182 }
34183 arg1 = reinterpret_cast< wxWindow * >(argp1);
34184 {
34185 arg2 = &temp2;
34186 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34187 }
34188 {
34189 PyThreadState* __tstate = wxPyBeginAllowThreads();
34190 (arg1)->SetSize((wxSize const &)*arg2);
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 resultobj = SWIG_Py_Void();
34195 return resultobj;
34196 fail:
34197 return NULL;
34198 }
34199
34200
34201 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34202 PyObject *resultobj = 0;
34203 wxWindow *arg1 = (wxWindow *) 0 ;
34204 int arg2 ;
34205 int arg3 ;
34206 int arg4 ;
34207 int arg5 ;
34208 int arg6 = (int) wxSIZE_AUTO ;
34209 void *argp1 = 0 ;
34210 int res1 = 0 ;
34211 int val2 ;
34212 int ecode2 = 0 ;
34213 int val3 ;
34214 int ecode3 = 0 ;
34215 int val4 ;
34216 int ecode4 = 0 ;
34217 int val5 ;
34218 int ecode5 = 0 ;
34219 int val6 ;
34220 int ecode6 = 0 ;
34221 PyObject * obj0 = 0 ;
34222 PyObject * obj1 = 0 ;
34223 PyObject * obj2 = 0 ;
34224 PyObject * obj3 = 0 ;
34225 PyObject * obj4 = 0 ;
34226 PyObject * obj5 = 0 ;
34227 char * kwnames[] = {
34228 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
34229 };
34230
34231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
34232 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34233 if (!SWIG_IsOK(res1)) {
34234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
34235 }
34236 arg1 = reinterpret_cast< wxWindow * >(argp1);
34237 ecode2 = SWIG_AsVal_int(obj1, &val2);
34238 if (!SWIG_IsOK(ecode2)) {
34239 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
34240 }
34241 arg2 = static_cast< int >(val2);
34242 ecode3 = SWIG_AsVal_int(obj2, &val3);
34243 if (!SWIG_IsOK(ecode3)) {
34244 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
34245 }
34246 arg3 = static_cast< int >(val3);
34247 ecode4 = SWIG_AsVal_int(obj3, &val4);
34248 if (!SWIG_IsOK(ecode4)) {
34249 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
34250 }
34251 arg4 = static_cast< int >(val4);
34252 ecode5 = SWIG_AsVal_int(obj4, &val5);
34253 if (!SWIG_IsOK(ecode5)) {
34254 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
34255 }
34256 arg5 = static_cast< int >(val5);
34257 if (obj5) {
34258 ecode6 = SWIG_AsVal_int(obj5, &val6);
34259 if (!SWIG_IsOK(ecode6)) {
34260 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
34261 }
34262 arg6 = static_cast< int >(val6);
34263 }
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 resultobj = SWIG_Py_Void();
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34278 PyObject *resultobj = 0;
34279 wxWindow *arg1 = (wxWindow *) 0 ;
34280 wxRect *arg2 = 0 ;
34281 int arg3 = (int) wxSIZE_AUTO ;
34282 void *argp1 = 0 ;
34283 int res1 = 0 ;
34284 wxRect temp2 ;
34285 int val3 ;
34286 int ecode3 = 0 ;
34287 PyObject * obj0 = 0 ;
34288 PyObject * obj1 = 0 ;
34289 PyObject * obj2 = 0 ;
34290 char * kwnames[] = {
34291 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
34292 };
34293
34294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34296 if (!SWIG_IsOK(res1)) {
34297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34298 }
34299 arg1 = reinterpret_cast< wxWindow * >(argp1);
34300 {
34301 arg2 = &temp2;
34302 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34303 }
34304 if (obj2) {
34305 ecode3 = SWIG_AsVal_int(obj2, &val3);
34306 if (!SWIG_IsOK(ecode3)) {
34307 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
34308 }
34309 arg3 = static_cast< int >(val3);
34310 }
34311 {
34312 PyThreadState* __tstate = wxPyBeginAllowThreads();
34313 (arg1)->SetSize((wxRect const &)*arg2,arg3);
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 resultobj = SWIG_Py_Void();
34318 return resultobj;
34319 fail:
34320 return NULL;
34321 }
34322
34323
34324 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34325 PyObject *resultobj = 0;
34326 wxWindow *arg1 = (wxWindow *) 0 ;
34327 int arg2 ;
34328 int arg3 ;
34329 void *argp1 = 0 ;
34330 int res1 = 0 ;
34331 int val2 ;
34332 int ecode2 = 0 ;
34333 int val3 ;
34334 int ecode3 = 0 ;
34335 PyObject * obj0 = 0 ;
34336 PyObject * obj1 = 0 ;
34337 PyObject * obj2 = 0 ;
34338 char * kwnames[] = {
34339 (char *) "self",(char *) "width",(char *) "height", NULL
34340 };
34341
34342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34346 }
34347 arg1 = reinterpret_cast< wxWindow * >(argp1);
34348 ecode2 = SWIG_AsVal_int(obj1, &val2);
34349 if (!SWIG_IsOK(ecode2)) {
34350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
34351 }
34352 arg2 = static_cast< int >(val2);
34353 ecode3 = SWIG_AsVal_int(obj2, &val3);
34354 if (!SWIG_IsOK(ecode3)) {
34355 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
34356 }
34357 arg3 = static_cast< int >(val3);
34358 {
34359 PyThreadState* __tstate = wxPyBeginAllowThreads();
34360 (arg1)->SetSize(arg2,arg3);
34361 wxPyEndAllowThreads(__tstate);
34362 if (PyErr_Occurred()) SWIG_fail;
34363 }
34364 resultobj = SWIG_Py_Void();
34365 return resultobj;
34366 fail:
34367 return NULL;
34368 }
34369
34370
34371 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34372 PyObject *resultobj = 0;
34373 wxWindow *arg1 = (wxWindow *) 0 ;
34374 wxPoint *arg2 = 0 ;
34375 int arg3 = (int) wxSIZE_USE_EXISTING ;
34376 void *argp1 = 0 ;
34377 int res1 = 0 ;
34378 wxPoint temp2 ;
34379 int val3 ;
34380 int ecode3 = 0 ;
34381 PyObject * obj0 = 0 ;
34382 PyObject * obj1 = 0 ;
34383 PyObject * obj2 = 0 ;
34384 char * kwnames[] = {
34385 (char *) "self",(char *) "pt",(char *) "flags", NULL
34386 };
34387
34388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34390 if (!SWIG_IsOK(res1)) {
34391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
34392 }
34393 arg1 = reinterpret_cast< wxWindow * >(argp1);
34394 {
34395 arg2 = &temp2;
34396 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34397 }
34398 if (obj2) {
34399 ecode3 = SWIG_AsVal_int(obj2, &val3);
34400 if (!SWIG_IsOK(ecode3)) {
34401 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
34402 }
34403 arg3 = static_cast< int >(val3);
34404 }
34405 {
34406 PyThreadState* __tstate = wxPyBeginAllowThreads();
34407 (arg1)->Move((wxPoint const &)*arg2,arg3);
34408 wxPyEndAllowThreads(__tstate);
34409 if (PyErr_Occurred()) SWIG_fail;
34410 }
34411 resultobj = SWIG_Py_Void();
34412 return resultobj;
34413 fail:
34414 return NULL;
34415 }
34416
34417
34418 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34419 PyObject *resultobj = 0;
34420 wxWindow *arg1 = (wxWindow *) 0 ;
34421 int arg2 ;
34422 int arg3 ;
34423 int arg4 = (int) wxSIZE_USE_EXISTING ;
34424 void *argp1 = 0 ;
34425 int res1 = 0 ;
34426 int val2 ;
34427 int ecode2 = 0 ;
34428 int val3 ;
34429 int ecode3 = 0 ;
34430 int val4 ;
34431 int ecode4 = 0 ;
34432 PyObject * obj0 = 0 ;
34433 PyObject * obj1 = 0 ;
34434 PyObject * obj2 = 0 ;
34435 PyObject * obj3 = 0 ;
34436 char * kwnames[] = {
34437 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
34438 };
34439
34440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34442 if (!SWIG_IsOK(res1)) {
34443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
34444 }
34445 arg1 = reinterpret_cast< wxWindow * >(argp1);
34446 ecode2 = SWIG_AsVal_int(obj1, &val2);
34447 if (!SWIG_IsOK(ecode2)) {
34448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
34449 }
34450 arg2 = static_cast< int >(val2);
34451 ecode3 = SWIG_AsVal_int(obj2, &val3);
34452 if (!SWIG_IsOK(ecode3)) {
34453 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
34454 }
34455 arg3 = static_cast< int >(val3);
34456 if (obj3) {
34457 ecode4 = SWIG_AsVal_int(obj3, &val4);
34458 if (!SWIG_IsOK(ecode4)) {
34459 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
34460 }
34461 arg4 = static_cast< int >(val4);
34462 }
34463 {
34464 PyThreadState* __tstate = wxPyBeginAllowThreads();
34465 (arg1)->Move(arg2,arg3,arg4);
34466 wxPyEndAllowThreads(__tstate);
34467 if (PyErr_Occurred()) SWIG_fail;
34468 }
34469 resultobj = SWIG_Py_Void();
34470 return resultobj;
34471 fail:
34472 return NULL;
34473 }
34474
34475
34476 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34477 PyObject *resultobj = 0;
34478 wxWindow *arg1 = (wxWindow *) 0 ;
34479 wxSize const &arg2_defvalue = wxDefaultSize ;
34480 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
34481 void *argp1 = 0 ;
34482 int res1 = 0 ;
34483 wxSize temp2 ;
34484 PyObject * obj0 = 0 ;
34485 PyObject * obj1 = 0 ;
34486 char * kwnames[] = {
34487 (char *) "self",(char *) "size", NULL
34488 };
34489
34490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
34491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34492 if (!SWIG_IsOK(res1)) {
34493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34494 }
34495 arg1 = reinterpret_cast< wxWindow * >(argp1);
34496 if (obj1) {
34497 {
34498 arg2 = &temp2;
34499 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34500 }
34501 }
34502 {
34503 PyThreadState* __tstate = wxPyBeginAllowThreads();
34504 (arg1)->SetInitialSize((wxSize const &)*arg2);
34505 wxPyEndAllowThreads(__tstate);
34506 if (PyErr_Occurred()) SWIG_fail;
34507 }
34508 resultobj = SWIG_Py_Void();
34509 return resultobj;
34510 fail:
34511 return NULL;
34512 }
34513
34514
34515 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34516 PyObject *resultobj = 0;
34517 wxWindow *arg1 = (wxWindow *) 0 ;
34518 void *argp1 = 0 ;
34519 int res1 = 0 ;
34520 PyObject *swig_obj[1] ;
34521
34522 if (!args) SWIG_fail;
34523 swig_obj[0] = args;
34524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34525 if (!SWIG_IsOK(res1)) {
34526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34527 }
34528 arg1 = reinterpret_cast< wxWindow * >(argp1);
34529 {
34530 PyThreadState* __tstate = wxPyBeginAllowThreads();
34531 (arg1)->Raise();
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 resultobj = SWIG_Py_Void();
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34543 PyObject *resultobj = 0;
34544 wxWindow *arg1 = (wxWindow *) 0 ;
34545 void *argp1 = 0 ;
34546 int res1 = 0 ;
34547 PyObject *swig_obj[1] ;
34548
34549 if (!args) SWIG_fail;
34550 swig_obj[0] = args;
34551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34552 if (!SWIG_IsOK(res1)) {
34553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34554 }
34555 arg1 = reinterpret_cast< wxWindow * >(argp1);
34556 {
34557 PyThreadState* __tstate = wxPyBeginAllowThreads();
34558 (arg1)->Lower();
34559 wxPyEndAllowThreads(__tstate);
34560 if (PyErr_Occurred()) SWIG_fail;
34561 }
34562 resultobj = SWIG_Py_Void();
34563 return resultobj;
34564 fail:
34565 return NULL;
34566 }
34567
34568
34569 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34570 PyObject *resultobj = 0;
34571 wxWindow *arg1 = (wxWindow *) 0 ;
34572 wxSize *arg2 = 0 ;
34573 void *argp1 = 0 ;
34574 int res1 = 0 ;
34575 wxSize temp2 ;
34576 PyObject * obj0 = 0 ;
34577 PyObject * obj1 = 0 ;
34578 char * kwnames[] = {
34579 (char *) "self",(char *) "size", NULL
34580 };
34581
34582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34584 if (!SWIG_IsOK(res1)) {
34585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34586 }
34587 arg1 = reinterpret_cast< wxWindow * >(argp1);
34588 {
34589 arg2 = &temp2;
34590 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34591 }
34592 {
34593 PyThreadState* __tstate = wxPyBeginAllowThreads();
34594 (arg1)->SetClientSize((wxSize const &)*arg2);
34595 wxPyEndAllowThreads(__tstate);
34596 if (PyErr_Occurred()) SWIG_fail;
34597 }
34598 resultobj = SWIG_Py_Void();
34599 return resultobj;
34600 fail:
34601 return NULL;
34602 }
34603
34604
34605 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34606 PyObject *resultobj = 0;
34607 wxWindow *arg1 = (wxWindow *) 0 ;
34608 int arg2 ;
34609 int arg3 ;
34610 void *argp1 = 0 ;
34611 int res1 = 0 ;
34612 int val2 ;
34613 int ecode2 = 0 ;
34614 int val3 ;
34615 int ecode3 = 0 ;
34616 PyObject * obj0 = 0 ;
34617 PyObject * obj1 = 0 ;
34618 PyObject * obj2 = 0 ;
34619 char * kwnames[] = {
34620 (char *) "self",(char *) "width",(char *) "height", NULL
34621 };
34622
34623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34625 if (!SWIG_IsOK(res1)) {
34626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34627 }
34628 arg1 = reinterpret_cast< wxWindow * >(argp1);
34629 ecode2 = SWIG_AsVal_int(obj1, &val2);
34630 if (!SWIG_IsOK(ecode2)) {
34631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34632 }
34633 arg2 = static_cast< int >(val2);
34634 ecode3 = SWIG_AsVal_int(obj2, &val3);
34635 if (!SWIG_IsOK(ecode3)) {
34636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34637 }
34638 arg3 = static_cast< int >(val3);
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 (arg1)->SetClientSize(arg2,arg3);
34642 wxPyEndAllowThreads(__tstate);
34643 if (PyErr_Occurred()) SWIG_fail;
34644 }
34645 resultobj = SWIG_Py_Void();
34646 return resultobj;
34647 fail:
34648 return NULL;
34649 }
34650
34651
34652 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34653 PyObject *resultobj = 0;
34654 wxWindow *arg1 = (wxWindow *) 0 ;
34655 wxRect *arg2 = 0 ;
34656 void *argp1 = 0 ;
34657 int res1 = 0 ;
34658 wxRect temp2 ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "rect", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34669 }
34670 arg1 = reinterpret_cast< wxWindow * >(argp1);
34671 {
34672 arg2 = &temp2;
34673 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34674 }
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 (arg1)->SetClientSize((wxRect const &)*arg2);
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 resultobj = SWIG_Py_Void();
34682 return resultobj;
34683 fail:
34684 return NULL;
34685 }
34686
34687
34688 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34689 PyObject *resultobj = 0;
34690 wxWindow *arg1 = (wxWindow *) 0 ;
34691 wxPoint result;
34692 void *argp1 = 0 ;
34693 int res1 = 0 ;
34694 PyObject *swig_obj[1] ;
34695
34696 if (!args) SWIG_fail;
34697 swig_obj[0] = args;
34698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34699 if (!SWIG_IsOK(res1)) {
34700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34701 }
34702 arg1 = reinterpret_cast< wxWindow * >(argp1);
34703 {
34704 PyThreadState* __tstate = wxPyBeginAllowThreads();
34705 result = ((wxWindow const *)arg1)->GetPosition();
34706 wxPyEndAllowThreads(__tstate);
34707 if (PyErr_Occurred()) SWIG_fail;
34708 }
34709 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34710 return resultobj;
34711 fail:
34712 return NULL;
34713 }
34714
34715
34716 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34717 PyObject *resultobj = 0;
34718 wxWindow *arg1 = (wxWindow *) 0 ;
34719 int *arg2 = (int *) 0 ;
34720 int *arg3 = (int *) 0 ;
34721 void *argp1 = 0 ;
34722 int res1 = 0 ;
34723 int temp2 ;
34724 int res2 = SWIG_TMPOBJ ;
34725 int temp3 ;
34726 int res3 = SWIG_TMPOBJ ;
34727 PyObject *swig_obj[1] ;
34728
34729 arg2 = &temp2;
34730 arg3 = &temp3;
34731 if (!args) SWIG_fail;
34732 swig_obj[0] = args;
34733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34734 if (!SWIG_IsOK(res1)) {
34735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34736 }
34737 arg1 = reinterpret_cast< wxWindow * >(argp1);
34738 {
34739 PyThreadState* __tstate = wxPyBeginAllowThreads();
34740 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34741 wxPyEndAllowThreads(__tstate);
34742 if (PyErr_Occurred()) SWIG_fail;
34743 }
34744 resultobj = SWIG_Py_Void();
34745 if (SWIG_IsTmpObj(res2)) {
34746 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34747 } else {
34748 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34749 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34750 }
34751 if (SWIG_IsTmpObj(res3)) {
34752 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34753 } else {
34754 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34755 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34756 }
34757 return resultobj;
34758 fail:
34759 return NULL;
34760 }
34761
34762
34763 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34764 PyObject *resultobj = 0;
34765 wxWindow *arg1 = (wxWindow *) 0 ;
34766 wxPoint result;
34767 void *argp1 = 0 ;
34768 int res1 = 0 ;
34769 PyObject *swig_obj[1] ;
34770
34771 if (!args) SWIG_fail;
34772 swig_obj[0] = args;
34773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34774 if (!SWIG_IsOK(res1)) {
34775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34776 }
34777 arg1 = reinterpret_cast< wxWindow * >(argp1);
34778 {
34779 PyThreadState* __tstate = wxPyBeginAllowThreads();
34780 result = ((wxWindow const *)arg1)->GetScreenPosition();
34781 wxPyEndAllowThreads(__tstate);
34782 if (PyErr_Occurred()) SWIG_fail;
34783 }
34784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34785 return resultobj;
34786 fail:
34787 return NULL;
34788 }
34789
34790
34791 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34792 PyObject *resultobj = 0;
34793 wxWindow *arg1 = (wxWindow *) 0 ;
34794 int *arg2 = (int *) 0 ;
34795 int *arg3 = (int *) 0 ;
34796 void *argp1 = 0 ;
34797 int res1 = 0 ;
34798 int temp2 ;
34799 int res2 = SWIG_TMPOBJ ;
34800 int temp3 ;
34801 int res3 = SWIG_TMPOBJ ;
34802 PyObject *swig_obj[1] ;
34803
34804 arg2 = &temp2;
34805 arg3 = &temp3;
34806 if (!args) SWIG_fail;
34807 swig_obj[0] = args;
34808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34809 if (!SWIG_IsOK(res1)) {
34810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34811 }
34812 arg1 = reinterpret_cast< wxWindow * >(argp1);
34813 {
34814 PyThreadState* __tstate = wxPyBeginAllowThreads();
34815 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34816 wxPyEndAllowThreads(__tstate);
34817 if (PyErr_Occurred()) SWIG_fail;
34818 }
34819 resultobj = SWIG_Py_Void();
34820 if (SWIG_IsTmpObj(res2)) {
34821 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34822 } else {
34823 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34824 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34825 }
34826 if (SWIG_IsTmpObj(res3)) {
34827 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34828 } else {
34829 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34830 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34831 }
34832 return resultobj;
34833 fail:
34834 return NULL;
34835 }
34836
34837
34838 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34839 PyObject *resultobj = 0;
34840 wxWindow *arg1 = (wxWindow *) 0 ;
34841 wxRect result;
34842 void *argp1 = 0 ;
34843 int res1 = 0 ;
34844 PyObject *swig_obj[1] ;
34845
34846 if (!args) SWIG_fail;
34847 swig_obj[0] = args;
34848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34849 if (!SWIG_IsOK(res1)) {
34850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34851 }
34852 arg1 = reinterpret_cast< wxWindow * >(argp1);
34853 {
34854 PyThreadState* __tstate = wxPyBeginAllowThreads();
34855 result = ((wxWindow const *)arg1)->GetScreenRect();
34856 wxPyEndAllowThreads(__tstate);
34857 if (PyErr_Occurred()) SWIG_fail;
34858 }
34859 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34860 return resultobj;
34861 fail:
34862 return NULL;
34863 }
34864
34865
34866 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 PyObject *resultobj = 0;
34868 wxWindow *arg1 = (wxWindow *) 0 ;
34869 wxSize result;
34870 void *argp1 = 0 ;
34871 int res1 = 0 ;
34872 PyObject *swig_obj[1] ;
34873
34874 if (!args) SWIG_fail;
34875 swig_obj[0] = args;
34876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34877 if (!SWIG_IsOK(res1)) {
34878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34879 }
34880 arg1 = reinterpret_cast< wxWindow * >(argp1);
34881 {
34882 PyThreadState* __tstate = wxPyBeginAllowThreads();
34883 result = ((wxWindow const *)arg1)->GetSize();
34884 wxPyEndAllowThreads(__tstate);
34885 if (PyErr_Occurred()) SWIG_fail;
34886 }
34887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34888 return resultobj;
34889 fail:
34890 return NULL;
34891 }
34892
34893
34894 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34895 PyObject *resultobj = 0;
34896 wxWindow *arg1 = (wxWindow *) 0 ;
34897 int *arg2 = (int *) 0 ;
34898 int *arg3 = (int *) 0 ;
34899 void *argp1 = 0 ;
34900 int res1 = 0 ;
34901 int temp2 ;
34902 int res2 = SWIG_TMPOBJ ;
34903 int temp3 ;
34904 int res3 = SWIG_TMPOBJ ;
34905 PyObject *swig_obj[1] ;
34906
34907 arg2 = &temp2;
34908 arg3 = &temp3;
34909 if (!args) SWIG_fail;
34910 swig_obj[0] = args;
34911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34912 if (!SWIG_IsOK(res1)) {
34913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34914 }
34915 arg1 = reinterpret_cast< wxWindow * >(argp1);
34916 {
34917 PyThreadState* __tstate = wxPyBeginAllowThreads();
34918 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34919 wxPyEndAllowThreads(__tstate);
34920 if (PyErr_Occurred()) SWIG_fail;
34921 }
34922 resultobj = SWIG_Py_Void();
34923 if (SWIG_IsTmpObj(res2)) {
34924 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34925 } else {
34926 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34927 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34928 }
34929 if (SWIG_IsTmpObj(res3)) {
34930 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34931 } else {
34932 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34933 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34934 }
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34942 PyObject *resultobj = 0;
34943 wxWindow *arg1 = (wxWindow *) 0 ;
34944 wxRect result;
34945 void *argp1 = 0 ;
34946 int res1 = 0 ;
34947 PyObject *swig_obj[1] ;
34948
34949 if (!args) SWIG_fail;
34950 swig_obj[0] = args;
34951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34952 if (!SWIG_IsOK(res1)) {
34953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34954 }
34955 arg1 = reinterpret_cast< wxWindow * >(argp1);
34956 {
34957 PyThreadState* __tstate = wxPyBeginAllowThreads();
34958 result = ((wxWindow const *)arg1)->GetRect();
34959 wxPyEndAllowThreads(__tstate);
34960 if (PyErr_Occurred()) SWIG_fail;
34961 }
34962 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34963 return resultobj;
34964 fail:
34965 return NULL;
34966 }
34967
34968
34969 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34970 PyObject *resultobj = 0;
34971 wxWindow *arg1 = (wxWindow *) 0 ;
34972 wxSize result;
34973 void *argp1 = 0 ;
34974 int res1 = 0 ;
34975 PyObject *swig_obj[1] ;
34976
34977 if (!args) SWIG_fail;
34978 swig_obj[0] = args;
34979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34980 if (!SWIG_IsOK(res1)) {
34981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34982 }
34983 arg1 = reinterpret_cast< wxWindow * >(argp1);
34984 {
34985 PyThreadState* __tstate = wxPyBeginAllowThreads();
34986 result = ((wxWindow const *)arg1)->GetClientSize();
34987 wxPyEndAllowThreads(__tstate);
34988 if (PyErr_Occurred()) SWIG_fail;
34989 }
34990 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34991 return resultobj;
34992 fail:
34993 return NULL;
34994 }
34995
34996
34997 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34998 PyObject *resultobj = 0;
34999 wxWindow *arg1 = (wxWindow *) 0 ;
35000 int *arg2 = (int *) 0 ;
35001 int *arg3 = (int *) 0 ;
35002 void *argp1 = 0 ;
35003 int res1 = 0 ;
35004 int temp2 ;
35005 int res2 = SWIG_TMPOBJ ;
35006 int temp3 ;
35007 int res3 = SWIG_TMPOBJ ;
35008 PyObject *swig_obj[1] ;
35009
35010 arg2 = &temp2;
35011 arg3 = &temp3;
35012 if (!args) SWIG_fail;
35013 swig_obj[0] = args;
35014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35015 if (!SWIG_IsOK(res1)) {
35016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35017 }
35018 arg1 = reinterpret_cast< wxWindow * >(argp1);
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
35022 wxPyEndAllowThreads(__tstate);
35023 if (PyErr_Occurred()) SWIG_fail;
35024 }
35025 resultobj = SWIG_Py_Void();
35026 if (SWIG_IsTmpObj(res2)) {
35027 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35028 } else {
35029 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35031 }
35032 if (SWIG_IsTmpObj(res3)) {
35033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35034 } else {
35035 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35037 }
35038 return resultobj;
35039 fail:
35040 return NULL;
35041 }
35042
35043
35044 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35045 PyObject *resultobj = 0;
35046 wxWindow *arg1 = (wxWindow *) 0 ;
35047 wxPoint result;
35048 void *argp1 = 0 ;
35049 int res1 = 0 ;
35050 PyObject *swig_obj[1] ;
35051
35052 if (!args) SWIG_fail;
35053 swig_obj[0] = args;
35054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35055 if (!SWIG_IsOK(res1)) {
35056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
35057 }
35058 arg1 = reinterpret_cast< wxWindow * >(argp1);
35059 {
35060 PyThreadState* __tstate = wxPyBeginAllowThreads();
35061 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
35062 wxPyEndAllowThreads(__tstate);
35063 if (PyErr_Occurred()) SWIG_fail;
35064 }
35065 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35073 PyObject *resultobj = 0;
35074 wxWindow *arg1 = (wxWindow *) 0 ;
35075 wxRect result;
35076 void *argp1 = 0 ;
35077 int res1 = 0 ;
35078 PyObject *swig_obj[1] ;
35079
35080 if (!args) SWIG_fail;
35081 swig_obj[0] = args;
35082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35083 if (!SWIG_IsOK(res1)) {
35084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
35085 }
35086 arg1 = reinterpret_cast< wxWindow * >(argp1);
35087 {
35088 PyThreadState* __tstate = wxPyBeginAllowThreads();
35089 result = ((wxWindow const *)arg1)->GetClientRect();
35090 wxPyEndAllowThreads(__tstate);
35091 if (PyErr_Occurred()) SWIG_fail;
35092 }
35093 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
35094 return resultobj;
35095 fail:
35096 return NULL;
35097 }
35098
35099
35100 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 wxSize result;
35104 void *argp1 = 0 ;
35105 int res1 = 0 ;
35106 PyObject *swig_obj[1] ;
35107
35108 if (!args) SWIG_fail;
35109 swig_obj[0] = args;
35110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35113 }
35114 arg1 = reinterpret_cast< wxWindow * >(argp1);
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = ((wxWindow const *)arg1)->GetBestSize();
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35122 return resultobj;
35123 fail:
35124 return NULL;
35125 }
35126
35127
35128 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35129 PyObject *resultobj = 0;
35130 wxWindow *arg1 = (wxWindow *) 0 ;
35131 int *arg2 = (int *) 0 ;
35132 int *arg3 = (int *) 0 ;
35133 void *argp1 = 0 ;
35134 int res1 = 0 ;
35135 int temp2 ;
35136 int res2 = SWIG_TMPOBJ ;
35137 int temp3 ;
35138 int res3 = SWIG_TMPOBJ ;
35139 PyObject *swig_obj[1] ;
35140
35141 arg2 = &temp2;
35142 arg3 = &temp3;
35143 if (!args) SWIG_fail;
35144 swig_obj[0] = args;
35145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35146 if (!SWIG_IsOK(res1)) {
35147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35148 }
35149 arg1 = reinterpret_cast< wxWindow * >(argp1);
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_Py_Void();
35157 if (SWIG_IsTmpObj(res2)) {
35158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35159 } else {
35160 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35162 }
35163 if (SWIG_IsTmpObj(res3)) {
35164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35165 } else {
35166 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35167 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35168 }
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 void *argp1 = 0 ;
35179 int res1 = 0 ;
35180 PyObject *swig_obj[1] ;
35181
35182 if (!args) SWIG_fail;
35183 swig_obj[0] = args;
35184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35185 if (!SWIG_IsOK(res1)) {
35186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35187 }
35188 arg1 = reinterpret_cast< wxWindow * >(argp1);
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 (arg1)->InvalidateBestSize();
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_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35203 PyObject *resultobj = 0;
35204 wxWindow *arg1 = (wxWindow *) 0 ;
35205 wxSize *arg2 = 0 ;
35206 void *argp1 = 0 ;
35207 int res1 = 0 ;
35208 wxSize temp2 ;
35209 PyObject * obj0 = 0 ;
35210 PyObject * obj1 = 0 ;
35211 char * kwnames[] = {
35212 (char *) "self",(char *) "size", NULL
35213 };
35214
35215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
35216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35217 if (!SWIG_IsOK(res1)) {
35218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35219 }
35220 arg1 = reinterpret_cast< wxWindow * >(argp1);
35221 {
35222 arg2 = &temp2;
35223 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35224 }
35225 {
35226 PyThreadState* __tstate = wxPyBeginAllowThreads();
35227 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
35228 wxPyEndAllowThreads(__tstate);
35229 if (PyErr_Occurred()) SWIG_fail;
35230 }
35231 resultobj = SWIG_Py_Void();
35232 return resultobj;
35233 fail:
35234 return NULL;
35235 }
35236
35237
35238 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35239 PyObject *resultobj = 0;
35240 wxWindow *arg1 = (wxWindow *) 0 ;
35241 wxSize result;
35242 void *argp1 = 0 ;
35243 int res1 = 0 ;
35244 PyObject *swig_obj[1] ;
35245
35246 if (!args) SWIG_fail;
35247 swig_obj[0] = args;
35248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35249 if (!SWIG_IsOK(res1)) {
35250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35251 }
35252 arg1 = reinterpret_cast< wxWindow * >(argp1);
35253 {
35254 PyThreadState* __tstate = wxPyBeginAllowThreads();
35255 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
35256 wxPyEndAllowThreads(__tstate);
35257 if (PyErr_Occurred()) SWIG_fail;
35258 }
35259 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35260 return resultobj;
35261 fail:
35262 return NULL;
35263 }
35264
35265
35266 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35267 PyObject *resultobj = 0;
35268 wxWindow *arg1 = (wxWindow *) 0 ;
35269 int arg2 = (int) wxBOTH ;
35270 void *argp1 = 0 ;
35271 int res1 = 0 ;
35272 int val2 ;
35273 int ecode2 = 0 ;
35274 PyObject * obj0 = 0 ;
35275 PyObject * obj1 = 0 ;
35276 char * kwnames[] = {
35277 (char *) "self",(char *) "direction", NULL
35278 };
35279
35280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
35281 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35282 if (!SWIG_IsOK(res1)) {
35283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
35284 }
35285 arg1 = reinterpret_cast< wxWindow * >(argp1);
35286 if (obj1) {
35287 ecode2 = SWIG_AsVal_int(obj1, &val2);
35288 if (!SWIG_IsOK(ecode2)) {
35289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
35290 }
35291 arg2 = static_cast< int >(val2);
35292 }
35293 {
35294 PyThreadState* __tstate = wxPyBeginAllowThreads();
35295 (arg1)->Center(arg2);
35296 wxPyEndAllowThreads(__tstate);
35297 if (PyErr_Occurred()) SWIG_fail;
35298 }
35299 resultobj = SWIG_Py_Void();
35300 return resultobj;
35301 fail:
35302 return NULL;
35303 }
35304
35305
35306 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35307 PyObject *resultobj = 0;
35308 wxWindow *arg1 = (wxWindow *) 0 ;
35309 int arg2 = (int) wxBOTH ;
35310 void *argp1 = 0 ;
35311 int res1 = 0 ;
35312 int val2 ;
35313 int ecode2 = 0 ;
35314 PyObject * obj0 = 0 ;
35315 PyObject * obj1 = 0 ;
35316 char * kwnames[] = {
35317 (char *) "self",(char *) "dir", NULL
35318 };
35319
35320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
35321 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35322 if (!SWIG_IsOK(res1)) {
35323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
35324 }
35325 arg1 = reinterpret_cast< wxWindow * >(argp1);
35326 if (obj1) {
35327 ecode2 = SWIG_AsVal_int(obj1, &val2);
35328 if (!SWIG_IsOK(ecode2)) {
35329 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
35330 }
35331 arg2 = static_cast< int >(val2);
35332 }
35333 {
35334 PyThreadState* __tstate = wxPyBeginAllowThreads();
35335 (arg1)->CenterOnParent(arg2);
35336 wxPyEndAllowThreads(__tstate);
35337 if (PyErr_Occurred()) SWIG_fail;
35338 }
35339 resultobj = SWIG_Py_Void();
35340 return resultobj;
35341 fail:
35342 return NULL;
35343 }
35344
35345
35346 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35347 PyObject *resultobj = 0;
35348 wxWindow *arg1 = (wxWindow *) 0 ;
35349 void *argp1 = 0 ;
35350 int res1 = 0 ;
35351 PyObject *swig_obj[1] ;
35352
35353 if (!args) SWIG_fail;
35354 swig_obj[0] = args;
35355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35356 if (!SWIG_IsOK(res1)) {
35357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
35358 }
35359 arg1 = reinterpret_cast< wxWindow * >(argp1);
35360 {
35361 PyThreadState* __tstate = wxPyBeginAllowThreads();
35362 (arg1)->Fit();
35363 wxPyEndAllowThreads(__tstate);
35364 if (PyErr_Occurred()) SWIG_fail;
35365 }
35366 resultobj = SWIG_Py_Void();
35367 return resultobj;
35368 fail:
35369 return NULL;
35370 }
35371
35372
35373 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35374 PyObject *resultobj = 0;
35375 wxWindow *arg1 = (wxWindow *) 0 ;
35376 void *argp1 = 0 ;
35377 int res1 = 0 ;
35378 PyObject *swig_obj[1] ;
35379
35380 if (!args) SWIG_fail;
35381 swig_obj[0] = args;
35382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35383 if (!SWIG_IsOK(res1)) {
35384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
35385 }
35386 arg1 = reinterpret_cast< wxWindow * >(argp1);
35387 {
35388 PyThreadState* __tstate = wxPyBeginAllowThreads();
35389 (arg1)->FitInside();
35390 wxPyEndAllowThreads(__tstate);
35391 if (PyErr_Occurred()) SWIG_fail;
35392 }
35393 resultobj = SWIG_Py_Void();
35394 return resultobj;
35395 fail:
35396 return NULL;
35397 }
35398
35399
35400 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35401 PyObject *resultobj = 0;
35402 wxWindow *arg1 = (wxWindow *) 0 ;
35403 int arg2 ;
35404 int arg3 ;
35405 int arg4 = (int) -1 ;
35406 int arg5 = (int) -1 ;
35407 int arg6 = (int) -1 ;
35408 int arg7 = (int) -1 ;
35409 void *argp1 = 0 ;
35410 int res1 = 0 ;
35411 int val2 ;
35412 int ecode2 = 0 ;
35413 int val3 ;
35414 int ecode3 = 0 ;
35415 int val4 ;
35416 int ecode4 = 0 ;
35417 int val5 ;
35418 int ecode5 = 0 ;
35419 int val6 ;
35420 int ecode6 = 0 ;
35421 int val7 ;
35422 int ecode7 = 0 ;
35423 PyObject * obj0 = 0 ;
35424 PyObject * obj1 = 0 ;
35425 PyObject * obj2 = 0 ;
35426 PyObject * obj3 = 0 ;
35427 PyObject * obj4 = 0 ;
35428 PyObject * obj5 = 0 ;
35429 PyObject * obj6 = 0 ;
35430 char * kwnames[] = {
35431 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
35432 };
35433
35434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
35435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35436 if (!SWIG_IsOK(res1)) {
35437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35438 }
35439 arg1 = reinterpret_cast< wxWindow * >(argp1);
35440 ecode2 = SWIG_AsVal_int(obj1, &val2);
35441 if (!SWIG_IsOK(ecode2)) {
35442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
35443 }
35444 arg2 = static_cast< int >(val2);
35445 ecode3 = SWIG_AsVal_int(obj2, &val3);
35446 if (!SWIG_IsOK(ecode3)) {
35447 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
35448 }
35449 arg3 = static_cast< int >(val3);
35450 if (obj3) {
35451 ecode4 = SWIG_AsVal_int(obj3, &val4);
35452 if (!SWIG_IsOK(ecode4)) {
35453 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
35454 }
35455 arg4 = static_cast< int >(val4);
35456 }
35457 if (obj4) {
35458 ecode5 = SWIG_AsVal_int(obj4, &val5);
35459 if (!SWIG_IsOK(ecode5)) {
35460 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
35461 }
35462 arg5 = static_cast< int >(val5);
35463 }
35464 if (obj5) {
35465 ecode6 = SWIG_AsVal_int(obj5, &val6);
35466 if (!SWIG_IsOK(ecode6)) {
35467 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
35468 }
35469 arg6 = static_cast< int >(val6);
35470 }
35471 if (obj6) {
35472 ecode7 = SWIG_AsVal_int(obj6, &val7);
35473 if (!SWIG_IsOK(ecode7)) {
35474 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
35475 }
35476 arg7 = static_cast< int >(val7);
35477 }
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 resultobj = SWIG_Py_Void();
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35492 PyObject *resultobj = 0;
35493 wxWindow *arg1 = (wxWindow *) 0 ;
35494 wxSize *arg2 = 0 ;
35495 wxSize const &arg3_defvalue = wxDefaultSize ;
35496 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35497 wxSize const &arg4_defvalue = wxDefaultSize ;
35498 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35499 void *argp1 = 0 ;
35500 int res1 = 0 ;
35501 wxSize temp2 ;
35502 wxSize temp3 ;
35503 wxSize temp4 ;
35504 PyObject * obj0 = 0 ;
35505 PyObject * obj1 = 0 ;
35506 PyObject * obj2 = 0 ;
35507 PyObject * obj3 = 0 ;
35508 char * kwnames[] = {
35509 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35510 };
35511
35512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35514 if (!SWIG_IsOK(res1)) {
35515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35516 }
35517 arg1 = reinterpret_cast< wxWindow * >(argp1);
35518 {
35519 arg2 = &temp2;
35520 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35521 }
35522 if (obj2) {
35523 {
35524 arg3 = &temp3;
35525 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35526 }
35527 }
35528 if (obj3) {
35529 {
35530 arg4 = &temp4;
35531 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35532 }
35533 }
35534 {
35535 PyThreadState* __tstate = wxPyBeginAllowThreads();
35536 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35537 wxPyEndAllowThreads(__tstate);
35538 if (PyErr_Occurred()) SWIG_fail;
35539 }
35540 resultobj = SWIG_Py_Void();
35541 return resultobj;
35542 fail:
35543 return NULL;
35544 }
35545
35546
35547 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35548 PyObject *resultobj = 0;
35549 wxWindow *arg1 = (wxWindow *) 0 ;
35550 int arg2 ;
35551 int arg3 ;
35552 int arg4 = (int) -1 ;
35553 int arg5 = (int) -1 ;
35554 void *argp1 = 0 ;
35555 int res1 = 0 ;
35556 int val2 ;
35557 int ecode2 = 0 ;
35558 int val3 ;
35559 int ecode3 = 0 ;
35560 int val4 ;
35561 int ecode4 = 0 ;
35562 int val5 ;
35563 int ecode5 = 0 ;
35564 PyObject * obj0 = 0 ;
35565 PyObject * obj1 = 0 ;
35566 PyObject * obj2 = 0 ;
35567 PyObject * obj3 = 0 ;
35568 PyObject * obj4 = 0 ;
35569 char * kwnames[] = {
35570 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35571 };
35572
35573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35575 if (!SWIG_IsOK(res1)) {
35576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35577 }
35578 arg1 = reinterpret_cast< wxWindow * >(argp1);
35579 ecode2 = SWIG_AsVal_int(obj1, &val2);
35580 if (!SWIG_IsOK(ecode2)) {
35581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35582 }
35583 arg2 = static_cast< int >(val2);
35584 ecode3 = SWIG_AsVal_int(obj2, &val3);
35585 if (!SWIG_IsOK(ecode3)) {
35586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35587 }
35588 arg3 = static_cast< int >(val3);
35589 if (obj3) {
35590 ecode4 = SWIG_AsVal_int(obj3, &val4);
35591 if (!SWIG_IsOK(ecode4)) {
35592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35593 }
35594 arg4 = static_cast< int >(val4);
35595 }
35596 if (obj4) {
35597 ecode5 = SWIG_AsVal_int(obj4, &val5);
35598 if (!SWIG_IsOK(ecode5)) {
35599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35600 }
35601 arg5 = static_cast< int >(val5);
35602 }
35603 {
35604 PyThreadState* __tstate = wxPyBeginAllowThreads();
35605 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35606 wxPyEndAllowThreads(__tstate);
35607 if (PyErr_Occurred()) SWIG_fail;
35608 }
35609 resultobj = SWIG_Py_Void();
35610 return resultobj;
35611 fail:
35612 return NULL;
35613 }
35614
35615
35616 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35617 PyObject *resultobj = 0;
35618 wxWindow *arg1 = (wxWindow *) 0 ;
35619 wxSize *arg2 = 0 ;
35620 wxSize const &arg3_defvalue = wxDefaultSize ;
35621 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35622 void *argp1 = 0 ;
35623 int res1 = 0 ;
35624 wxSize temp2 ;
35625 wxSize temp3 ;
35626 PyObject * obj0 = 0 ;
35627 PyObject * obj1 = 0 ;
35628 PyObject * obj2 = 0 ;
35629 char * kwnames[] = {
35630 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35631 };
35632
35633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35635 if (!SWIG_IsOK(res1)) {
35636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35637 }
35638 arg1 = reinterpret_cast< wxWindow * >(argp1);
35639 {
35640 arg2 = &temp2;
35641 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35642 }
35643 if (obj2) {
35644 {
35645 arg3 = &temp3;
35646 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35647 }
35648 }
35649 {
35650 PyThreadState* __tstate = wxPyBeginAllowThreads();
35651 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35652 wxPyEndAllowThreads(__tstate);
35653 if (PyErr_Occurred()) SWIG_fail;
35654 }
35655 resultobj = SWIG_Py_Void();
35656 return resultobj;
35657 fail:
35658 return NULL;
35659 }
35660
35661
35662 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35663 PyObject *resultobj = 0;
35664 wxWindow *arg1 = (wxWindow *) 0 ;
35665 wxSize result;
35666 void *argp1 = 0 ;
35667 int res1 = 0 ;
35668 PyObject *swig_obj[1] ;
35669
35670 if (!args) SWIG_fail;
35671 swig_obj[0] = args;
35672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35673 if (!SWIG_IsOK(res1)) {
35674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35675 }
35676 arg1 = reinterpret_cast< wxWindow * >(argp1);
35677 {
35678 PyThreadState* __tstate = wxPyBeginAllowThreads();
35679 result = ((wxWindow const *)arg1)->GetMaxSize();
35680 wxPyEndAllowThreads(__tstate);
35681 if (PyErr_Occurred()) SWIG_fail;
35682 }
35683 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35691 PyObject *resultobj = 0;
35692 wxWindow *arg1 = (wxWindow *) 0 ;
35693 wxSize result;
35694 void *argp1 = 0 ;
35695 int res1 = 0 ;
35696 PyObject *swig_obj[1] ;
35697
35698 if (!args) SWIG_fail;
35699 swig_obj[0] = args;
35700 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35701 if (!SWIG_IsOK(res1)) {
35702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35703 }
35704 arg1 = reinterpret_cast< wxWindow * >(argp1);
35705 {
35706 PyThreadState* __tstate = wxPyBeginAllowThreads();
35707 result = ((wxWindow const *)arg1)->GetMinSize();
35708 wxPyEndAllowThreads(__tstate);
35709 if (PyErr_Occurred()) SWIG_fail;
35710 }
35711 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35712 return resultobj;
35713 fail:
35714 return NULL;
35715 }
35716
35717
35718 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35719 PyObject *resultobj = 0;
35720 wxWindow *arg1 = (wxWindow *) 0 ;
35721 wxSize *arg2 = 0 ;
35722 void *argp1 = 0 ;
35723 int res1 = 0 ;
35724 wxSize temp2 ;
35725 PyObject * obj0 = 0 ;
35726 PyObject * obj1 = 0 ;
35727 char * kwnames[] = {
35728 (char *) "self",(char *) "minSize", NULL
35729 };
35730
35731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35733 if (!SWIG_IsOK(res1)) {
35734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35735 }
35736 arg1 = reinterpret_cast< wxWindow * >(argp1);
35737 {
35738 arg2 = &temp2;
35739 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35740 }
35741 {
35742 PyThreadState* __tstate = wxPyBeginAllowThreads();
35743 (arg1)->SetMinSize((wxSize const &)*arg2);
35744 wxPyEndAllowThreads(__tstate);
35745 if (PyErr_Occurred()) SWIG_fail;
35746 }
35747 resultobj = SWIG_Py_Void();
35748 return resultobj;
35749 fail:
35750 return NULL;
35751 }
35752
35753
35754 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35755 PyObject *resultobj = 0;
35756 wxWindow *arg1 = (wxWindow *) 0 ;
35757 wxSize *arg2 = 0 ;
35758 void *argp1 = 0 ;
35759 int res1 = 0 ;
35760 wxSize temp2 ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 char * kwnames[] = {
35764 (char *) "self",(char *) "maxSize", NULL
35765 };
35766
35767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35771 }
35772 arg1 = reinterpret_cast< wxWindow * >(argp1);
35773 {
35774 arg2 = &temp2;
35775 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35776 }
35777 {
35778 PyThreadState* __tstate = wxPyBeginAllowThreads();
35779 (arg1)->SetMaxSize((wxSize const &)*arg2);
35780 wxPyEndAllowThreads(__tstate);
35781 if (PyErr_Occurred()) SWIG_fail;
35782 }
35783 resultobj = SWIG_Py_Void();
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35791 PyObject *resultobj = 0;
35792 wxWindow *arg1 = (wxWindow *) 0 ;
35793 int result;
35794 void *argp1 = 0 ;
35795 int res1 = 0 ;
35796 PyObject *swig_obj[1] ;
35797
35798 if (!args) SWIG_fail;
35799 swig_obj[0] = args;
35800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35801 if (!SWIG_IsOK(res1)) {
35802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35803 }
35804 arg1 = reinterpret_cast< wxWindow * >(argp1);
35805 {
35806 PyThreadState* __tstate = wxPyBeginAllowThreads();
35807 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35808 wxPyEndAllowThreads(__tstate);
35809 if (PyErr_Occurred()) SWIG_fail;
35810 }
35811 resultobj = SWIG_From_int(static_cast< int >(result));
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35819 PyObject *resultobj = 0;
35820 wxWindow *arg1 = (wxWindow *) 0 ;
35821 int result;
35822 void *argp1 = 0 ;
35823 int res1 = 0 ;
35824 PyObject *swig_obj[1] ;
35825
35826 if (!args) SWIG_fail;
35827 swig_obj[0] = args;
35828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35829 if (!SWIG_IsOK(res1)) {
35830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35831 }
35832 arg1 = reinterpret_cast< wxWindow * >(argp1);
35833 {
35834 PyThreadState* __tstate = wxPyBeginAllowThreads();
35835 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35836 wxPyEndAllowThreads(__tstate);
35837 if (PyErr_Occurred()) SWIG_fail;
35838 }
35839 resultobj = SWIG_From_int(static_cast< int >(result));
35840 return resultobj;
35841 fail:
35842 return NULL;
35843 }
35844
35845
35846 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35847 PyObject *resultobj = 0;
35848 wxWindow *arg1 = (wxWindow *) 0 ;
35849 int result;
35850 void *argp1 = 0 ;
35851 int res1 = 0 ;
35852 PyObject *swig_obj[1] ;
35853
35854 if (!args) SWIG_fail;
35855 swig_obj[0] = args;
35856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35857 if (!SWIG_IsOK(res1)) {
35858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35859 }
35860 arg1 = reinterpret_cast< wxWindow * >(argp1);
35861 {
35862 PyThreadState* __tstate = wxPyBeginAllowThreads();
35863 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35864 wxPyEndAllowThreads(__tstate);
35865 if (PyErr_Occurred()) SWIG_fail;
35866 }
35867 resultobj = SWIG_From_int(static_cast< int >(result));
35868 return resultobj;
35869 fail:
35870 return NULL;
35871 }
35872
35873
35874 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35875 PyObject *resultobj = 0;
35876 wxWindow *arg1 = (wxWindow *) 0 ;
35877 int result;
35878 void *argp1 = 0 ;
35879 int res1 = 0 ;
35880 PyObject *swig_obj[1] ;
35881
35882 if (!args) SWIG_fail;
35883 swig_obj[0] = args;
35884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35885 if (!SWIG_IsOK(res1)) {
35886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35887 }
35888 arg1 = reinterpret_cast< wxWindow * >(argp1);
35889 {
35890 PyThreadState* __tstate = wxPyBeginAllowThreads();
35891 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35892 wxPyEndAllowThreads(__tstate);
35893 if (PyErr_Occurred()) SWIG_fail;
35894 }
35895 resultobj = SWIG_From_int(static_cast< int >(result));
35896 return resultobj;
35897 fail:
35898 return NULL;
35899 }
35900
35901
35902 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35903 PyObject *resultobj = 0;
35904 wxWindow *arg1 = (wxWindow *) 0 ;
35905 wxSize *arg2 = 0 ;
35906 void *argp1 = 0 ;
35907 int res1 = 0 ;
35908 wxSize temp2 ;
35909 PyObject * obj0 = 0 ;
35910 PyObject * obj1 = 0 ;
35911 char * kwnames[] = {
35912 (char *) "self",(char *) "size", NULL
35913 };
35914
35915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35917 if (!SWIG_IsOK(res1)) {
35918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35919 }
35920 arg1 = reinterpret_cast< wxWindow * >(argp1);
35921 {
35922 arg2 = &temp2;
35923 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35924 }
35925 {
35926 PyThreadState* __tstate = wxPyBeginAllowThreads();
35927 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 resultobj = SWIG_Py_Void();
35932 return resultobj;
35933 fail:
35934 return NULL;
35935 }
35936
35937
35938 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35939 PyObject *resultobj = 0;
35940 wxWindow *arg1 = (wxWindow *) 0 ;
35941 int arg2 ;
35942 int arg3 ;
35943 void *argp1 = 0 ;
35944 int res1 = 0 ;
35945 int val2 ;
35946 int ecode2 = 0 ;
35947 int val3 ;
35948 int ecode3 = 0 ;
35949 PyObject * obj0 = 0 ;
35950 PyObject * obj1 = 0 ;
35951 PyObject * obj2 = 0 ;
35952 char * kwnames[] = {
35953 (char *) "self",(char *) "w",(char *) "h", NULL
35954 };
35955
35956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35958 if (!SWIG_IsOK(res1)) {
35959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35960 }
35961 arg1 = reinterpret_cast< wxWindow * >(argp1);
35962 ecode2 = SWIG_AsVal_int(obj1, &val2);
35963 if (!SWIG_IsOK(ecode2)) {
35964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35965 }
35966 arg2 = static_cast< int >(val2);
35967 ecode3 = SWIG_AsVal_int(obj2, &val3);
35968 if (!SWIG_IsOK(ecode3)) {
35969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35970 }
35971 arg3 = static_cast< int >(val3);
35972 {
35973 PyThreadState* __tstate = wxPyBeginAllowThreads();
35974 (arg1)->SetVirtualSize(arg2,arg3);
35975 wxPyEndAllowThreads(__tstate);
35976 if (PyErr_Occurred()) SWIG_fail;
35977 }
35978 resultobj = SWIG_Py_Void();
35979 return resultobj;
35980 fail:
35981 return NULL;
35982 }
35983
35984
35985 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35986 PyObject *resultobj = 0;
35987 wxWindow *arg1 = (wxWindow *) 0 ;
35988 wxSize result;
35989 void *argp1 = 0 ;
35990 int res1 = 0 ;
35991 PyObject *swig_obj[1] ;
35992
35993 if (!args) SWIG_fail;
35994 swig_obj[0] = args;
35995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35996 if (!SWIG_IsOK(res1)) {
35997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35998 }
35999 arg1 = reinterpret_cast< wxWindow * >(argp1);
36000 {
36001 PyThreadState* __tstate = wxPyBeginAllowThreads();
36002 result = ((wxWindow const *)arg1)->GetVirtualSize();
36003 wxPyEndAllowThreads(__tstate);
36004 if (PyErr_Occurred()) SWIG_fail;
36005 }
36006 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36014 PyObject *resultobj = 0;
36015 wxWindow *arg1 = (wxWindow *) 0 ;
36016 int *arg2 = (int *) 0 ;
36017 int *arg3 = (int *) 0 ;
36018 void *argp1 = 0 ;
36019 int res1 = 0 ;
36020 int temp2 ;
36021 int res2 = SWIG_TMPOBJ ;
36022 int temp3 ;
36023 int res3 = SWIG_TMPOBJ ;
36024 PyObject *swig_obj[1] ;
36025
36026 arg2 = &temp2;
36027 arg3 = &temp3;
36028 if (!args) SWIG_fail;
36029 swig_obj[0] = args;
36030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36031 if (!SWIG_IsOK(res1)) {
36032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
36033 }
36034 arg1 = reinterpret_cast< wxWindow * >(argp1);
36035 {
36036 PyThreadState* __tstate = wxPyBeginAllowThreads();
36037 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
36038 wxPyEndAllowThreads(__tstate);
36039 if (PyErr_Occurred()) SWIG_fail;
36040 }
36041 resultobj = SWIG_Py_Void();
36042 if (SWIG_IsTmpObj(res2)) {
36043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
36044 } else {
36045 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
36047 }
36048 if (SWIG_IsTmpObj(res3)) {
36049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
36050 } else {
36051 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
36052 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
36053 }
36054 return resultobj;
36055 fail:
36056 return NULL;
36057 }
36058
36059
36060 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36061 PyObject *resultobj = 0;
36062 wxWindow *arg1 = (wxWindow *) 0 ;
36063 wxSize result;
36064 void *argp1 = 0 ;
36065 int res1 = 0 ;
36066 PyObject *swig_obj[1] ;
36067
36068 if (!args) SWIG_fail;
36069 swig_obj[0] = args;
36070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36071 if (!SWIG_IsOK(res1)) {
36072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36073 }
36074 arg1 = reinterpret_cast< wxWindow * >(argp1);
36075 {
36076 PyThreadState* __tstate = wxPyBeginAllowThreads();
36077 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
36078 wxPyEndAllowThreads(__tstate);
36079 if (PyErr_Occurred()) SWIG_fail;
36080 }
36081 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36082 return resultobj;
36083 fail:
36084 return NULL;
36085 }
36086
36087
36088 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36089 PyObject *resultobj = 0;
36090 wxWindow *arg1 = (wxWindow *) 0 ;
36091 wxSize result;
36092 void *argp1 = 0 ;
36093 int res1 = 0 ;
36094 PyObject *swig_obj[1] ;
36095
36096 if (!args) SWIG_fail;
36097 swig_obj[0] = args;
36098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36099 if (!SWIG_IsOK(res1)) {
36100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
36101 }
36102 arg1 = reinterpret_cast< wxWindow * >(argp1);
36103 {
36104 PyThreadState* __tstate = wxPyBeginAllowThreads();
36105 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
36106 wxPyEndAllowThreads(__tstate);
36107 if (PyErr_Occurred()) SWIG_fail;
36108 }
36109 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
36110 return resultobj;
36111 fail:
36112 return NULL;
36113 }
36114
36115
36116 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36117 PyObject *resultobj = 0;
36118 wxWindow *arg1 = (wxWindow *) 0 ;
36119 bool arg2 = (bool) true ;
36120 bool result;
36121 void *argp1 = 0 ;
36122 int res1 = 0 ;
36123 bool val2 ;
36124 int ecode2 = 0 ;
36125 PyObject * obj0 = 0 ;
36126 PyObject * obj1 = 0 ;
36127 char * kwnames[] = {
36128 (char *) "self",(char *) "show", NULL
36129 };
36130
36131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
36132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36133 if (!SWIG_IsOK(res1)) {
36134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
36135 }
36136 arg1 = reinterpret_cast< wxWindow * >(argp1);
36137 if (obj1) {
36138 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36139 if (!SWIG_IsOK(ecode2)) {
36140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
36141 }
36142 arg2 = static_cast< bool >(val2);
36143 }
36144 {
36145 PyThreadState* __tstate = wxPyBeginAllowThreads();
36146 result = (bool)(arg1)->Show(arg2);
36147 wxPyEndAllowThreads(__tstate);
36148 if (PyErr_Occurred()) SWIG_fail;
36149 }
36150 {
36151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36152 }
36153 return resultobj;
36154 fail:
36155 return NULL;
36156 }
36157
36158
36159 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36160 PyObject *resultobj = 0;
36161 wxWindow *arg1 = (wxWindow *) 0 ;
36162 bool result;
36163 void *argp1 = 0 ;
36164 int res1 = 0 ;
36165 PyObject *swig_obj[1] ;
36166
36167 if (!args) SWIG_fail;
36168 swig_obj[0] = args;
36169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36170 if (!SWIG_IsOK(res1)) {
36171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
36172 }
36173 arg1 = reinterpret_cast< wxWindow * >(argp1);
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 result = (bool)(arg1)->Hide();
36177 wxPyEndAllowThreads(__tstate);
36178 if (PyErr_Occurred()) SWIG_fail;
36179 }
36180 {
36181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36182 }
36183 return resultobj;
36184 fail:
36185 return NULL;
36186 }
36187
36188
36189 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36190 PyObject *resultobj = 0;
36191 wxWindow *arg1 = (wxWindow *) 0 ;
36192 bool arg2 = (bool) true ;
36193 bool result;
36194 void *argp1 = 0 ;
36195 int res1 = 0 ;
36196 bool val2 ;
36197 int ecode2 = 0 ;
36198 PyObject * obj0 = 0 ;
36199 PyObject * obj1 = 0 ;
36200 char * kwnames[] = {
36201 (char *) "self",(char *) "enable", NULL
36202 };
36203
36204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
36205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36206 if (!SWIG_IsOK(res1)) {
36207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
36208 }
36209 arg1 = reinterpret_cast< wxWindow * >(argp1);
36210 if (obj1) {
36211 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36212 if (!SWIG_IsOK(ecode2)) {
36213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
36214 }
36215 arg2 = static_cast< bool >(val2);
36216 }
36217 {
36218 PyThreadState* __tstate = wxPyBeginAllowThreads();
36219 result = (bool)(arg1)->Enable(arg2);
36220 wxPyEndAllowThreads(__tstate);
36221 if (PyErr_Occurred()) SWIG_fail;
36222 }
36223 {
36224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36225 }
36226 return resultobj;
36227 fail:
36228 return NULL;
36229 }
36230
36231
36232 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36233 PyObject *resultobj = 0;
36234 wxWindow *arg1 = (wxWindow *) 0 ;
36235 bool result;
36236 void *argp1 = 0 ;
36237 int res1 = 0 ;
36238 PyObject *swig_obj[1] ;
36239
36240 if (!args) SWIG_fail;
36241 swig_obj[0] = args;
36242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36243 if (!SWIG_IsOK(res1)) {
36244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
36245 }
36246 arg1 = reinterpret_cast< wxWindow * >(argp1);
36247 {
36248 PyThreadState* __tstate = wxPyBeginAllowThreads();
36249 result = (bool)(arg1)->Disable();
36250 wxPyEndAllowThreads(__tstate);
36251 if (PyErr_Occurred()) SWIG_fail;
36252 }
36253 {
36254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36255 }
36256 return resultobj;
36257 fail:
36258 return NULL;
36259 }
36260
36261
36262 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36263 PyObject *resultobj = 0;
36264 wxWindow *arg1 = (wxWindow *) 0 ;
36265 bool result;
36266 void *argp1 = 0 ;
36267 int res1 = 0 ;
36268 PyObject *swig_obj[1] ;
36269
36270 if (!args) SWIG_fail;
36271 swig_obj[0] = args;
36272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36273 if (!SWIG_IsOK(res1)) {
36274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
36275 }
36276 arg1 = reinterpret_cast< wxWindow * >(argp1);
36277 {
36278 PyThreadState* __tstate = wxPyBeginAllowThreads();
36279 result = (bool)((wxWindow const *)arg1)->IsShown();
36280 wxPyEndAllowThreads(__tstate);
36281 if (PyErr_Occurred()) SWIG_fail;
36282 }
36283 {
36284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36285 }
36286 return resultobj;
36287 fail:
36288 return NULL;
36289 }
36290
36291
36292 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36293 PyObject *resultobj = 0;
36294 wxWindow *arg1 = (wxWindow *) 0 ;
36295 bool result;
36296 void *argp1 = 0 ;
36297 int res1 = 0 ;
36298 PyObject *swig_obj[1] ;
36299
36300 if (!args) SWIG_fail;
36301 swig_obj[0] = args;
36302 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36303 if (!SWIG_IsOK(res1)) {
36304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36305 }
36306 arg1 = reinterpret_cast< wxWindow * >(argp1);
36307 {
36308 PyThreadState* __tstate = wxPyBeginAllowThreads();
36309 result = (bool)((wxWindow const *)arg1)->IsEnabled();
36310 wxPyEndAllowThreads(__tstate);
36311 if (PyErr_Occurred()) SWIG_fail;
36312 }
36313 {
36314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36315 }
36316 return resultobj;
36317 fail:
36318 return NULL;
36319 }
36320
36321
36322 SWIGINTERN PyObject *_wrap_Window_IsThisEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36323 PyObject *resultobj = 0;
36324 wxWindow *arg1 = (wxWindow *) 0 ;
36325 bool result;
36326 void *argp1 = 0 ;
36327 int res1 = 0 ;
36328 PyObject *swig_obj[1] ;
36329
36330 if (!args) SWIG_fail;
36331 swig_obj[0] = args;
36332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36333 if (!SWIG_IsOK(res1)) {
36334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsThisEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36335 }
36336 arg1 = reinterpret_cast< wxWindow * >(argp1);
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 result = (bool)((wxWindow const *)arg1)->IsThisEnabled();
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 {
36344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36345 }
36346 return resultobj;
36347 fail:
36348 return NULL;
36349 }
36350
36351
36352 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36353 PyObject *resultobj = 0;
36354 wxWindow *arg1 = (wxWindow *) 0 ;
36355 bool result;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 PyObject *swig_obj[1] ;
36359
36360 if (!args) SWIG_fail;
36361 swig_obj[0] = args;
36362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36363 if (!SWIG_IsOK(res1)) {
36364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
36365 }
36366 arg1 = reinterpret_cast< wxWindow * >(argp1);
36367 {
36368 PyThreadState* __tstate = wxPyBeginAllowThreads();
36369 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
36370 wxPyEndAllowThreads(__tstate);
36371 if (PyErr_Occurred()) SWIG_fail;
36372 }
36373 {
36374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36375 }
36376 return resultobj;
36377 fail:
36378 return NULL;
36379 }
36380
36381
36382 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36383 PyObject *resultobj = 0;
36384 wxWindow *arg1 = (wxWindow *) 0 ;
36385 long arg2 ;
36386 void *argp1 = 0 ;
36387 int res1 = 0 ;
36388 long val2 ;
36389 int ecode2 = 0 ;
36390 PyObject * obj0 = 0 ;
36391 PyObject * obj1 = 0 ;
36392 char * kwnames[] = {
36393 (char *) "self",(char *) "style", NULL
36394 };
36395
36396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36398 if (!SWIG_IsOK(res1)) {
36399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
36400 }
36401 arg1 = reinterpret_cast< wxWindow * >(argp1);
36402 ecode2 = SWIG_AsVal_long(obj1, &val2);
36403 if (!SWIG_IsOK(ecode2)) {
36404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
36405 }
36406 arg2 = static_cast< long >(val2);
36407 {
36408 PyThreadState* __tstate = wxPyBeginAllowThreads();
36409 (arg1)->SetWindowStyleFlag(arg2);
36410 wxPyEndAllowThreads(__tstate);
36411 if (PyErr_Occurred()) SWIG_fail;
36412 }
36413 resultobj = SWIG_Py_Void();
36414 return resultobj;
36415 fail:
36416 return NULL;
36417 }
36418
36419
36420 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36421 PyObject *resultobj = 0;
36422 wxWindow *arg1 = (wxWindow *) 0 ;
36423 long result;
36424 void *argp1 = 0 ;
36425 int res1 = 0 ;
36426 PyObject *swig_obj[1] ;
36427
36428 if (!args) SWIG_fail;
36429 swig_obj[0] = args;
36430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36431 if (!SWIG_IsOK(res1)) {
36432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36433 }
36434 arg1 = reinterpret_cast< wxWindow * >(argp1);
36435 {
36436 PyThreadState* __tstate = wxPyBeginAllowThreads();
36437 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
36438 wxPyEndAllowThreads(__tstate);
36439 if (PyErr_Occurred()) SWIG_fail;
36440 }
36441 resultobj = SWIG_From_long(static_cast< long >(result));
36442 return resultobj;
36443 fail:
36444 return NULL;
36445 }
36446
36447
36448 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36449 PyObject *resultobj = 0;
36450 wxWindow *arg1 = (wxWindow *) 0 ;
36451 int arg2 ;
36452 bool result;
36453 void *argp1 = 0 ;
36454 int res1 = 0 ;
36455 int val2 ;
36456 int ecode2 = 0 ;
36457 PyObject * obj0 = 0 ;
36458 PyObject * obj1 = 0 ;
36459 char * kwnames[] = {
36460 (char *) "self",(char *) "flag", NULL
36461 };
36462
36463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
36464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36465 if (!SWIG_IsOK(res1)) {
36466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
36467 }
36468 arg1 = reinterpret_cast< wxWindow * >(argp1);
36469 ecode2 = SWIG_AsVal_int(obj1, &val2);
36470 if (!SWIG_IsOK(ecode2)) {
36471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
36472 }
36473 arg2 = static_cast< int >(val2);
36474 {
36475 PyThreadState* __tstate = wxPyBeginAllowThreads();
36476 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 {
36481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36482 }
36483 return resultobj;
36484 fail:
36485 return NULL;
36486 }
36487
36488
36489 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36490 PyObject *resultobj = 0;
36491 wxWindow *arg1 = (wxWindow *) 0 ;
36492 bool result;
36493 void *argp1 = 0 ;
36494 int res1 = 0 ;
36495 PyObject *swig_obj[1] ;
36496
36497 if (!args) SWIG_fail;
36498 swig_obj[0] = args;
36499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36500 if (!SWIG_IsOK(res1)) {
36501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
36502 }
36503 arg1 = reinterpret_cast< wxWindow * >(argp1);
36504 {
36505 PyThreadState* __tstate = wxPyBeginAllowThreads();
36506 result = (bool)((wxWindow const *)arg1)->IsRetained();
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 {
36511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36512 }
36513 return resultobj;
36514 fail:
36515 return NULL;
36516 }
36517
36518
36519 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36520 PyObject *resultobj = 0;
36521 wxWindow *arg1 = (wxWindow *) 0 ;
36522 int arg2 ;
36523 bool result;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 int val2 ;
36527 int ecode2 = 0 ;
36528 PyObject * obj0 = 0 ;
36529 PyObject * obj1 = 0 ;
36530 char * kwnames[] = {
36531 (char *) "self",(char *) "flag", NULL
36532 };
36533
36534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res1)) {
36537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36538 }
36539 arg1 = reinterpret_cast< wxWindow * >(argp1);
36540 ecode2 = SWIG_AsVal_int(obj1, &val2);
36541 if (!SWIG_IsOK(ecode2)) {
36542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36543 }
36544 arg2 = static_cast< int >(val2);
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36548 wxPyEndAllowThreads(__tstate);
36549 if (PyErr_Occurred()) SWIG_fail;
36550 }
36551 {
36552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36553 }
36554 return resultobj;
36555 fail:
36556 return NULL;
36557 }
36558
36559
36560 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36561 PyObject *resultobj = 0;
36562 wxWindow *arg1 = (wxWindow *) 0 ;
36563 long arg2 ;
36564 void *argp1 = 0 ;
36565 int res1 = 0 ;
36566 long val2 ;
36567 int ecode2 = 0 ;
36568 PyObject * obj0 = 0 ;
36569 PyObject * obj1 = 0 ;
36570 char * kwnames[] = {
36571 (char *) "self",(char *) "exStyle", NULL
36572 };
36573
36574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36576 if (!SWIG_IsOK(res1)) {
36577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36578 }
36579 arg1 = reinterpret_cast< wxWindow * >(argp1);
36580 ecode2 = SWIG_AsVal_long(obj1, &val2);
36581 if (!SWIG_IsOK(ecode2)) {
36582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36583 }
36584 arg2 = static_cast< long >(val2);
36585 {
36586 PyThreadState* __tstate = wxPyBeginAllowThreads();
36587 (arg1)->SetExtraStyle(arg2);
36588 wxPyEndAllowThreads(__tstate);
36589 if (PyErr_Occurred()) SWIG_fail;
36590 }
36591 resultobj = SWIG_Py_Void();
36592 return resultobj;
36593 fail:
36594 return NULL;
36595 }
36596
36597
36598 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36599 PyObject *resultobj = 0;
36600 wxWindow *arg1 = (wxWindow *) 0 ;
36601 long result;
36602 void *argp1 = 0 ;
36603 int res1 = 0 ;
36604 PyObject *swig_obj[1] ;
36605
36606 if (!args) SWIG_fail;
36607 swig_obj[0] = args;
36608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36609 if (!SWIG_IsOK(res1)) {
36610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36611 }
36612 arg1 = reinterpret_cast< wxWindow * >(argp1);
36613 {
36614 PyThreadState* __tstate = wxPyBeginAllowThreads();
36615 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36616 wxPyEndAllowThreads(__tstate);
36617 if (PyErr_Occurred()) SWIG_fail;
36618 }
36619 resultobj = SWIG_From_long(static_cast< long >(result));
36620 return resultobj;
36621 fail:
36622 return NULL;
36623 }
36624
36625
36626 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36627 PyObject *resultobj = 0;
36628 wxWindow *arg1 = (wxWindow *) 0 ;
36629 bool arg2 = (bool) true ;
36630 void *argp1 = 0 ;
36631 int res1 = 0 ;
36632 bool val2 ;
36633 int ecode2 = 0 ;
36634 PyObject * obj0 = 0 ;
36635 PyObject * obj1 = 0 ;
36636 char * kwnames[] = {
36637 (char *) "self",(char *) "modal", NULL
36638 };
36639
36640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36642 if (!SWIG_IsOK(res1)) {
36643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36644 }
36645 arg1 = reinterpret_cast< wxWindow * >(argp1);
36646 if (obj1) {
36647 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36648 if (!SWIG_IsOK(ecode2)) {
36649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36650 }
36651 arg2 = static_cast< bool >(val2);
36652 }
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 (arg1)->MakeModal(arg2);
36656 wxPyEndAllowThreads(__tstate);
36657 if (PyErr_Occurred()) SWIG_fail;
36658 }
36659 resultobj = SWIG_Py_Void();
36660 return resultobj;
36661 fail:
36662 return NULL;
36663 }
36664
36665
36666 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36667 PyObject *resultobj = 0;
36668 wxWindow *arg1 = (wxWindow *) 0 ;
36669 bool arg2 ;
36670 void *argp1 = 0 ;
36671 int res1 = 0 ;
36672 bool val2 ;
36673 int ecode2 = 0 ;
36674 PyObject * obj0 = 0 ;
36675 PyObject * obj1 = 0 ;
36676 char * kwnames[] = {
36677 (char *) "self",(char *) "enableTheme", NULL
36678 };
36679
36680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36682 if (!SWIG_IsOK(res1)) {
36683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36684 }
36685 arg1 = reinterpret_cast< wxWindow * >(argp1);
36686 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36687 if (!SWIG_IsOK(ecode2)) {
36688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36689 }
36690 arg2 = static_cast< bool >(val2);
36691 {
36692 PyThreadState* __tstate = wxPyBeginAllowThreads();
36693 (arg1)->SetThemeEnabled(arg2);
36694 wxPyEndAllowThreads(__tstate);
36695 if (PyErr_Occurred()) SWIG_fail;
36696 }
36697 resultobj = SWIG_Py_Void();
36698 return resultobj;
36699 fail:
36700 return NULL;
36701 }
36702
36703
36704 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36705 PyObject *resultobj = 0;
36706 wxWindow *arg1 = (wxWindow *) 0 ;
36707 bool result;
36708 void *argp1 = 0 ;
36709 int res1 = 0 ;
36710 PyObject *swig_obj[1] ;
36711
36712 if (!args) SWIG_fail;
36713 swig_obj[0] = args;
36714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36715 if (!SWIG_IsOK(res1)) {
36716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36717 }
36718 arg1 = reinterpret_cast< wxWindow * >(argp1);
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36722 wxPyEndAllowThreads(__tstate);
36723 if (PyErr_Occurred()) SWIG_fail;
36724 }
36725 {
36726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36727 }
36728 return resultobj;
36729 fail:
36730 return NULL;
36731 }
36732
36733
36734 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36735 PyObject *resultobj = 0;
36736 wxWindow *arg1 = (wxWindow *) 0 ;
36737 void *argp1 = 0 ;
36738 int res1 = 0 ;
36739 PyObject *swig_obj[1] ;
36740
36741 if (!args) SWIG_fail;
36742 swig_obj[0] = args;
36743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36744 if (!SWIG_IsOK(res1)) {
36745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36746 }
36747 arg1 = reinterpret_cast< wxWindow * >(argp1);
36748 {
36749 PyThreadState* __tstate = wxPyBeginAllowThreads();
36750 (arg1)->SetFocus();
36751 wxPyEndAllowThreads(__tstate);
36752 if (PyErr_Occurred()) SWIG_fail;
36753 }
36754 resultobj = SWIG_Py_Void();
36755 return resultobj;
36756 fail:
36757 return NULL;
36758 }
36759
36760
36761 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36762 PyObject *resultobj = 0;
36763 wxWindow *arg1 = (wxWindow *) 0 ;
36764 void *argp1 = 0 ;
36765 int res1 = 0 ;
36766 PyObject *swig_obj[1] ;
36767
36768 if (!args) SWIG_fail;
36769 swig_obj[0] = args;
36770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36771 if (!SWIG_IsOK(res1)) {
36772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36773 }
36774 arg1 = reinterpret_cast< wxWindow * >(argp1);
36775 {
36776 PyThreadState* __tstate = wxPyBeginAllowThreads();
36777 (arg1)->SetFocusFromKbd();
36778 wxPyEndAllowThreads(__tstate);
36779 if (PyErr_Occurred()) SWIG_fail;
36780 }
36781 resultobj = SWIG_Py_Void();
36782 return resultobj;
36783 fail:
36784 return NULL;
36785 }
36786
36787
36788 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36789 PyObject *resultobj = 0;
36790 wxWindow *result = 0 ;
36791
36792 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36793 {
36794 if (!wxPyCheckForApp()) SWIG_fail;
36795 PyThreadState* __tstate = wxPyBeginAllowThreads();
36796 result = (wxWindow *)wxWindow::FindFocus();
36797 wxPyEndAllowThreads(__tstate);
36798 if (PyErr_Occurred()) SWIG_fail;
36799 }
36800 {
36801 resultobj = wxPyMake_wxObject(result, 0);
36802 }
36803 return resultobj;
36804 fail:
36805 return NULL;
36806 }
36807
36808
36809 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36810 PyObject *resultobj = 0;
36811 wxWindow *arg1 = (wxWindow *) 0 ;
36812 bool result;
36813 void *argp1 = 0 ;
36814 int res1 = 0 ;
36815 PyObject *swig_obj[1] ;
36816
36817 if (!args) SWIG_fail;
36818 swig_obj[0] = args;
36819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36820 if (!SWIG_IsOK(res1)) {
36821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36822 }
36823 arg1 = reinterpret_cast< wxWindow * >(argp1);
36824 {
36825 PyThreadState* __tstate = wxPyBeginAllowThreads();
36826 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36827 wxPyEndAllowThreads(__tstate);
36828 if (PyErr_Occurred()) SWIG_fail;
36829 }
36830 {
36831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36832 }
36833 return resultobj;
36834 fail:
36835 return NULL;
36836 }
36837
36838
36839 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36840 PyObject *resultobj = 0;
36841 wxWindow *arg1 = (wxWindow *) 0 ;
36842 bool result;
36843 void *argp1 = 0 ;
36844 int res1 = 0 ;
36845 PyObject *swig_obj[1] ;
36846
36847 if (!args) SWIG_fail;
36848 swig_obj[0] = args;
36849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36850 if (!SWIG_IsOK(res1)) {
36851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36852 }
36853 arg1 = reinterpret_cast< wxWindow * >(argp1);
36854 {
36855 PyThreadState* __tstate = wxPyBeginAllowThreads();
36856 result = (bool)((wxWindow const *)arg1)->CanAcceptFocus();
36857 wxPyEndAllowThreads(__tstate);
36858 if (PyErr_Occurred()) SWIG_fail;
36859 }
36860 {
36861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36862 }
36863 return resultobj;
36864 fail:
36865 return NULL;
36866 }
36867
36868
36869 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36870 PyObject *resultobj = 0;
36871 wxWindow *arg1 = (wxWindow *) 0 ;
36872 bool result;
36873 void *argp1 = 0 ;
36874 int res1 = 0 ;
36875 PyObject *swig_obj[1] ;
36876
36877 if (!args) SWIG_fail;
36878 swig_obj[0] = args;
36879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36880 if (!SWIG_IsOK(res1)) {
36881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36882 }
36883 arg1 = reinterpret_cast< wxWindow * >(argp1);
36884 {
36885 PyThreadState* __tstate = wxPyBeginAllowThreads();
36886 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36887 wxPyEndAllowThreads(__tstate);
36888 if (PyErr_Occurred()) SWIG_fail;
36889 }
36890 {
36891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36892 }
36893 return resultobj;
36894 fail:
36895 return NULL;
36896 }
36897
36898
36899 SWIGINTERN PyObject *_wrap_Window_CanAcceptFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36900 PyObject *resultobj = 0;
36901 wxWindow *arg1 = (wxWindow *) 0 ;
36902 bool result;
36903 void *argp1 = 0 ;
36904 int res1 = 0 ;
36905 PyObject *swig_obj[1] ;
36906
36907 if (!args) SWIG_fail;
36908 swig_obj[0] = args;
36909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanAcceptFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 result = (bool)((wxWindow const *)arg1)->CanAcceptFocusFromKeyboard();
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 {
36921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36922 }
36923 return resultobj;
36924 fail:
36925 return NULL;
36926 }
36927
36928
36929 SWIGINTERN PyObject *_wrap_Window_SetCanFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36930 PyObject *resultobj = 0;
36931 wxWindow *arg1 = (wxWindow *) 0 ;
36932 bool arg2 ;
36933 void *argp1 = 0 ;
36934 int res1 = 0 ;
36935 bool val2 ;
36936 int ecode2 = 0 ;
36937 PyObject * obj0 = 0 ;
36938 PyObject * obj1 = 0 ;
36939 char * kwnames[] = {
36940 (char *) "self",(char *) "canFocus", NULL
36941 };
36942
36943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCanFocus",kwnames,&obj0,&obj1)) SWIG_fail;
36944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36945 if (!SWIG_IsOK(res1)) {
36946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCanFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36947 }
36948 arg1 = reinterpret_cast< wxWindow * >(argp1);
36949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36950 if (!SWIG_IsOK(ecode2)) {
36951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetCanFocus" "', expected argument " "2"" of type '" "bool""'");
36952 }
36953 arg2 = static_cast< bool >(val2);
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 (arg1)->SetCanFocus(arg2);
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 resultobj = SWIG_Py_Void();
36961 return resultobj;
36962 fail:
36963 return NULL;
36964 }
36965
36966
36967 SWIGINTERN PyObject *_wrap_Window_NavigateIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36968 PyObject *resultobj = 0;
36969 wxWindow *arg1 = (wxWindow *) 0 ;
36970 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36971 bool result;
36972 void *argp1 = 0 ;
36973 int res1 = 0 ;
36974 int val2 ;
36975 int ecode2 = 0 ;
36976 PyObject * obj0 = 0 ;
36977 PyObject * obj1 = 0 ;
36978 char * kwnames[] = {
36979 (char *) "self",(char *) "flags", NULL
36980 };
36981
36982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_NavigateIn",kwnames,&obj0,&obj1)) SWIG_fail;
36983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36984 if (!SWIG_IsOK(res1)) {
36985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_NavigateIn" "', expected argument " "1"" of type '" "wxWindow *""'");
36986 }
36987 arg1 = reinterpret_cast< wxWindow * >(argp1);
36988 if (obj1) {
36989 ecode2 = SWIG_AsVal_int(obj1, &val2);
36990 if (!SWIG_IsOK(ecode2)) {
36991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_NavigateIn" "', expected argument " "2"" of type '" "int""'");
36992 }
36993 arg2 = static_cast< int >(val2);
36994 }
36995 {
36996 PyThreadState* __tstate = wxPyBeginAllowThreads();
36997 result = (bool)(arg1)->NavigateIn(arg2);
36998 wxPyEndAllowThreads(__tstate);
36999 if (PyErr_Occurred()) SWIG_fail;
37000 }
37001 {
37002 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37003 }
37004 return resultobj;
37005 fail:
37006 return NULL;
37007 }
37008
37009
37010 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37011 PyObject *resultobj = 0;
37012 wxWindow *arg1 = (wxWindow *) 0 ;
37013 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
37014 bool result;
37015 void *argp1 = 0 ;
37016 int res1 = 0 ;
37017 int val2 ;
37018 int ecode2 = 0 ;
37019 PyObject * obj0 = 0 ;
37020 PyObject * obj1 = 0 ;
37021 char * kwnames[] = {
37022 (char *) "self",(char *) "flags", NULL
37023 };
37024
37025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
37026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37027 if (!SWIG_IsOK(res1)) {
37028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
37029 }
37030 arg1 = reinterpret_cast< wxWindow * >(argp1);
37031 if (obj1) {
37032 ecode2 = SWIG_AsVal_int(obj1, &val2);
37033 if (!SWIG_IsOK(ecode2)) {
37034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
37035 }
37036 arg2 = static_cast< int >(val2);
37037 }
37038 {
37039 PyThreadState* __tstate = wxPyBeginAllowThreads();
37040 result = (bool)(arg1)->Navigate(arg2);
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 {
37045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37046 }
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37054 PyObject *resultobj = 0;
37055 wxWindow *arg1 = (wxWindow *) 0 ;
37056 wxWindow *arg2 = (wxWindow *) 0 ;
37057 void *argp1 = 0 ;
37058 int res1 = 0 ;
37059 void *argp2 = 0 ;
37060 int res2 = 0 ;
37061 PyObject * obj0 = 0 ;
37062 PyObject * obj1 = 0 ;
37063 char * kwnames[] = {
37064 (char *) "self",(char *) "win", NULL
37065 };
37066
37067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37069 if (!SWIG_IsOK(res1)) {
37070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37071 }
37072 arg1 = reinterpret_cast< wxWindow * >(argp1);
37073 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37074 if (!SWIG_IsOK(res2)) {
37075 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37076 }
37077 arg2 = reinterpret_cast< wxWindow * >(argp2);
37078 {
37079 PyThreadState* __tstate = wxPyBeginAllowThreads();
37080 (arg1)->MoveAfterInTabOrder(arg2);
37081 wxPyEndAllowThreads(__tstate);
37082 if (PyErr_Occurred()) SWIG_fail;
37083 }
37084 resultobj = SWIG_Py_Void();
37085 return resultobj;
37086 fail:
37087 return NULL;
37088 }
37089
37090
37091 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37092 PyObject *resultobj = 0;
37093 wxWindow *arg1 = (wxWindow *) 0 ;
37094 wxWindow *arg2 = (wxWindow *) 0 ;
37095 void *argp1 = 0 ;
37096 int res1 = 0 ;
37097 void *argp2 = 0 ;
37098 int res2 = 0 ;
37099 PyObject * obj0 = 0 ;
37100 PyObject * obj1 = 0 ;
37101 char * kwnames[] = {
37102 (char *) "self",(char *) "win", NULL
37103 };
37104
37105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
37106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37107 if (!SWIG_IsOK(res1)) {
37108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
37109 }
37110 arg1 = reinterpret_cast< wxWindow * >(argp1);
37111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37112 if (!SWIG_IsOK(res2)) {
37113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
37114 }
37115 arg2 = reinterpret_cast< wxWindow * >(argp2);
37116 {
37117 PyThreadState* __tstate = wxPyBeginAllowThreads();
37118 (arg1)->MoveBeforeInTabOrder(arg2);
37119 wxPyEndAllowThreads(__tstate);
37120 if (PyErr_Occurred()) SWIG_fail;
37121 }
37122 resultobj = SWIG_Py_Void();
37123 return resultobj;
37124 fail:
37125 return NULL;
37126 }
37127
37128
37129 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37130 PyObject *resultobj = 0;
37131 wxWindow *arg1 = (wxWindow *) 0 ;
37132 PyObject *result = 0 ;
37133 void *argp1 = 0 ;
37134 int res1 = 0 ;
37135 PyObject *swig_obj[1] ;
37136
37137 if (!args) SWIG_fail;
37138 swig_obj[0] = args;
37139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37140 if (!SWIG_IsOK(res1)) {
37141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
37142 }
37143 arg1 = reinterpret_cast< wxWindow * >(argp1);
37144 {
37145 PyThreadState* __tstate = wxPyBeginAllowThreads();
37146 result = (PyObject *)wxWindow_GetChildren(arg1);
37147 wxPyEndAllowThreads(__tstate);
37148 if (PyErr_Occurred()) SWIG_fail;
37149 }
37150 resultobj = result;
37151 return resultobj;
37152 fail:
37153 return NULL;
37154 }
37155
37156
37157 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37158 PyObject *resultobj = 0;
37159 wxWindow *arg1 = (wxWindow *) 0 ;
37160 wxWindow *result = 0 ;
37161 void *argp1 = 0 ;
37162 int res1 = 0 ;
37163 PyObject *swig_obj[1] ;
37164
37165 if (!args) SWIG_fail;
37166 swig_obj[0] = args;
37167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37168 if (!SWIG_IsOK(res1)) {
37169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37170 }
37171 arg1 = reinterpret_cast< wxWindow * >(argp1);
37172 {
37173 PyThreadState* __tstate = wxPyBeginAllowThreads();
37174 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
37175 wxPyEndAllowThreads(__tstate);
37176 if (PyErr_Occurred()) SWIG_fail;
37177 }
37178 {
37179 resultobj = wxPyMake_wxObject(result, 0);
37180 }
37181 return resultobj;
37182 fail:
37183 return NULL;
37184 }
37185
37186
37187 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37188 PyObject *resultobj = 0;
37189 wxWindow *arg1 = (wxWindow *) 0 ;
37190 wxWindow *result = 0 ;
37191 void *argp1 = 0 ;
37192 int res1 = 0 ;
37193 PyObject *swig_obj[1] ;
37194
37195 if (!args) SWIG_fail;
37196 swig_obj[0] = args;
37197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37198 if (!SWIG_IsOK(res1)) {
37199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
37200 }
37201 arg1 = reinterpret_cast< wxWindow * >(argp1);
37202 {
37203 PyThreadState* __tstate = wxPyBeginAllowThreads();
37204 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
37205 wxPyEndAllowThreads(__tstate);
37206 if (PyErr_Occurred()) SWIG_fail;
37207 }
37208 {
37209 resultobj = wxPyMake_wxObject(result, 0);
37210 }
37211 return resultobj;
37212 fail:
37213 return NULL;
37214 }
37215
37216
37217 SWIGINTERN PyObject *_wrap_Window_GetTopLevelParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37218 PyObject *resultobj = 0;
37219 wxWindow *arg1 = (wxWindow *) 0 ;
37220 wxWindow *result = 0 ;
37221 void *argp1 = 0 ;
37222 int res1 = 0 ;
37223 PyObject *swig_obj[1] ;
37224
37225 if (!args) SWIG_fail;
37226 swig_obj[0] = args;
37227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37228 if (!SWIG_IsOK(res1)) {
37229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTopLevelParent" "', expected argument " "1"" of type '" "wxWindow *""'");
37230 }
37231 arg1 = reinterpret_cast< wxWindow * >(argp1);
37232 {
37233 PyThreadState* __tstate = wxPyBeginAllowThreads();
37234 result = (wxWindow *)wxWindow_GetTopLevelParent(arg1);
37235 wxPyEndAllowThreads(__tstate);
37236 if (PyErr_Occurred()) SWIG_fail;
37237 }
37238 {
37239 resultobj = wxPyMake_wxObject(result, 0);
37240 }
37241 return resultobj;
37242 fail:
37243 return NULL;
37244 }
37245
37246
37247 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37248 PyObject *resultobj = 0;
37249 wxWindow *arg1 = (wxWindow *) 0 ;
37250 bool result;
37251 void *argp1 = 0 ;
37252 int res1 = 0 ;
37253 PyObject *swig_obj[1] ;
37254
37255 if (!args) SWIG_fail;
37256 swig_obj[0] = args;
37257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37258 if (!SWIG_IsOK(res1)) {
37259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
37260 }
37261 arg1 = reinterpret_cast< wxWindow * >(argp1);
37262 {
37263 PyThreadState* __tstate = wxPyBeginAllowThreads();
37264 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
37265 wxPyEndAllowThreads(__tstate);
37266 if (PyErr_Occurred()) SWIG_fail;
37267 }
37268 {
37269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37270 }
37271 return resultobj;
37272 fail:
37273 return NULL;
37274 }
37275
37276
37277 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37278 PyObject *resultobj = 0;
37279 wxWindow *arg1 = (wxWindow *) 0 ;
37280 wxWindow *arg2 = (wxWindow *) 0 ;
37281 bool result;
37282 void *argp1 = 0 ;
37283 int res1 = 0 ;
37284 void *argp2 = 0 ;
37285 int res2 = 0 ;
37286 PyObject * obj0 = 0 ;
37287 PyObject * obj1 = 0 ;
37288 char * kwnames[] = {
37289 (char *) "self",(char *) "newParent", NULL
37290 };
37291
37292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
37293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37294 if (!SWIG_IsOK(res1)) {
37295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
37296 }
37297 arg1 = reinterpret_cast< wxWindow * >(argp1);
37298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37299 if (!SWIG_IsOK(res2)) {
37300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
37301 }
37302 arg2 = reinterpret_cast< wxWindow * >(argp2);
37303 {
37304 PyThreadState* __tstate = wxPyBeginAllowThreads();
37305 result = (bool)(arg1)->Reparent(arg2);
37306 wxPyEndAllowThreads(__tstate);
37307 if (PyErr_Occurred()) SWIG_fail;
37308 }
37309 {
37310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37311 }
37312 return resultobj;
37313 fail:
37314 return NULL;
37315 }
37316
37317
37318 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37319 PyObject *resultobj = 0;
37320 wxWindow *arg1 = (wxWindow *) 0 ;
37321 wxWindow *arg2 = (wxWindow *) 0 ;
37322 void *argp1 = 0 ;
37323 int res1 = 0 ;
37324 void *argp2 = 0 ;
37325 int res2 = 0 ;
37326 PyObject * obj0 = 0 ;
37327 PyObject * obj1 = 0 ;
37328 char * kwnames[] = {
37329 (char *) "self",(char *) "child", NULL
37330 };
37331
37332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
37333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37334 if (!SWIG_IsOK(res1)) {
37335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37336 }
37337 arg1 = reinterpret_cast< wxWindow * >(argp1);
37338 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37339 if (!SWIG_IsOK(res2)) {
37340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37341 }
37342 arg2 = reinterpret_cast< wxWindow * >(argp2);
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 (arg1)->AddChild(arg2);
37346 wxPyEndAllowThreads(__tstate);
37347 if (PyErr_Occurred()) SWIG_fail;
37348 }
37349 resultobj = SWIG_Py_Void();
37350 return resultobj;
37351 fail:
37352 return NULL;
37353 }
37354
37355
37356 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37357 PyObject *resultobj = 0;
37358 wxWindow *arg1 = (wxWindow *) 0 ;
37359 wxWindow *arg2 = (wxWindow *) 0 ;
37360 void *argp1 = 0 ;
37361 int res1 = 0 ;
37362 void *argp2 = 0 ;
37363 int res2 = 0 ;
37364 PyObject * obj0 = 0 ;
37365 PyObject * obj1 = 0 ;
37366 char * kwnames[] = {
37367 (char *) "self",(char *) "child", NULL
37368 };
37369
37370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
37371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37372 if (!SWIG_IsOK(res1)) {
37373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
37374 }
37375 arg1 = reinterpret_cast< wxWindow * >(argp1);
37376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37377 if (!SWIG_IsOK(res2)) {
37378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
37379 }
37380 arg2 = reinterpret_cast< wxWindow * >(argp2);
37381 {
37382 PyThreadState* __tstate = wxPyBeginAllowThreads();
37383 (arg1)->RemoveChild(arg2);
37384 wxPyEndAllowThreads(__tstate);
37385 if (PyErr_Occurred()) SWIG_fail;
37386 }
37387 resultobj = SWIG_Py_Void();
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 bool arg2 ;
37398 void *argp1 = 0 ;
37399 int res1 = 0 ;
37400 bool val2 ;
37401 int ecode2 = 0 ;
37402 PyObject * obj0 = 0 ;
37403 PyObject * obj1 = 0 ;
37404 char * kwnames[] = {
37405 (char *) "self",(char *) "on", NULL
37406 };
37407
37408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
37409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37410 if (!SWIG_IsOK(res1)) {
37411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
37412 }
37413 arg1 = reinterpret_cast< wxWindow * >(argp1);
37414 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37415 if (!SWIG_IsOK(ecode2)) {
37416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
37417 }
37418 arg2 = static_cast< bool >(val2);
37419 {
37420 PyThreadState* __tstate = wxPyBeginAllowThreads();
37421 (arg1)->SetDoubleBuffered(arg2);
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 resultobj = SWIG_Py_Void();
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37433 PyObject *resultobj = 0;
37434 wxWindow *arg1 = (wxWindow *) 0 ;
37435 long arg2 ;
37436 wxWindow *result = 0 ;
37437 void *argp1 = 0 ;
37438 int res1 = 0 ;
37439 long val2 ;
37440 int ecode2 = 0 ;
37441 PyObject * obj0 = 0 ;
37442 PyObject * obj1 = 0 ;
37443 char * kwnames[] = {
37444 (char *) "self",(char *) "winid", NULL
37445 };
37446
37447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37449 if (!SWIG_IsOK(res1)) {
37450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
37451 }
37452 arg1 = reinterpret_cast< wxWindow * >(argp1);
37453 ecode2 = SWIG_AsVal_long(obj1, &val2);
37454 if (!SWIG_IsOK(ecode2)) {
37455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
37456 }
37457 arg2 = static_cast< long >(val2);
37458 {
37459 PyThreadState* __tstate = wxPyBeginAllowThreads();
37460 result = (wxWindow *)(arg1)->FindWindow(arg2);
37461 wxPyEndAllowThreads(__tstate);
37462 if (PyErr_Occurred()) SWIG_fail;
37463 }
37464 {
37465 resultobj = wxPyMake_wxObject(result, 0);
37466 }
37467 return resultobj;
37468 fail:
37469 return NULL;
37470 }
37471
37472
37473 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37474 PyObject *resultobj = 0;
37475 wxWindow *arg1 = (wxWindow *) 0 ;
37476 wxString *arg2 = 0 ;
37477 wxWindow *result = 0 ;
37478 void *argp1 = 0 ;
37479 int res1 = 0 ;
37480 bool temp2 = false ;
37481 PyObject * obj0 = 0 ;
37482 PyObject * obj1 = 0 ;
37483 char * kwnames[] = {
37484 (char *) "self",(char *) "name", NULL
37485 };
37486
37487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37489 if (!SWIG_IsOK(res1)) {
37490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
37491 }
37492 arg1 = reinterpret_cast< wxWindow * >(argp1);
37493 {
37494 arg2 = wxString_in_helper(obj1);
37495 if (arg2 == NULL) SWIG_fail;
37496 temp2 = true;
37497 }
37498 {
37499 PyThreadState* __tstate = wxPyBeginAllowThreads();
37500 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 {
37505 resultobj = wxPyMake_wxObject(result, 0);
37506 }
37507 {
37508 if (temp2)
37509 delete arg2;
37510 }
37511 return resultobj;
37512 fail:
37513 {
37514 if (temp2)
37515 delete arg2;
37516 }
37517 return NULL;
37518 }
37519
37520
37521 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37522 PyObject *resultobj = 0;
37523 wxWindow *arg1 = (wxWindow *) 0 ;
37524 wxEvtHandler *result = 0 ;
37525 void *argp1 = 0 ;
37526 int res1 = 0 ;
37527 PyObject *swig_obj[1] ;
37528
37529 if (!args) SWIG_fail;
37530 swig_obj[0] = args;
37531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37532 if (!SWIG_IsOK(res1)) {
37533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
37534 }
37535 arg1 = reinterpret_cast< wxWindow * >(argp1);
37536 {
37537 PyThreadState* __tstate = wxPyBeginAllowThreads();
37538 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
37539 wxPyEndAllowThreads(__tstate);
37540 if (PyErr_Occurred()) SWIG_fail;
37541 }
37542 {
37543 resultobj = wxPyMake_wxObject(result, 0);
37544 }
37545 return resultobj;
37546 fail:
37547 return NULL;
37548 }
37549
37550
37551 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37552 PyObject *resultobj = 0;
37553 wxWindow *arg1 = (wxWindow *) 0 ;
37554 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37555 void *argp1 = 0 ;
37556 int res1 = 0 ;
37557 void *argp2 = 0 ;
37558 int res2 = 0 ;
37559 PyObject * obj0 = 0 ;
37560 PyObject * obj1 = 0 ;
37561 char * kwnames[] = {
37562 (char *) "self",(char *) "handler", NULL
37563 };
37564
37565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37567 if (!SWIG_IsOK(res1)) {
37568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37569 }
37570 arg1 = reinterpret_cast< wxWindow * >(argp1);
37571 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37572 if (!SWIG_IsOK(res2)) {
37573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37574 }
37575 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37576 {
37577 PyThreadState* __tstate = wxPyBeginAllowThreads();
37578 (arg1)->SetEventHandler(arg2);
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 resultobj = SWIG_Py_Void();
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj = 0;
37591 wxWindow *arg1 = (wxWindow *) 0 ;
37592 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37593 void *argp1 = 0 ;
37594 int res1 = 0 ;
37595 void *argp2 = 0 ;
37596 int res2 = 0 ;
37597 PyObject * obj0 = 0 ;
37598 PyObject * obj1 = 0 ;
37599 char * kwnames[] = {
37600 (char *) "self",(char *) "handler", NULL
37601 };
37602
37603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37605 if (!SWIG_IsOK(res1)) {
37606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37607 }
37608 arg1 = reinterpret_cast< wxWindow * >(argp1);
37609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37610 if (!SWIG_IsOK(res2)) {
37611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37612 }
37613 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37614 {
37615 PyThreadState* __tstate = wxPyBeginAllowThreads();
37616 (arg1)->PushEventHandler(arg2);
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 resultobj = SWIG_Py_Void();
37621 return resultobj;
37622 fail:
37623 return NULL;
37624 }
37625
37626
37627 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37628 PyObject *resultobj = 0;
37629 wxWindow *arg1 = (wxWindow *) 0 ;
37630 bool arg2 = (bool) false ;
37631 wxEvtHandler *result = 0 ;
37632 void *argp1 = 0 ;
37633 int res1 = 0 ;
37634 bool val2 ;
37635 int ecode2 = 0 ;
37636 PyObject * obj0 = 0 ;
37637 PyObject * obj1 = 0 ;
37638 char * kwnames[] = {
37639 (char *) "self",(char *) "deleteHandler", NULL
37640 };
37641
37642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37644 if (!SWIG_IsOK(res1)) {
37645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37646 }
37647 arg1 = reinterpret_cast< wxWindow * >(argp1);
37648 if (obj1) {
37649 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37650 if (!SWIG_IsOK(ecode2)) {
37651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
37652 }
37653 arg2 = static_cast< bool >(val2);
37654 }
37655 {
37656 PyThreadState* __tstate = wxPyBeginAllowThreads();
37657 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
37658 wxPyEndAllowThreads(__tstate);
37659 if (PyErr_Occurred()) SWIG_fail;
37660 }
37661 {
37662 resultobj = wxPyMake_wxObject(result, 0);
37663 }
37664 return resultobj;
37665 fail:
37666 return NULL;
37667 }
37668
37669
37670 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37671 PyObject *resultobj = 0;
37672 wxWindow *arg1 = (wxWindow *) 0 ;
37673 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
37674 bool result;
37675 void *argp1 = 0 ;
37676 int res1 = 0 ;
37677 void *argp2 = 0 ;
37678 int res2 = 0 ;
37679 PyObject * obj0 = 0 ;
37680 PyObject * obj1 = 0 ;
37681 char * kwnames[] = {
37682 (char *) "self",(char *) "handler", NULL
37683 };
37684
37685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
37686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37687 if (!SWIG_IsOK(res1)) {
37688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
37689 }
37690 arg1 = reinterpret_cast< wxWindow * >(argp1);
37691 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
37692 if (!SWIG_IsOK(res2)) {
37693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
37694 }
37695 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
37696 {
37697 PyThreadState* __tstate = wxPyBeginAllowThreads();
37698 result = (bool)(arg1)->RemoveEventHandler(arg2);
37699 wxPyEndAllowThreads(__tstate);
37700 if (PyErr_Occurred()) SWIG_fail;
37701 }
37702 {
37703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37704 }
37705 return resultobj;
37706 fail:
37707 return NULL;
37708 }
37709
37710
37711 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37712 PyObject *resultobj = 0;
37713 wxWindow *arg1 = (wxWindow *) 0 ;
37714 wxValidator *arg2 = 0 ;
37715 void *argp1 = 0 ;
37716 int res1 = 0 ;
37717 void *argp2 = 0 ;
37718 int res2 = 0 ;
37719 PyObject * obj0 = 0 ;
37720 PyObject * obj1 = 0 ;
37721 char * kwnames[] = {
37722 (char *) "self",(char *) "validator", NULL
37723 };
37724
37725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37727 if (!SWIG_IsOK(res1)) {
37728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37729 }
37730 arg1 = reinterpret_cast< wxWindow * >(argp1);
37731 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37732 if (!SWIG_IsOK(res2)) {
37733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37734 }
37735 if (!argp2) {
37736 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37737 }
37738 arg2 = reinterpret_cast< wxValidator * >(argp2);
37739 {
37740 PyThreadState* __tstate = wxPyBeginAllowThreads();
37741 (arg1)->SetValidator((wxValidator const &)*arg2);
37742 wxPyEndAllowThreads(__tstate);
37743 if (PyErr_Occurred()) SWIG_fail;
37744 }
37745 resultobj = SWIG_Py_Void();
37746 return resultobj;
37747 fail:
37748 return NULL;
37749 }
37750
37751
37752 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37753 PyObject *resultobj = 0;
37754 wxWindow *arg1 = (wxWindow *) 0 ;
37755 wxValidator *result = 0 ;
37756 void *argp1 = 0 ;
37757 int res1 = 0 ;
37758 PyObject *swig_obj[1] ;
37759
37760 if (!args) SWIG_fail;
37761 swig_obj[0] = args;
37762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37763 if (!SWIG_IsOK(res1)) {
37764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37765 }
37766 arg1 = reinterpret_cast< wxWindow * >(argp1);
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 result = (wxValidator *)(arg1)->GetValidator();
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 {
37774 resultobj = wxPyMake_wxObject(result, (bool)0);
37775 }
37776 return resultobj;
37777 fail:
37778 return NULL;
37779 }
37780
37781
37782 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37783 PyObject *resultobj = 0;
37784 wxWindow *arg1 = (wxWindow *) 0 ;
37785 bool result;
37786 void *argp1 = 0 ;
37787 int res1 = 0 ;
37788 PyObject *swig_obj[1] ;
37789
37790 if (!args) SWIG_fail;
37791 swig_obj[0] = args;
37792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37793 if (!SWIG_IsOK(res1)) {
37794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37795 }
37796 arg1 = reinterpret_cast< wxWindow * >(argp1);
37797 {
37798 PyThreadState* __tstate = wxPyBeginAllowThreads();
37799 result = (bool)(arg1)->Validate();
37800 wxPyEndAllowThreads(__tstate);
37801 if (PyErr_Occurred()) SWIG_fail;
37802 }
37803 {
37804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37805 }
37806 return resultobj;
37807 fail:
37808 return NULL;
37809 }
37810
37811
37812 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37813 PyObject *resultobj = 0;
37814 wxWindow *arg1 = (wxWindow *) 0 ;
37815 bool result;
37816 void *argp1 = 0 ;
37817 int res1 = 0 ;
37818 PyObject *swig_obj[1] ;
37819
37820 if (!args) SWIG_fail;
37821 swig_obj[0] = args;
37822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37823 if (!SWIG_IsOK(res1)) {
37824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37825 }
37826 arg1 = reinterpret_cast< wxWindow * >(argp1);
37827 {
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 result = (bool)(arg1)->TransferDataToWindow();
37830 wxPyEndAllowThreads(__tstate);
37831 if (PyErr_Occurred()) SWIG_fail;
37832 }
37833 {
37834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37835 }
37836 return resultobj;
37837 fail:
37838 return NULL;
37839 }
37840
37841
37842 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37843 PyObject *resultobj = 0;
37844 wxWindow *arg1 = (wxWindow *) 0 ;
37845 bool result;
37846 void *argp1 = 0 ;
37847 int res1 = 0 ;
37848 PyObject *swig_obj[1] ;
37849
37850 if (!args) SWIG_fail;
37851 swig_obj[0] = args;
37852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37853 if (!SWIG_IsOK(res1)) {
37854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37855 }
37856 arg1 = reinterpret_cast< wxWindow * >(argp1);
37857 {
37858 PyThreadState* __tstate = wxPyBeginAllowThreads();
37859 result = (bool)(arg1)->TransferDataFromWindow();
37860 wxPyEndAllowThreads(__tstate);
37861 if (PyErr_Occurred()) SWIG_fail;
37862 }
37863 {
37864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37865 }
37866 return resultobj;
37867 fail:
37868 return NULL;
37869 }
37870
37871
37872 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37873 PyObject *resultobj = 0;
37874 wxWindow *arg1 = (wxWindow *) 0 ;
37875 void *argp1 = 0 ;
37876 int res1 = 0 ;
37877 PyObject *swig_obj[1] ;
37878
37879 if (!args) SWIG_fail;
37880 swig_obj[0] = args;
37881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37882 if (!SWIG_IsOK(res1)) {
37883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37884 }
37885 arg1 = reinterpret_cast< wxWindow * >(argp1);
37886 {
37887 PyThreadState* __tstate = wxPyBeginAllowThreads();
37888 (arg1)->InitDialog();
37889 wxPyEndAllowThreads(__tstate);
37890 if (PyErr_Occurred()) SWIG_fail;
37891 }
37892 resultobj = SWIG_Py_Void();
37893 return resultobj;
37894 fail:
37895 return NULL;
37896 }
37897
37898
37899 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37900 PyObject *resultobj = 0;
37901 wxWindow *arg1 = (wxWindow *) 0 ;
37902 wxAcceleratorTable *arg2 = 0 ;
37903 void *argp1 = 0 ;
37904 int res1 = 0 ;
37905 void *argp2 = 0 ;
37906 int res2 = 0 ;
37907 PyObject * obj0 = 0 ;
37908 PyObject * obj1 = 0 ;
37909 char * kwnames[] = {
37910 (char *) "self",(char *) "accel", NULL
37911 };
37912
37913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37915 if (!SWIG_IsOK(res1)) {
37916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37917 }
37918 arg1 = reinterpret_cast< wxWindow * >(argp1);
37919 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37920 if (!SWIG_IsOK(res2)) {
37921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37922 }
37923 if (!argp2) {
37924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37925 }
37926 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37927 {
37928 PyThreadState* __tstate = wxPyBeginAllowThreads();
37929 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37930 wxPyEndAllowThreads(__tstate);
37931 if (PyErr_Occurred()) SWIG_fail;
37932 }
37933 resultobj = SWIG_Py_Void();
37934 return resultobj;
37935 fail:
37936 return NULL;
37937 }
37938
37939
37940 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37941 PyObject *resultobj = 0;
37942 wxWindow *arg1 = (wxWindow *) 0 ;
37943 wxAcceleratorTable *result = 0 ;
37944 void *argp1 = 0 ;
37945 int res1 = 0 ;
37946 PyObject *swig_obj[1] ;
37947
37948 if (!args) SWIG_fail;
37949 swig_obj[0] = args;
37950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37951 if (!SWIG_IsOK(res1)) {
37952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37953 }
37954 arg1 = reinterpret_cast< wxWindow * >(argp1);
37955 {
37956 PyThreadState* __tstate = wxPyBeginAllowThreads();
37957 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37958 wxPyEndAllowThreads(__tstate);
37959 if (PyErr_Occurred()) SWIG_fail;
37960 }
37961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37962 return resultobj;
37963 fail:
37964 return NULL;
37965 }
37966
37967
37968 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37969 PyObject *resultobj = 0;
37970 wxWindow *arg1 = (wxWindow *) 0 ;
37971 int arg2 ;
37972 int arg3 ;
37973 int arg4 ;
37974 bool result;
37975 void *argp1 = 0 ;
37976 int res1 = 0 ;
37977 int val2 ;
37978 int ecode2 = 0 ;
37979 int val3 ;
37980 int ecode3 = 0 ;
37981 int val4 ;
37982 int ecode4 = 0 ;
37983 PyObject * obj0 = 0 ;
37984 PyObject * obj1 = 0 ;
37985 PyObject * obj2 = 0 ;
37986 PyObject * obj3 = 0 ;
37987 char * kwnames[] = {
37988 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37989 };
37990
37991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37993 if (!SWIG_IsOK(res1)) {
37994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37995 }
37996 arg1 = reinterpret_cast< wxWindow * >(argp1);
37997 ecode2 = SWIG_AsVal_int(obj1, &val2);
37998 if (!SWIG_IsOK(ecode2)) {
37999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
38000 }
38001 arg2 = static_cast< int >(val2);
38002 ecode3 = SWIG_AsVal_int(obj2, &val3);
38003 if (!SWIG_IsOK(ecode3)) {
38004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
38005 }
38006 arg3 = static_cast< int >(val3);
38007 ecode4 = SWIG_AsVal_int(obj3, &val4);
38008 if (!SWIG_IsOK(ecode4)) {
38009 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
38010 }
38011 arg4 = static_cast< int >(val4);
38012 {
38013 PyThreadState* __tstate = wxPyBeginAllowThreads();
38014 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
38015 wxPyEndAllowThreads(__tstate);
38016 if (PyErr_Occurred()) SWIG_fail;
38017 }
38018 {
38019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38020 }
38021 return resultobj;
38022 fail:
38023 return NULL;
38024 }
38025
38026
38027 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38028 PyObject *resultobj = 0;
38029 wxWindow *arg1 = (wxWindow *) 0 ;
38030 int arg2 ;
38031 bool result;
38032 void *argp1 = 0 ;
38033 int res1 = 0 ;
38034 int val2 ;
38035 int ecode2 = 0 ;
38036 PyObject * obj0 = 0 ;
38037 PyObject * obj1 = 0 ;
38038 char * kwnames[] = {
38039 (char *) "self",(char *) "hotkeyId", NULL
38040 };
38041
38042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
38043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38044 if (!SWIG_IsOK(res1)) {
38045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
38046 }
38047 arg1 = reinterpret_cast< wxWindow * >(argp1);
38048 ecode2 = SWIG_AsVal_int(obj1, &val2);
38049 if (!SWIG_IsOK(ecode2)) {
38050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
38051 }
38052 arg2 = static_cast< int >(val2);
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
38056 wxPyEndAllowThreads(__tstate);
38057 if (PyErr_Occurred()) SWIG_fail;
38058 }
38059 {
38060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38061 }
38062 return resultobj;
38063 fail:
38064 return NULL;
38065 }
38066
38067
38068 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38069 PyObject *resultobj = 0;
38070 wxWindow *arg1 = (wxWindow *) 0 ;
38071 wxPoint *arg2 = 0 ;
38072 wxPoint result;
38073 void *argp1 = 0 ;
38074 int res1 = 0 ;
38075 wxPoint temp2 ;
38076 PyObject * obj0 = 0 ;
38077 PyObject * obj1 = 0 ;
38078 char * kwnames[] = {
38079 (char *) "self",(char *) "pt", NULL
38080 };
38081
38082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38084 if (!SWIG_IsOK(res1)) {
38085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38086 }
38087 arg1 = reinterpret_cast< wxWindow * >(argp1);
38088 {
38089 arg2 = &temp2;
38090 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38091 }
38092 {
38093 PyThreadState* __tstate = wxPyBeginAllowThreads();
38094 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38095 wxPyEndAllowThreads(__tstate);
38096 if (PyErr_Occurred()) SWIG_fail;
38097 }
38098 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38099 return resultobj;
38100 fail:
38101 return NULL;
38102 }
38103
38104
38105 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38106 PyObject *resultobj = 0;
38107 wxWindow *arg1 = (wxWindow *) 0 ;
38108 wxSize *arg2 = 0 ;
38109 wxSize result;
38110 void *argp1 = 0 ;
38111 int res1 = 0 ;
38112 wxSize temp2 ;
38113 PyObject * obj0 = 0 ;
38114 PyObject * obj1 = 0 ;
38115 char * kwnames[] = {
38116 (char *) "self",(char *) "sz", NULL
38117 };
38118
38119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
38120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38121 if (!SWIG_IsOK(res1)) {
38122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
38123 }
38124 arg1 = reinterpret_cast< wxWindow * >(argp1);
38125 {
38126 arg2 = &temp2;
38127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38128 }
38129 {
38130 PyThreadState* __tstate = wxPyBeginAllowThreads();
38131 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38132 wxPyEndAllowThreads(__tstate);
38133 if (PyErr_Occurred()) SWIG_fail;
38134 }
38135 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38136 return resultobj;
38137 fail:
38138 return NULL;
38139 }
38140
38141
38142 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38143 PyObject *resultobj = 0;
38144 wxWindow *arg1 = (wxWindow *) 0 ;
38145 wxPoint *arg2 = 0 ;
38146 wxPoint result;
38147 void *argp1 = 0 ;
38148 int res1 = 0 ;
38149 wxPoint temp2 ;
38150 PyObject * obj0 = 0 ;
38151 PyObject * obj1 = 0 ;
38152 char * kwnames[] = {
38153 (char *) "self",(char *) "pt", NULL
38154 };
38155
38156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
38157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38158 if (!SWIG_IsOK(res1)) {
38159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
38160 }
38161 arg1 = reinterpret_cast< wxWindow * >(argp1);
38162 {
38163 arg2 = &temp2;
38164 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38165 }
38166 {
38167 PyThreadState* __tstate = wxPyBeginAllowThreads();
38168 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
38169 wxPyEndAllowThreads(__tstate);
38170 if (PyErr_Occurred()) SWIG_fail;
38171 }
38172 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38173 return resultobj;
38174 fail:
38175 return NULL;
38176 }
38177
38178
38179 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38180 PyObject *resultobj = 0;
38181 wxWindow *arg1 = (wxWindow *) 0 ;
38182 wxSize *arg2 = 0 ;
38183 wxSize result;
38184 void *argp1 = 0 ;
38185 int res1 = 0 ;
38186 wxSize temp2 ;
38187 PyObject * obj0 = 0 ;
38188 PyObject * obj1 = 0 ;
38189 char * kwnames[] = {
38190 (char *) "self",(char *) "sz", NULL
38191 };
38192
38193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
38194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38195 if (!SWIG_IsOK(res1)) {
38196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
38197 }
38198 arg1 = reinterpret_cast< wxWindow * >(argp1);
38199 {
38200 arg2 = &temp2;
38201 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38202 }
38203 {
38204 PyThreadState* __tstate = wxPyBeginAllowThreads();
38205 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
38206 wxPyEndAllowThreads(__tstate);
38207 if (PyErr_Occurred()) SWIG_fail;
38208 }
38209 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38210 return resultobj;
38211 fail:
38212 return NULL;
38213 }
38214
38215
38216 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38217 PyObject *resultobj = 0;
38218 wxWindow *arg1 = (wxWindow *) 0 ;
38219 wxPoint *arg2 = 0 ;
38220 wxPoint result;
38221 void *argp1 = 0 ;
38222 int res1 = 0 ;
38223 wxPoint temp2 ;
38224 PyObject * obj0 = 0 ;
38225 PyObject * obj1 = 0 ;
38226 char * kwnames[] = {
38227 (char *) "self",(char *) "pt", NULL
38228 };
38229
38230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38232 if (!SWIG_IsOK(res1)) {
38233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38234 }
38235 arg1 = reinterpret_cast< wxWindow * >(argp1);
38236 {
38237 arg2 = &temp2;
38238 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38239 }
38240 {
38241 PyThreadState* __tstate = wxPyBeginAllowThreads();
38242 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
38243 wxPyEndAllowThreads(__tstate);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 }
38246 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
38247 return resultobj;
38248 fail:
38249 return NULL;
38250 }
38251
38252
38253 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38254 PyObject *resultobj = 0;
38255 wxWindow *arg1 = (wxWindow *) 0 ;
38256 wxSize *arg2 = 0 ;
38257 wxSize result;
38258 void *argp1 = 0 ;
38259 int res1 = 0 ;
38260 wxSize temp2 ;
38261 PyObject * obj0 = 0 ;
38262 PyObject * obj1 = 0 ;
38263 char * kwnames[] = {
38264 (char *) "self",(char *) "sz", NULL
38265 };
38266
38267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
38268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38269 if (!SWIG_IsOK(res1)) {
38270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
38271 }
38272 arg1 = reinterpret_cast< wxWindow * >(argp1);
38273 {
38274 arg2 = &temp2;
38275 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38276 }
38277 {
38278 PyThreadState* __tstate = wxPyBeginAllowThreads();
38279 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
38280 wxPyEndAllowThreads(__tstate);
38281 if (PyErr_Occurred()) SWIG_fail;
38282 }
38283 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
38284 return resultobj;
38285 fail:
38286 return NULL;
38287 }
38288
38289
38290 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38291 PyObject *resultobj = 0;
38292 wxWindow *arg1 = (wxWindow *) 0 ;
38293 int arg2 ;
38294 int arg3 ;
38295 void *argp1 = 0 ;
38296 int res1 = 0 ;
38297 int val2 ;
38298 int ecode2 = 0 ;
38299 int val3 ;
38300 int ecode3 = 0 ;
38301 PyObject * obj0 = 0 ;
38302 PyObject * obj1 = 0 ;
38303 PyObject * obj2 = 0 ;
38304 char * kwnames[] = {
38305 (char *) "self",(char *) "x",(char *) "y", NULL
38306 };
38307
38308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38310 if (!SWIG_IsOK(res1)) {
38311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
38312 }
38313 arg1 = reinterpret_cast< wxWindow * >(argp1);
38314 ecode2 = SWIG_AsVal_int(obj1, &val2);
38315 if (!SWIG_IsOK(ecode2)) {
38316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
38317 }
38318 arg2 = static_cast< int >(val2);
38319 ecode3 = SWIG_AsVal_int(obj2, &val3);
38320 if (!SWIG_IsOK(ecode3)) {
38321 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
38322 }
38323 arg3 = static_cast< int >(val3);
38324 {
38325 PyThreadState* __tstate = wxPyBeginAllowThreads();
38326 (arg1)->WarpPointer(arg2,arg3);
38327 wxPyEndAllowThreads(__tstate);
38328 if (PyErr_Occurred()) SWIG_fail;
38329 }
38330 resultobj = SWIG_Py_Void();
38331 return resultobj;
38332 fail:
38333 return NULL;
38334 }
38335
38336
38337 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38338 PyObject *resultobj = 0;
38339 wxWindow *arg1 = (wxWindow *) 0 ;
38340 void *argp1 = 0 ;
38341 int res1 = 0 ;
38342 PyObject *swig_obj[1] ;
38343
38344 if (!args) SWIG_fail;
38345 swig_obj[0] = args;
38346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38347 if (!SWIG_IsOK(res1)) {
38348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38349 }
38350 arg1 = reinterpret_cast< wxWindow * >(argp1);
38351 {
38352 PyThreadState* __tstate = wxPyBeginAllowThreads();
38353 (arg1)->CaptureMouse();
38354 wxPyEndAllowThreads(__tstate);
38355 if (PyErr_Occurred()) SWIG_fail;
38356 }
38357 resultobj = SWIG_Py_Void();
38358 return resultobj;
38359 fail:
38360 return NULL;
38361 }
38362
38363
38364 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38365 PyObject *resultobj = 0;
38366 wxWindow *arg1 = (wxWindow *) 0 ;
38367 void *argp1 = 0 ;
38368 int res1 = 0 ;
38369 PyObject *swig_obj[1] ;
38370
38371 if (!args) SWIG_fail;
38372 swig_obj[0] = args;
38373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38374 if (!SWIG_IsOK(res1)) {
38375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
38376 }
38377 arg1 = reinterpret_cast< wxWindow * >(argp1);
38378 {
38379 PyThreadState* __tstate = wxPyBeginAllowThreads();
38380 (arg1)->ReleaseMouse();
38381 wxPyEndAllowThreads(__tstate);
38382 if (PyErr_Occurred()) SWIG_fail;
38383 }
38384 resultobj = SWIG_Py_Void();
38385 return resultobj;
38386 fail:
38387 return NULL;
38388 }
38389
38390
38391 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38392 PyObject *resultobj = 0;
38393 wxWindow *result = 0 ;
38394
38395 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
38396 {
38397 if (!wxPyCheckForApp()) SWIG_fail;
38398 PyThreadState* __tstate = wxPyBeginAllowThreads();
38399 result = (wxWindow *)wxWindow::GetCapture();
38400 wxPyEndAllowThreads(__tstate);
38401 if (PyErr_Occurred()) SWIG_fail;
38402 }
38403 {
38404 resultobj = wxPyMake_wxObject(result, 0);
38405 }
38406 return resultobj;
38407 fail:
38408 return NULL;
38409 }
38410
38411
38412 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38413 PyObject *resultobj = 0;
38414 wxWindow *arg1 = (wxWindow *) 0 ;
38415 bool result;
38416 void *argp1 = 0 ;
38417 int res1 = 0 ;
38418 PyObject *swig_obj[1] ;
38419
38420 if (!args) SWIG_fail;
38421 swig_obj[0] = args;
38422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38423 if (!SWIG_IsOK(res1)) {
38424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
38425 }
38426 arg1 = reinterpret_cast< wxWindow * >(argp1);
38427 {
38428 PyThreadState* __tstate = wxPyBeginAllowThreads();
38429 result = (bool)((wxWindow const *)arg1)->HasCapture();
38430 wxPyEndAllowThreads(__tstate);
38431 if (PyErr_Occurred()) SWIG_fail;
38432 }
38433 {
38434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38435 }
38436 return resultobj;
38437 fail:
38438 return NULL;
38439 }
38440
38441
38442 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38443 PyObject *resultobj = 0;
38444 wxWindow *arg1 = (wxWindow *) 0 ;
38445 bool arg2 = (bool) true ;
38446 wxRect *arg3 = (wxRect *) NULL ;
38447 void *argp1 = 0 ;
38448 int res1 = 0 ;
38449 bool val2 ;
38450 int ecode2 = 0 ;
38451 void *argp3 = 0 ;
38452 int res3 = 0 ;
38453 PyObject * obj0 = 0 ;
38454 PyObject * obj1 = 0 ;
38455 PyObject * obj2 = 0 ;
38456 char * kwnames[] = {
38457 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
38458 };
38459
38460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38462 if (!SWIG_IsOK(res1)) {
38463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
38464 }
38465 arg1 = reinterpret_cast< wxWindow * >(argp1);
38466 if (obj1) {
38467 ecode2 = SWIG_AsVal_bool(obj1, &val2);
38468 if (!SWIG_IsOK(ecode2)) {
38469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
38470 }
38471 arg2 = static_cast< bool >(val2);
38472 }
38473 if (obj2) {
38474 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
38475 if (!SWIG_IsOK(res3)) {
38476 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
38477 }
38478 arg3 = reinterpret_cast< wxRect * >(argp3);
38479 }
38480 {
38481 PyThreadState* __tstate = wxPyBeginAllowThreads();
38482 (arg1)->Refresh(arg2,(wxRect const *)arg3);
38483 wxPyEndAllowThreads(__tstate);
38484 if (PyErr_Occurred()) SWIG_fail;
38485 }
38486 resultobj = SWIG_Py_Void();
38487 return resultobj;
38488 fail:
38489 return NULL;
38490 }
38491
38492
38493 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38494 PyObject *resultobj = 0;
38495 wxWindow *arg1 = (wxWindow *) 0 ;
38496 wxRect *arg2 = 0 ;
38497 bool arg3 = (bool) true ;
38498 void *argp1 = 0 ;
38499 int res1 = 0 ;
38500 wxRect temp2 ;
38501 bool val3 ;
38502 int ecode3 = 0 ;
38503 PyObject * obj0 = 0 ;
38504 PyObject * obj1 = 0 ;
38505 PyObject * obj2 = 0 ;
38506 char * kwnames[] = {
38507 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
38508 };
38509
38510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38512 if (!SWIG_IsOK(res1)) {
38513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
38514 }
38515 arg1 = reinterpret_cast< wxWindow * >(argp1);
38516 {
38517 arg2 = &temp2;
38518 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38519 }
38520 if (obj2) {
38521 ecode3 = SWIG_AsVal_bool(obj2, &val3);
38522 if (!SWIG_IsOK(ecode3)) {
38523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
38524 }
38525 arg3 = static_cast< bool >(val3);
38526 }
38527 {
38528 PyThreadState* __tstate = wxPyBeginAllowThreads();
38529 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
38530 wxPyEndAllowThreads(__tstate);
38531 if (PyErr_Occurred()) SWIG_fail;
38532 }
38533 resultobj = SWIG_Py_Void();
38534 return resultobj;
38535 fail:
38536 return NULL;
38537 }
38538
38539
38540 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38541 PyObject *resultobj = 0;
38542 wxWindow *arg1 = (wxWindow *) 0 ;
38543 void *argp1 = 0 ;
38544 int res1 = 0 ;
38545 PyObject *swig_obj[1] ;
38546
38547 if (!args) SWIG_fail;
38548 swig_obj[0] = args;
38549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38550 if (!SWIG_IsOK(res1)) {
38551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
38552 }
38553 arg1 = reinterpret_cast< wxWindow * >(argp1);
38554 {
38555 PyThreadState* __tstate = wxPyBeginAllowThreads();
38556 (arg1)->Update();
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 resultobj = SWIG_Py_Void();
38561 return resultobj;
38562 fail:
38563 return NULL;
38564 }
38565
38566
38567 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38568 PyObject *resultobj = 0;
38569 wxWindow *arg1 = (wxWindow *) 0 ;
38570 void *argp1 = 0 ;
38571 int res1 = 0 ;
38572 PyObject *swig_obj[1] ;
38573
38574 if (!args) SWIG_fail;
38575 swig_obj[0] = args;
38576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38577 if (!SWIG_IsOK(res1)) {
38578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38579 }
38580 arg1 = reinterpret_cast< wxWindow * >(argp1);
38581 {
38582 PyThreadState* __tstate = wxPyBeginAllowThreads();
38583 (arg1)->ClearBackground();
38584 wxPyEndAllowThreads(__tstate);
38585 if (PyErr_Occurred()) SWIG_fail;
38586 }
38587 resultobj = SWIG_Py_Void();
38588 return resultobj;
38589 fail:
38590 return NULL;
38591 }
38592
38593
38594 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38595 PyObject *resultobj = 0;
38596 wxWindow *arg1 = (wxWindow *) 0 ;
38597 void *argp1 = 0 ;
38598 int res1 = 0 ;
38599 PyObject *swig_obj[1] ;
38600
38601 if (!args) SWIG_fail;
38602 swig_obj[0] = args;
38603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38604 if (!SWIG_IsOK(res1)) {
38605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
38606 }
38607 arg1 = reinterpret_cast< wxWindow * >(argp1);
38608 {
38609 PyThreadState* __tstate = wxPyBeginAllowThreads();
38610 (arg1)->Freeze();
38611 wxPyEndAllowThreads(__tstate);
38612 if (PyErr_Occurred()) SWIG_fail;
38613 }
38614 resultobj = SWIG_Py_Void();
38615 return resultobj;
38616 fail:
38617 return NULL;
38618 }
38619
38620
38621 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38622 PyObject *resultobj = 0;
38623 wxWindow *arg1 = (wxWindow *) 0 ;
38624 bool result;
38625 void *argp1 = 0 ;
38626 int res1 = 0 ;
38627 PyObject *swig_obj[1] ;
38628
38629 if (!args) SWIG_fail;
38630 swig_obj[0] = args;
38631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38632 if (!SWIG_IsOK(res1)) {
38633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
38634 }
38635 arg1 = reinterpret_cast< wxWindow * >(argp1);
38636 {
38637 PyThreadState* __tstate = wxPyBeginAllowThreads();
38638 result = (bool)((wxWindow const *)arg1)->IsFrozen();
38639 wxPyEndAllowThreads(__tstate);
38640 if (PyErr_Occurred()) SWIG_fail;
38641 }
38642 {
38643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38644 }
38645 return resultobj;
38646 fail:
38647 return NULL;
38648 }
38649
38650
38651 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38652 PyObject *resultobj = 0;
38653 wxWindow *arg1 = (wxWindow *) 0 ;
38654 void *argp1 = 0 ;
38655 int res1 = 0 ;
38656 PyObject *swig_obj[1] ;
38657
38658 if (!args) SWIG_fail;
38659 swig_obj[0] = args;
38660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38661 if (!SWIG_IsOK(res1)) {
38662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
38663 }
38664 arg1 = reinterpret_cast< wxWindow * >(argp1);
38665 {
38666 PyThreadState* __tstate = wxPyBeginAllowThreads();
38667 (arg1)->Thaw();
38668 wxPyEndAllowThreads(__tstate);
38669 if (PyErr_Occurred()) SWIG_fail;
38670 }
38671 resultobj = SWIG_Py_Void();
38672 return resultobj;
38673 fail:
38674 return NULL;
38675 }
38676
38677
38678 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38679 PyObject *resultobj = 0;
38680 wxWindow *arg1 = (wxWindow *) 0 ;
38681 wxDC *arg2 = 0 ;
38682 void *argp1 = 0 ;
38683 int res1 = 0 ;
38684 void *argp2 = 0 ;
38685 int res2 = 0 ;
38686 PyObject * obj0 = 0 ;
38687 PyObject * obj1 = 0 ;
38688 char * kwnames[] = {
38689 (char *) "self",(char *) "dc", NULL
38690 };
38691
38692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
38693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38694 if (!SWIG_IsOK(res1)) {
38695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
38696 }
38697 arg1 = reinterpret_cast< wxWindow * >(argp1);
38698 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
38699 if (!SWIG_IsOK(res2)) {
38700 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38701 }
38702 if (!argp2) {
38703 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38704 }
38705 arg2 = reinterpret_cast< wxDC * >(argp2);
38706 {
38707 PyThreadState* __tstate = wxPyBeginAllowThreads();
38708 (arg1)->PrepareDC(*arg2);
38709 wxPyEndAllowThreads(__tstate);
38710 if (PyErr_Occurred()) SWIG_fail;
38711 }
38712 resultobj = SWIG_Py_Void();
38713 return resultobj;
38714 fail:
38715 return NULL;
38716 }
38717
38718
38719 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38720 PyObject *resultobj = 0;
38721 wxWindow *arg1 = (wxWindow *) 0 ;
38722 bool result;
38723 void *argp1 = 0 ;
38724 int res1 = 0 ;
38725 PyObject *swig_obj[1] ;
38726
38727 if (!args) SWIG_fail;
38728 swig_obj[0] = args;
38729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38730 if (!SWIG_IsOK(res1)) {
38731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38732 }
38733 arg1 = reinterpret_cast< wxWindow * >(argp1);
38734 {
38735 PyThreadState* __tstate = wxPyBeginAllowThreads();
38736 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38737 wxPyEndAllowThreads(__tstate);
38738 if (PyErr_Occurred()) SWIG_fail;
38739 }
38740 {
38741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38742 }
38743 return resultobj;
38744 fail:
38745 return NULL;
38746 }
38747
38748
38749 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38750 PyObject *resultobj = 0;
38751 wxWindow *arg1 = (wxWindow *) 0 ;
38752 wxRegion *result = 0 ;
38753 void *argp1 = 0 ;
38754 int res1 = 0 ;
38755 PyObject *swig_obj[1] ;
38756
38757 if (!args) SWIG_fail;
38758 swig_obj[0] = args;
38759 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38760 if (!SWIG_IsOK(res1)) {
38761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38762 }
38763 arg1 = reinterpret_cast< wxWindow * >(argp1);
38764 {
38765 PyThreadState* __tstate = wxPyBeginAllowThreads();
38766 {
38767 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38768 result = (wxRegion *) &_result_ref;
38769 }
38770 wxPyEndAllowThreads(__tstate);
38771 if (PyErr_Occurred()) SWIG_fail;
38772 }
38773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38774 return resultobj;
38775 fail:
38776 return NULL;
38777 }
38778
38779
38780 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38781 PyObject *resultobj = 0;
38782 wxWindow *arg1 = (wxWindow *) 0 ;
38783 wxRect result;
38784 void *argp1 = 0 ;
38785 int res1 = 0 ;
38786 PyObject *swig_obj[1] ;
38787
38788 if (!args) SWIG_fail;
38789 swig_obj[0] = args;
38790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38791 if (!SWIG_IsOK(res1)) {
38792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38793 }
38794 arg1 = reinterpret_cast< wxWindow * >(argp1);
38795 {
38796 PyThreadState* __tstate = wxPyBeginAllowThreads();
38797 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38798 wxPyEndAllowThreads(__tstate);
38799 if (PyErr_Occurred()) SWIG_fail;
38800 }
38801 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38802 return resultobj;
38803 fail:
38804 return NULL;
38805 }
38806
38807
38808 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38809 PyObject *resultobj = 0;
38810 wxWindow *arg1 = (wxWindow *) 0 ;
38811 int arg2 ;
38812 int arg3 ;
38813 int arg4 = (int) 1 ;
38814 int arg5 = (int) 1 ;
38815 bool result;
38816 void *argp1 = 0 ;
38817 int res1 = 0 ;
38818 int val2 ;
38819 int ecode2 = 0 ;
38820 int val3 ;
38821 int ecode3 = 0 ;
38822 int val4 ;
38823 int ecode4 = 0 ;
38824 int val5 ;
38825 int ecode5 = 0 ;
38826 PyObject * obj0 = 0 ;
38827 PyObject * obj1 = 0 ;
38828 PyObject * obj2 = 0 ;
38829 PyObject * obj3 = 0 ;
38830 PyObject * obj4 = 0 ;
38831 char * kwnames[] = {
38832 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38833 };
38834
38835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38837 if (!SWIG_IsOK(res1)) {
38838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38839 }
38840 arg1 = reinterpret_cast< wxWindow * >(argp1);
38841 ecode2 = SWIG_AsVal_int(obj1, &val2);
38842 if (!SWIG_IsOK(ecode2)) {
38843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38844 }
38845 arg2 = static_cast< int >(val2);
38846 ecode3 = SWIG_AsVal_int(obj2, &val3);
38847 if (!SWIG_IsOK(ecode3)) {
38848 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38849 }
38850 arg3 = static_cast< int >(val3);
38851 if (obj3) {
38852 ecode4 = SWIG_AsVal_int(obj3, &val4);
38853 if (!SWIG_IsOK(ecode4)) {
38854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38855 }
38856 arg4 = static_cast< int >(val4);
38857 }
38858 if (obj4) {
38859 ecode5 = SWIG_AsVal_int(obj4, &val5);
38860 if (!SWIG_IsOK(ecode5)) {
38861 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38862 }
38863 arg5 = static_cast< int >(val5);
38864 }
38865 {
38866 PyThreadState* __tstate = wxPyBeginAllowThreads();
38867 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38868 wxPyEndAllowThreads(__tstate);
38869 if (PyErr_Occurred()) SWIG_fail;
38870 }
38871 {
38872 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38873 }
38874 return resultobj;
38875 fail:
38876 return NULL;
38877 }
38878
38879
38880 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38881 PyObject *resultobj = 0;
38882 wxWindow *arg1 = (wxWindow *) 0 ;
38883 wxPoint *arg2 = 0 ;
38884 bool result;
38885 void *argp1 = 0 ;
38886 int res1 = 0 ;
38887 wxPoint temp2 ;
38888 PyObject * obj0 = 0 ;
38889 PyObject * obj1 = 0 ;
38890 char * kwnames[] = {
38891 (char *) "self",(char *) "pt", NULL
38892 };
38893
38894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38896 if (!SWIG_IsOK(res1)) {
38897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38898 }
38899 arg1 = reinterpret_cast< wxWindow * >(argp1);
38900 {
38901 arg2 = &temp2;
38902 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38903 }
38904 {
38905 PyThreadState* __tstate = wxPyBeginAllowThreads();
38906 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38907 wxPyEndAllowThreads(__tstate);
38908 if (PyErr_Occurred()) SWIG_fail;
38909 }
38910 {
38911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38912 }
38913 return resultobj;
38914 fail:
38915 return NULL;
38916 }
38917
38918
38919 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38920 PyObject *resultobj = 0;
38921 wxWindow *arg1 = (wxWindow *) 0 ;
38922 wxRect *arg2 = 0 ;
38923 bool result;
38924 void *argp1 = 0 ;
38925 int res1 = 0 ;
38926 wxRect temp2 ;
38927 PyObject * obj0 = 0 ;
38928 PyObject * obj1 = 0 ;
38929 char * kwnames[] = {
38930 (char *) "self",(char *) "rect", NULL
38931 };
38932
38933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38935 if (!SWIG_IsOK(res1)) {
38936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38937 }
38938 arg1 = reinterpret_cast< wxWindow * >(argp1);
38939 {
38940 arg2 = &temp2;
38941 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38942 }
38943 {
38944 PyThreadState* __tstate = wxPyBeginAllowThreads();
38945 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38946 wxPyEndAllowThreads(__tstate);
38947 if (PyErr_Occurred()) SWIG_fail;
38948 }
38949 {
38950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38951 }
38952 return resultobj;
38953 fail:
38954 return NULL;
38955 }
38956
38957
38958 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38959 PyObject *resultobj = 0;
38960 wxWindow *arg1 = (wxWindow *) 0 ;
38961 SwigValueWrapper<wxVisualAttributes > result;
38962 void *argp1 = 0 ;
38963 int res1 = 0 ;
38964 PyObject *swig_obj[1] ;
38965
38966 if (!args) SWIG_fail;
38967 swig_obj[0] = args;
38968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38969 if (!SWIG_IsOK(res1)) {
38970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38971 }
38972 arg1 = reinterpret_cast< wxWindow * >(argp1);
38973 {
38974 PyThreadState* __tstate = wxPyBeginAllowThreads();
38975 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38976 wxPyEndAllowThreads(__tstate);
38977 if (PyErr_Occurred()) SWIG_fail;
38978 }
38979 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38980 return resultobj;
38981 fail:
38982 return NULL;
38983 }
38984
38985
38986 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38987 PyObject *resultobj = 0;
38988 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38989 SwigValueWrapper<wxVisualAttributes > result;
38990 int val1 ;
38991 int ecode1 = 0 ;
38992 PyObject * obj0 = 0 ;
38993 char * kwnames[] = {
38994 (char *) "variant", NULL
38995 };
38996
38997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38998 if (obj0) {
38999 ecode1 = SWIG_AsVal_int(obj0, &val1);
39000 if (!SWIG_IsOK(ecode1)) {
39001 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
39002 }
39003 arg1 = static_cast< wxWindowVariant >(val1);
39004 }
39005 {
39006 if (!wxPyCheckForApp()) SWIG_fail;
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 result = wxWindow::GetClassDefaultAttributes(arg1);
39009 wxPyEndAllowThreads(__tstate);
39010 if (PyErr_Occurred()) SWIG_fail;
39011 }
39012 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
39013 return resultobj;
39014 fail:
39015 return NULL;
39016 }
39017
39018
39019 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39020 PyObject *resultobj = 0;
39021 wxWindow *arg1 = (wxWindow *) 0 ;
39022 wxColour *arg2 = 0 ;
39023 bool result;
39024 void *argp1 = 0 ;
39025 int res1 = 0 ;
39026 wxColour temp2 ;
39027 PyObject * obj0 = 0 ;
39028 PyObject * obj1 = 0 ;
39029 char * kwnames[] = {
39030 (char *) "self",(char *) "colour", NULL
39031 };
39032
39033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39035 if (!SWIG_IsOK(res1)) {
39036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39037 }
39038 arg1 = reinterpret_cast< wxWindow * >(argp1);
39039 {
39040 arg2 = &temp2;
39041 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39042 }
39043 {
39044 PyThreadState* __tstate = wxPyBeginAllowThreads();
39045 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
39046 wxPyEndAllowThreads(__tstate);
39047 if (PyErr_Occurred()) SWIG_fail;
39048 }
39049 {
39050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39051 }
39052 return resultobj;
39053 fail:
39054 return NULL;
39055 }
39056
39057
39058 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39059 PyObject *resultobj = 0;
39060 wxWindow *arg1 = (wxWindow *) 0 ;
39061 wxColour *arg2 = 0 ;
39062 void *argp1 = 0 ;
39063 int res1 = 0 ;
39064 wxColour temp2 ;
39065 PyObject * obj0 = 0 ;
39066 PyObject * obj1 = 0 ;
39067 char * kwnames[] = {
39068 (char *) "self",(char *) "colour", NULL
39069 };
39070
39071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39073 if (!SWIG_IsOK(res1)) {
39074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39075 }
39076 arg1 = reinterpret_cast< wxWindow * >(argp1);
39077 {
39078 arg2 = &temp2;
39079 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39080 }
39081 {
39082 PyThreadState* __tstate = wxPyBeginAllowThreads();
39083 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
39084 wxPyEndAllowThreads(__tstate);
39085 if (PyErr_Occurred()) SWIG_fail;
39086 }
39087 resultobj = SWIG_Py_Void();
39088 return resultobj;
39089 fail:
39090 return NULL;
39091 }
39092
39093
39094 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39095 PyObject *resultobj = 0;
39096 wxWindow *arg1 = (wxWindow *) 0 ;
39097 wxColour *arg2 = 0 ;
39098 bool result;
39099 void *argp1 = 0 ;
39100 int res1 = 0 ;
39101 wxColour temp2 ;
39102 PyObject * obj0 = 0 ;
39103 PyObject * obj1 = 0 ;
39104 char * kwnames[] = {
39105 (char *) "self",(char *) "colour", NULL
39106 };
39107
39108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39110 if (!SWIG_IsOK(res1)) {
39111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39112 }
39113 arg1 = reinterpret_cast< wxWindow * >(argp1);
39114 {
39115 arg2 = &temp2;
39116 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39117 }
39118 {
39119 PyThreadState* __tstate = wxPyBeginAllowThreads();
39120 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
39121 wxPyEndAllowThreads(__tstate);
39122 if (PyErr_Occurred()) SWIG_fail;
39123 }
39124 {
39125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39126 }
39127 return resultobj;
39128 fail:
39129 return NULL;
39130 }
39131
39132
39133 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39134 PyObject *resultobj = 0;
39135 wxWindow *arg1 = (wxWindow *) 0 ;
39136 wxColour *arg2 = 0 ;
39137 void *argp1 = 0 ;
39138 int res1 = 0 ;
39139 wxColour temp2 ;
39140 PyObject * obj0 = 0 ;
39141 PyObject * obj1 = 0 ;
39142 char * kwnames[] = {
39143 (char *) "self",(char *) "colour", NULL
39144 };
39145
39146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
39147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39148 if (!SWIG_IsOK(res1)) {
39149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
39150 }
39151 arg1 = reinterpret_cast< wxWindow * >(argp1);
39152 {
39153 arg2 = &temp2;
39154 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
39155 }
39156 {
39157 PyThreadState* __tstate = wxPyBeginAllowThreads();
39158 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 resultobj = SWIG_Py_Void();
39163 return resultobj;
39164 fail:
39165 return NULL;
39166 }
39167
39168
39169 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39170 PyObject *resultobj = 0;
39171 wxWindow *arg1 = (wxWindow *) 0 ;
39172 wxColour result;
39173 void *argp1 = 0 ;
39174 int res1 = 0 ;
39175 PyObject *swig_obj[1] ;
39176
39177 if (!args) SWIG_fail;
39178 swig_obj[0] = args;
39179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39180 if (!SWIG_IsOK(res1)) {
39181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39182 }
39183 arg1 = reinterpret_cast< wxWindow * >(argp1);
39184 {
39185 PyThreadState* __tstate = wxPyBeginAllowThreads();
39186 result = ((wxWindow const *)arg1)->GetBackgroundColour();
39187 wxPyEndAllowThreads(__tstate);
39188 if (PyErr_Occurred()) SWIG_fail;
39189 }
39190 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39191 return resultobj;
39192 fail:
39193 return NULL;
39194 }
39195
39196
39197 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39198 PyObject *resultobj = 0;
39199 wxWindow *arg1 = (wxWindow *) 0 ;
39200 wxColour result;
39201 void *argp1 = 0 ;
39202 int res1 = 0 ;
39203 PyObject *swig_obj[1] ;
39204
39205 if (!args) SWIG_fail;
39206 swig_obj[0] = args;
39207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39208 if (!SWIG_IsOK(res1)) {
39209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39210 }
39211 arg1 = reinterpret_cast< wxWindow * >(argp1);
39212 {
39213 PyThreadState* __tstate = wxPyBeginAllowThreads();
39214 result = ((wxWindow const *)arg1)->GetForegroundColour();
39215 wxPyEndAllowThreads(__tstate);
39216 if (PyErr_Occurred()) SWIG_fail;
39217 }
39218 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
39219 return resultobj;
39220 fail:
39221 return NULL;
39222 }
39223
39224
39225 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39226 PyObject *resultobj = 0;
39227 wxWindow *arg1 = (wxWindow *) 0 ;
39228 bool result;
39229 void *argp1 = 0 ;
39230 int res1 = 0 ;
39231 PyObject *swig_obj[1] ;
39232
39233 if (!args) SWIG_fail;
39234 swig_obj[0] = args;
39235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39236 if (!SWIG_IsOK(res1)) {
39237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
39238 }
39239 arg1 = reinterpret_cast< wxWindow * >(argp1);
39240 {
39241 PyThreadState* __tstate = wxPyBeginAllowThreads();
39242 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
39243 wxPyEndAllowThreads(__tstate);
39244 if (PyErr_Occurred()) SWIG_fail;
39245 }
39246 {
39247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39248 }
39249 return resultobj;
39250 fail:
39251 return NULL;
39252 }
39253
39254
39255 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39256 PyObject *resultobj = 0;
39257 wxWindow *arg1 = (wxWindow *) 0 ;
39258 bool result;
39259 void *argp1 = 0 ;
39260 int res1 = 0 ;
39261 PyObject *swig_obj[1] ;
39262
39263 if (!args) SWIG_fail;
39264 swig_obj[0] = args;
39265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39266 if (!SWIG_IsOK(res1)) {
39267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
39268 }
39269 arg1 = reinterpret_cast< wxWindow * >(argp1);
39270 {
39271 PyThreadState* __tstate = wxPyBeginAllowThreads();
39272 result = (bool)((wxWindow const *)arg1)->UseBgCol();
39273 wxPyEndAllowThreads(__tstate);
39274 if (PyErr_Occurred()) SWIG_fail;
39275 }
39276 {
39277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39278 }
39279 return resultobj;
39280 fail:
39281 return NULL;
39282 }
39283
39284
39285 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39286 PyObject *resultobj = 0;
39287 wxWindow *arg1 = (wxWindow *) 0 ;
39288 wxBackgroundStyle arg2 ;
39289 bool result;
39290 void *argp1 = 0 ;
39291 int res1 = 0 ;
39292 int val2 ;
39293 int ecode2 = 0 ;
39294 PyObject * obj0 = 0 ;
39295 PyObject * obj1 = 0 ;
39296 char * kwnames[] = {
39297 (char *) "self",(char *) "style", NULL
39298 };
39299
39300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
39301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39302 if (!SWIG_IsOK(res1)) {
39303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
39304 }
39305 arg1 = reinterpret_cast< wxWindow * >(argp1);
39306 ecode2 = SWIG_AsVal_int(obj1, &val2);
39307 if (!SWIG_IsOK(ecode2)) {
39308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
39309 }
39310 arg2 = static_cast< wxBackgroundStyle >(val2);
39311 {
39312 PyThreadState* __tstate = wxPyBeginAllowThreads();
39313 result = (bool)(arg1)->SetBackgroundStyle(arg2);
39314 wxPyEndAllowThreads(__tstate);
39315 if (PyErr_Occurred()) SWIG_fail;
39316 }
39317 {
39318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39319 }
39320 return resultobj;
39321 fail:
39322 return NULL;
39323 }
39324
39325
39326 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39327 PyObject *resultobj = 0;
39328 wxWindow *arg1 = (wxWindow *) 0 ;
39329 wxBackgroundStyle result;
39330 void *argp1 = 0 ;
39331 int res1 = 0 ;
39332 PyObject *swig_obj[1] ;
39333
39334 if (!args) SWIG_fail;
39335 swig_obj[0] = args;
39336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39337 if (!SWIG_IsOK(res1)) {
39338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
39339 }
39340 arg1 = reinterpret_cast< wxWindow * >(argp1);
39341 {
39342 PyThreadState* __tstate = wxPyBeginAllowThreads();
39343 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
39344 wxPyEndAllowThreads(__tstate);
39345 if (PyErr_Occurred()) SWIG_fail;
39346 }
39347 resultobj = SWIG_From_int(static_cast< int >(result));
39348 return resultobj;
39349 fail:
39350 return NULL;
39351 }
39352
39353
39354 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39355 PyObject *resultobj = 0;
39356 wxWindow *arg1 = (wxWindow *) 0 ;
39357 bool result;
39358 void *argp1 = 0 ;
39359 int res1 = 0 ;
39360 PyObject *swig_obj[1] ;
39361
39362 if (!args) SWIG_fail;
39363 swig_obj[0] = args;
39364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39365 if (!SWIG_IsOK(res1)) {
39366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
39367 }
39368 arg1 = reinterpret_cast< wxWindow * >(argp1);
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 result = (bool)(arg1)->HasTransparentBackground();
39372 wxPyEndAllowThreads(__tstate);
39373 if (PyErr_Occurred()) SWIG_fail;
39374 }
39375 {
39376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39377 }
39378 return resultobj;
39379 fail:
39380 return NULL;
39381 }
39382
39383
39384 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39385 PyObject *resultobj = 0;
39386 wxWindow *arg1 = (wxWindow *) 0 ;
39387 wxCursor *arg2 = 0 ;
39388 bool result;
39389 void *argp1 = 0 ;
39390 int res1 = 0 ;
39391 void *argp2 = 0 ;
39392 int res2 = 0 ;
39393 PyObject * obj0 = 0 ;
39394 PyObject * obj1 = 0 ;
39395 char * kwnames[] = {
39396 (char *) "self",(char *) "cursor", NULL
39397 };
39398
39399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
39400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39401 if (!SWIG_IsOK(res1)) {
39402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39403 }
39404 arg1 = reinterpret_cast< wxWindow * >(argp1);
39405 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
39406 if (!SWIG_IsOK(res2)) {
39407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39408 }
39409 if (!argp2) {
39410 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
39411 }
39412 arg2 = reinterpret_cast< wxCursor * >(argp2);
39413 {
39414 PyThreadState* __tstate = wxPyBeginAllowThreads();
39415 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
39416 wxPyEndAllowThreads(__tstate);
39417 if (PyErr_Occurred()) SWIG_fail;
39418 }
39419 {
39420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39421 }
39422 return resultobj;
39423 fail:
39424 return NULL;
39425 }
39426
39427
39428 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39429 PyObject *resultobj = 0;
39430 wxWindow *arg1 = (wxWindow *) 0 ;
39431 wxCursor result;
39432 void *argp1 = 0 ;
39433 int res1 = 0 ;
39434 PyObject *swig_obj[1] ;
39435
39436 if (!args) SWIG_fail;
39437 swig_obj[0] = args;
39438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39439 if (!SWIG_IsOK(res1)) {
39440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
39441 }
39442 arg1 = reinterpret_cast< wxWindow * >(argp1);
39443 {
39444 PyThreadState* __tstate = wxPyBeginAllowThreads();
39445 result = (arg1)->GetCursor();
39446 wxPyEndAllowThreads(__tstate);
39447 if (PyErr_Occurred()) SWIG_fail;
39448 }
39449 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
39450 return resultobj;
39451 fail:
39452 return NULL;
39453 }
39454
39455
39456 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39457 PyObject *resultobj = 0;
39458 wxWindow *arg1 = (wxWindow *) 0 ;
39459 wxFont *arg2 = 0 ;
39460 bool result;
39461 void *argp1 = 0 ;
39462 int res1 = 0 ;
39463 void *argp2 = 0 ;
39464 int res2 = 0 ;
39465 PyObject * obj0 = 0 ;
39466 PyObject * obj1 = 0 ;
39467 char * kwnames[] = {
39468 (char *) "self",(char *) "font", NULL
39469 };
39470
39471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
39472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39473 if (!SWIG_IsOK(res1)) {
39474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39475 }
39476 arg1 = reinterpret_cast< wxWindow * >(argp1);
39477 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39478 if (!SWIG_IsOK(res2)) {
39479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39480 }
39481 if (!argp2) {
39482 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39483 }
39484 arg2 = reinterpret_cast< wxFont * >(argp2);
39485 {
39486 PyThreadState* __tstate = wxPyBeginAllowThreads();
39487 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
39488 wxPyEndAllowThreads(__tstate);
39489 if (PyErr_Occurred()) SWIG_fail;
39490 }
39491 {
39492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39493 }
39494 return resultobj;
39495 fail:
39496 return NULL;
39497 }
39498
39499
39500 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39501 PyObject *resultobj = 0;
39502 wxWindow *arg1 = (wxWindow *) 0 ;
39503 wxFont *arg2 = 0 ;
39504 void *argp1 = 0 ;
39505 int res1 = 0 ;
39506 void *argp2 = 0 ;
39507 int res2 = 0 ;
39508 PyObject * obj0 = 0 ;
39509 PyObject * obj1 = 0 ;
39510 char * kwnames[] = {
39511 (char *) "self",(char *) "font", NULL
39512 };
39513
39514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
39515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39516 if (!SWIG_IsOK(res1)) {
39517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39518 }
39519 arg1 = reinterpret_cast< wxWindow * >(argp1);
39520 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
39521 if (!SWIG_IsOK(res2)) {
39522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39523 }
39524 if (!argp2) {
39525 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
39526 }
39527 arg2 = reinterpret_cast< wxFont * >(argp2);
39528 {
39529 PyThreadState* __tstate = wxPyBeginAllowThreads();
39530 (arg1)->SetOwnFont((wxFont const &)*arg2);
39531 wxPyEndAllowThreads(__tstate);
39532 if (PyErr_Occurred()) SWIG_fail;
39533 }
39534 resultobj = SWIG_Py_Void();
39535 return resultobj;
39536 fail:
39537 return NULL;
39538 }
39539
39540
39541 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39542 PyObject *resultobj = 0;
39543 wxWindow *arg1 = (wxWindow *) 0 ;
39544 wxFont result;
39545 void *argp1 = 0 ;
39546 int res1 = 0 ;
39547 PyObject *swig_obj[1] ;
39548
39549 if (!args) SWIG_fail;
39550 swig_obj[0] = args;
39551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39552 if (!SWIG_IsOK(res1)) {
39553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
39554 }
39555 arg1 = reinterpret_cast< wxWindow * >(argp1);
39556 {
39557 PyThreadState* __tstate = wxPyBeginAllowThreads();
39558 result = (arg1)->GetFont();
39559 wxPyEndAllowThreads(__tstate);
39560 if (PyErr_Occurred()) SWIG_fail;
39561 }
39562 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
39563 return resultobj;
39564 fail:
39565 return NULL;
39566 }
39567
39568
39569 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39570 PyObject *resultobj = 0;
39571 wxWindow *arg1 = (wxWindow *) 0 ;
39572 wxCaret *arg2 = (wxCaret *) 0 ;
39573 void *argp1 = 0 ;
39574 int res1 = 0 ;
39575 int res2 = 0 ;
39576 PyObject * obj0 = 0 ;
39577 PyObject * obj1 = 0 ;
39578 char * kwnames[] = {
39579 (char *) "self",(char *) "caret", NULL
39580 };
39581
39582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
39583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39584 if (!SWIG_IsOK(res1)) {
39585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
39586 }
39587 arg1 = reinterpret_cast< wxWindow * >(argp1);
39588 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
39589 if (!SWIG_IsOK(res2)) {
39590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
39591 }
39592 {
39593 PyThreadState* __tstate = wxPyBeginAllowThreads();
39594 (arg1)->SetCaret(arg2);
39595 wxPyEndAllowThreads(__tstate);
39596 if (PyErr_Occurred()) SWIG_fail;
39597 }
39598 resultobj = SWIG_Py_Void();
39599 return resultobj;
39600 fail:
39601 return NULL;
39602 }
39603
39604
39605 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39606 PyObject *resultobj = 0;
39607 wxWindow *arg1 = (wxWindow *) 0 ;
39608 wxCaret *result = 0 ;
39609 void *argp1 = 0 ;
39610 int res1 = 0 ;
39611 PyObject *swig_obj[1] ;
39612
39613 if (!args) SWIG_fail;
39614 swig_obj[0] = args;
39615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39616 if (!SWIG_IsOK(res1)) {
39617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
39618 }
39619 arg1 = reinterpret_cast< wxWindow * >(argp1);
39620 {
39621 PyThreadState* __tstate = wxPyBeginAllowThreads();
39622 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
39623 wxPyEndAllowThreads(__tstate);
39624 if (PyErr_Occurred()) SWIG_fail;
39625 }
39626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
39627 return resultobj;
39628 fail:
39629 return NULL;
39630 }
39631
39632
39633 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39634 PyObject *resultobj = 0;
39635 wxWindow *arg1 = (wxWindow *) 0 ;
39636 int result;
39637 void *argp1 = 0 ;
39638 int res1 = 0 ;
39639 PyObject *swig_obj[1] ;
39640
39641 if (!args) SWIG_fail;
39642 swig_obj[0] = args;
39643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39644 if (!SWIG_IsOK(res1)) {
39645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
39646 }
39647 arg1 = reinterpret_cast< wxWindow * >(argp1);
39648 {
39649 PyThreadState* __tstate = wxPyBeginAllowThreads();
39650 result = (int)((wxWindow const *)arg1)->GetCharHeight();
39651 wxPyEndAllowThreads(__tstate);
39652 if (PyErr_Occurred()) SWIG_fail;
39653 }
39654 resultobj = SWIG_From_int(static_cast< int >(result));
39655 return resultobj;
39656 fail:
39657 return NULL;
39658 }
39659
39660
39661 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39662 PyObject *resultobj = 0;
39663 wxWindow *arg1 = (wxWindow *) 0 ;
39664 int result;
39665 void *argp1 = 0 ;
39666 int res1 = 0 ;
39667 PyObject *swig_obj[1] ;
39668
39669 if (!args) SWIG_fail;
39670 swig_obj[0] = args;
39671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39672 if (!SWIG_IsOK(res1)) {
39673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
39674 }
39675 arg1 = reinterpret_cast< wxWindow * >(argp1);
39676 {
39677 PyThreadState* __tstate = wxPyBeginAllowThreads();
39678 result = (int)((wxWindow const *)arg1)->GetCharWidth();
39679 wxPyEndAllowThreads(__tstate);
39680 if (PyErr_Occurred()) SWIG_fail;
39681 }
39682 resultobj = SWIG_From_int(static_cast< int >(result));
39683 return resultobj;
39684 fail:
39685 return NULL;
39686 }
39687
39688
39689 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39690 PyObject *resultobj = 0;
39691 wxWindow *arg1 = (wxWindow *) 0 ;
39692 wxString *arg2 = 0 ;
39693 int *arg3 = (int *) 0 ;
39694 int *arg4 = (int *) 0 ;
39695 void *argp1 = 0 ;
39696 int res1 = 0 ;
39697 bool temp2 = false ;
39698 int temp3 ;
39699 int res3 = SWIG_TMPOBJ ;
39700 int temp4 ;
39701 int res4 = SWIG_TMPOBJ ;
39702 PyObject * obj0 = 0 ;
39703 PyObject * obj1 = 0 ;
39704 char * kwnames[] = {
39705 (char *) "self",(char *) "string", NULL
39706 };
39707
39708 arg3 = &temp3;
39709 arg4 = &temp4;
39710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39712 if (!SWIG_IsOK(res1)) {
39713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39714 }
39715 arg1 = reinterpret_cast< wxWindow * >(argp1);
39716 {
39717 arg2 = wxString_in_helper(obj1);
39718 if (arg2 == NULL) SWIG_fail;
39719 temp2 = true;
39720 }
39721 {
39722 PyThreadState* __tstate = wxPyBeginAllowThreads();
39723 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39724 wxPyEndAllowThreads(__tstate);
39725 if (PyErr_Occurred()) SWIG_fail;
39726 }
39727 resultobj = SWIG_Py_Void();
39728 if (SWIG_IsTmpObj(res3)) {
39729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39730 } else {
39731 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39733 }
39734 if (SWIG_IsTmpObj(res4)) {
39735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39736 } else {
39737 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39739 }
39740 {
39741 if (temp2)
39742 delete arg2;
39743 }
39744 return resultobj;
39745 fail:
39746 {
39747 if (temp2)
39748 delete arg2;
39749 }
39750 return NULL;
39751 }
39752
39753
39754 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39755 PyObject *resultobj = 0;
39756 wxWindow *arg1 = (wxWindow *) 0 ;
39757 wxString *arg2 = 0 ;
39758 int *arg3 = (int *) 0 ;
39759 int *arg4 = (int *) 0 ;
39760 int *arg5 = (int *) 0 ;
39761 int *arg6 = (int *) 0 ;
39762 wxFont *arg7 = (wxFont *) NULL ;
39763 void *argp1 = 0 ;
39764 int res1 = 0 ;
39765 bool temp2 = false ;
39766 int temp3 ;
39767 int res3 = SWIG_TMPOBJ ;
39768 int temp4 ;
39769 int res4 = SWIG_TMPOBJ ;
39770 int temp5 ;
39771 int res5 = SWIG_TMPOBJ ;
39772 int temp6 ;
39773 int res6 = SWIG_TMPOBJ ;
39774 void *argp7 = 0 ;
39775 int res7 = 0 ;
39776 PyObject * obj0 = 0 ;
39777 PyObject * obj1 = 0 ;
39778 PyObject * obj2 = 0 ;
39779 char * kwnames[] = {
39780 (char *) "self",(char *) "string",(char *) "font", NULL
39781 };
39782
39783 arg3 = &temp3;
39784 arg4 = &temp4;
39785 arg5 = &temp5;
39786 arg6 = &temp6;
39787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39789 if (!SWIG_IsOK(res1)) {
39790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39791 }
39792 arg1 = reinterpret_cast< wxWindow * >(argp1);
39793 {
39794 arg2 = wxString_in_helper(obj1);
39795 if (arg2 == NULL) SWIG_fail;
39796 temp2 = true;
39797 }
39798 if (obj2) {
39799 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39800 if (!SWIG_IsOK(res7)) {
39801 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39802 }
39803 arg7 = reinterpret_cast< wxFont * >(argp7);
39804 }
39805 {
39806 PyThreadState* __tstate = wxPyBeginAllowThreads();
39807 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39808 wxPyEndAllowThreads(__tstate);
39809 if (PyErr_Occurred()) SWIG_fail;
39810 }
39811 resultobj = SWIG_Py_Void();
39812 if (SWIG_IsTmpObj(res3)) {
39813 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39814 } else {
39815 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39816 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39817 }
39818 if (SWIG_IsTmpObj(res4)) {
39819 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39820 } else {
39821 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39822 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39823 }
39824 if (SWIG_IsTmpObj(res5)) {
39825 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39826 } else {
39827 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39828 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39829 }
39830 if (SWIG_IsTmpObj(res6)) {
39831 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39832 } else {
39833 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39834 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39835 }
39836 {
39837 if (temp2)
39838 delete arg2;
39839 }
39840 return resultobj;
39841 fail:
39842 {
39843 if (temp2)
39844 delete arg2;
39845 }
39846 return NULL;
39847 }
39848
39849
39850 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39851 PyObject *resultobj = 0;
39852 wxWindow *arg1 = (wxWindow *) 0 ;
39853 int *arg2 = (int *) 0 ;
39854 int *arg3 = (int *) 0 ;
39855 void *argp1 = 0 ;
39856 int res1 = 0 ;
39857 int temp2 ;
39858 int res2 = 0 ;
39859 int temp3 ;
39860 int res3 = 0 ;
39861 PyObject * obj0 = 0 ;
39862 PyObject * obj1 = 0 ;
39863 PyObject * obj2 = 0 ;
39864 char * kwnames[] = {
39865 (char *) "self",(char *) "x",(char *) "y", NULL
39866 };
39867
39868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39870 if (!SWIG_IsOK(res1)) {
39871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39872 }
39873 arg1 = reinterpret_cast< wxWindow * >(argp1);
39874 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39875 int val;
39876 int ecode = SWIG_AsVal_int(obj1, &val);
39877 if (!SWIG_IsOK(ecode)) {
39878 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39879 }
39880 temp2 = static_cast< int >(val);
39881 arg2 = &temp2;
39882 res2 = SWIG_AddTmpMask(ecode);
39883 }
39884 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39885 int val;
39886 int ecode = SWIG_AsVal_int(obj2, &val);
39887 if (!SWIG_IsOK(ecode)) {
39888 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39889 }
39890 temp3 = static_cast< int >(val);
39891 arg3 = &temp3;
39892 res3 = SWIG_AddTmpMask(ecode);
39893 }
39894 {
39895 PyThreadState* __tstate = wxPyBeginAllowThreads();
39896 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 resultobj = SWIG_Py_Void();
39901 if (SWIG_IsTmpObj(res2)) {
39902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39903 } else {
39904 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39905 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39906 }
39907 if (SWIG_IsTmpObj(res3)) {
39908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39909 } else {
39910 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39912 }
39913 return resultobj;
39914 fail:
39915 return NULL;
39916 }
39917
39918
39919 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39920 PyObject *resultobj = 0;
39921 wxWindow *arg1 = (wxWindow *) 0 ;
39922 int *arg2 = (int *) 0 ;
39923 int *arg3 = (int *) 0 ;
39924 void *argp1 = 0 ;
39925 int res1 = 0 ;
39926 int temp2 ;
39927 int res2 = 0 ;
39928 int temp3 ;
39929 int res3 = 0 ;
39930 PyObject * obj0 = 0 ;
39931 PyObject * obj1 = 0 ;
39932 PyObject * obj2 = 0 ;
39933 char * kwnames[] = {
39934 (char *) "self",(char *) "x",(char *) "y", NULL
39935 };
39936
39937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39939 if (!SWIG_IsOK(res1)) {
39940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39941 }
39942 arg1 = reinterpret_cast< wxWindow * >(argp1);
39943 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39944 int val;
39945 int ecode = SWIG_AsVal_int(obj1, &val);
39946 if (!SWIG_IsOK(ecode)) {
39947 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39948 }
39949 temp2 = static_cast< int >(val);
39950 arg2 = &temp2;
39951 res2 = SWIG_AddTmpMask(ecode);
39952 }
39953 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39954 int val;
39955 int ecode = SWIG_AsVal_int(obj2, &val);
39956 if (!SWIG_IsOK(ecode)) {
39957 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39958 }
39959 temp3 = static_cast< int >(val);
39960 arg3 = &temp3;
39961 res3 = SWIG_AddTmpMask(ecode);
39962 }
39963 {
39964 PyThreadState* __tstate = wxPyBeginAllowThreads();
39965 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39966 wxPyEndAllowThreads(__tstate);
39967 if (PyErr_Occurred()) SWIG_fail;
39968 }
39969 resultobj = SWIG_Py_Void();
39970 if (SWIG_IsTmpObj(res2)) {
39971 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39972 } else {
39973 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39974 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39975 }
39976 if (SWIG_IsTmpObj(res3)) {
39977 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39978 } else {
39979 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39980 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39981 }
39982 return resultobj;
39983 fail:
39984 return NULL;
39985 }
39986
39987
39988 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39989 PyObject *resultobj = 0;
39990 wxWindow *arg1 = (wxWindow *) 0 ;
39991 wxPoint *arg2 = 0 ;
39992 wxPoint result;
39993 void *argp1 = 0 ;
39994 int res1 = 0 ;
39995 wxPoint temp2 ;
39996 PyObject * obj0 = 0 ;
39997 PyObject * obj1 = 0 ;
39998 char * kwnames[] = {
39999 (char *) "self",(char *) "pt", NULL
40000 };
40001
40002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
40003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40004 if (!SWIG_IsOK(res1)) {
40005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
40006 }
40007 arg1 = reinterpret_cast< wxWindow * >(argp1);
40008 {
40009 arg2 = &temp2;
40010 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40011 }
40012 {
40013 PyThreadState* __tstate = wxPyBeginAllowThreads();
40014 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
40015 wxPyEndAllowThreads(__tstate);
40016 if (PyErr_Occurred()) SWIG_fail;
40017 }
40018 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40019 return resultobj;
40020 fail:
40021 return NULL;
40022 }
40023
40024
40025 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40026 PyObject *resultobj = 0;
40027 wxWindow *arg1 = (wxWindow *) 0 ;
40028 wxPoint *arg2 = 0 ;
40029 wxPoint result;
40030 void *argp1 = 0 ;
40031 int res1 = 0 ;
40032 wxPoint temp2 ;
40033 PyObject * obj0 = 0 ;
40034 PyObject * obj1 = 0 ;
40035 char * kwnames[] = {
40036 (char *) "self",(char *) "pt", NULL
40037 };
40038
40039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
40040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40041 if (!SWIG_IsOK(res1)) {
40042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
40043 }
40044 arg1 = reinterpret_cast< wxWindow * >(argp1);
40045 {
40046 arg2 = &temp2;
40047 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40048 }
40049 {
40050 PyThreadState* __tstate = wxPyBeginAllowThreads();
40051 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
40052 wxPyEndAllowThreads(__tstate);
40053 if (PyErr_Occurred()) SWIG_fail;
40054 }
40055 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
40056 return resultobj;
40057 fail:
40058 return NULL;
40059 }
40060
40061
40062 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40063 PyObject *resultobj = 0;
40064 wxWindow *arg1 = (wxWindow *) 0 ;
40065 int arg2 ;
40066 int arg3 ;
40067 wxHitTest result;
40068 void *argp1 = 0 ;
40069 int res1 = 0 ;
40070 int val2 ;
40071 int ecode2 = 0 ;
40072 int val3 ;
40073 int ecode3 = 0 ;
40074 PyObject * obj0 = 0 ;
40075 PyObject * obj1 = 0 ;
40076 PyObject * obj2 = 0 ;
40077 char * kwnames[] = {
40078 (char *) "self",(char *) "x",(char *) "y", NULL
40079 };
40080
40081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40083 if (!SWIG_IsOK(res1)) {
40084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
40085 }
40086 arg1 = reinterpret_cast< wxWindow * >(argp1);
40087 ecode2 = SWIG_AsVal_int(obj1, &val2);
40088 if (!SWIG_IsOK(ecode2)) {
40089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
40090 }
40091 arg2 = static_cast< int >(val2);
40092 ecode3 = SWIG_AsVal_int(obj2, &val3);
40093 if (!SWIG_IsOK(ecode3)) {
40094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
40095 }
40096 arg3 = static_cast< int >(val3);
40097 {
40098 PyThreadState* __tstate = wxPyBeginAllowThreads();
40099 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
40100 wxPyEndAllowThreads(__tstate);
40101 if (PyErr_Occurred()) SWIG_fail;
40102 }
40103 resultobj = SWIG_From_int(static_cast< int >(result));
40104 return resultobj;
40105 fail:
40106 return NULL;
40107 }
40108
40109
40110 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40111 PyObject *resultobj = 0;
40112 wxWindow *arg1 = (wxWindow *) 0 ;
40113 wxPoint *arg2 = 0 ;
40114 wxHitTest result;
40115 void *argp1 = 0 ;
40116 int res1 = 0 ;
40117 wxPoint temp2 ;
40118 PyObject * obj0 = 0 ;
40119 PyObject * obj1 = 0 ;
40120 char * kwnames[] = {
40121 (char *) "self",(char *) "pt", NULL
40122 };
40123
40124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
40125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40126 if (!SWIG_IsOK(res1)) {
40127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
40128 }
40129 arg1 = reinterpret_cast< wxWindow * >(argp1);
40130 {
40131 arg2 = &temp2;
40132 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40133 }
40134 {
40135 PyThreadState* __tstate = wxPyBeginAllowThreads();
40136 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
40137 wxPyEndAllowThreads(__tstate);
40138 if (PyErr_Occurred()) SWIG_fail;
40139 }
40140 resultobj = SWIG_From_int(static_cast< int >(result));
40141 return resultobj;
40142 fail:
40143 return NULL;
40144 }
40145
40146
40147 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40148 PyObject *resultobj = 0;
40149 wxWindow *arg1 = (wxWindow *) 0 ;
40150 long arg2 ;
40151 wxBorder result;
40152 void *argp1 = 0 ;
40153 int res1 = 0 ;
40154 long val2 ;
40155 int ecode2 = 0 ;
40156
40157 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
40158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40159 if (!SWIG_IsOK(res1)) {
40160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40161 }
40162 arg1 = reinterpret_cast< wxWindow * >(argp1);
40163 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
40164 if (!SWIG_IsOK(ecode2)) {
40165 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
40166 }
40167 arg2 = static_cast< long >(val2);
40168 {
40169 PyThreadState* __tstate = wxPyBeginAllowThreads();
40170 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
40171 wxPyEndAllowThreads(__tstate);
40172 if (PyErr_Occurred()) SWIG_fail;
40173 }
40174 resultobj = SWIG_From_int(static_cast< int >(result));
40175 return resultobj;
40176 fail:
40177 return NULL;
40178 }
40179
40180
40181 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
40182 PyObject *resultobj = 0;
40183 wxWindow *arg1 = (wxWindow *) 0 ;
40184 wxBorder result;
40185 void *argp1 = 0 ;
40186 int res1 = 0 ;
40187
40188 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
40189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40190 if (!SWIG_IsOK(res1)) {
40191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
40192 }
40193 arg1 = reinterpret_cast< wxWindow * >(argp1);
40194 {
40195 PyThreadState* __tstate = wxPyBeginAllowThreads();
40196 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
40197 wxPyEndAllowThreads(__tstate);
40198 if (PyErr_Occurred()) SWIG_fail;
40199 }
40200 resultobj = SWIG_From_int(static_cast< int >(result));
40201 return resultobj;
40202 fail:
40203 return NULL;
40204 }
40205
40206
40207 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
40208 int argc;
40209 PyObject *argv[3];
40210
40211 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
40212 --argc;
40213 if (argc == 1) {
40214 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
40215 }
40216 if (argc == 2) {
40217 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
40218 }
40219
40220 fail:
40221 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
40222 return NULL;
40223 }
40224
40225
40226 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40227 PyObject *resultobj = 0;
40228 wxWindow *arg1 = (wxWindow *) 0 ;
40229 long arg2 = (long) wxUPDATE_UI_NONE ;
40230 void *argp1 = 0 ;
40231 int res1 = 0 ;
40232 long val2 ;
40233 int ecode2 = 0 ;
40234 PyObject * obj0 = 0 ;
40235 PyObject * obj1 = 0 ;
40236 char * kwnames[] = {
40237 (char *) "self",(char *) "flags", NULL
40238 };
40239
40240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
40241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40242 if (!SWIG_IsOK(res1)) {
40243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
40244 }
40245 arg1 = reinterpret_cast< wxWindow * >(argp1);
40246 if (obj1) {
40247 ecode2 = SWIG_AsVal_long(obj1, &val2);
40248 if (!SWIG_IsOK(ecode2)) {
40249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
40250 }
40251 arg2 = static_cast< long >(val2);
40252 }
40253 {
40254 PyThreadState* __tstate = wxPyBeginAllowThreads();
40255 (arg1)->UpdateWindowUI(arg2);
40256 wxPyEndAllowThreads(__tstate);
40257 if (PyErr_Occurred()) SWIG_fail;
40258 }
40259 resultobj = SWIG_Py_Void();
40260 return resultobj;
40261 fail:
40262 return NULL;
40263 }
40264
40265
40266 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40267 PyObject *resultobj = 0;
40268 wxWindow *arg1 = (wxWindow *) 0 ;
40269 wxMenu *arg2 = (wxMenu *) 0 ;
40270 int arg3 = (int) -1 ;
40271 int arg4 = (int) -1 ;
40272 bool result;
40273 void *argp1 = 0 ;
40274 int res1 = 0 ;
40275 void *argp2 = 0 ;
40276 int res2 = 0 ;
40277 int val3 ;
40278 int ecode3 = 0 ;
40279 int val4 ;
40280 int ecode4 = 0 ;
40281 PyObject * obj0 = 0 ;
40282 PyObject * obj1 = 0 ;
40283 PyObject * obj2 = 0 ;
40284 PyObject * obj3 = 0 ;
40285 char * kwnames[] = {
40286 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
40287 };
40288
40289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40291 if (!SWIG_IsOK(res1)) {
40292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
40293 }
40294 arg1 = reinterpret_cast< wxWindow * >(argp1);
40295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40296 if (!SWIG_IsOK(res2)) {
40297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
40298 }
40299 arg2 = reinterpret_cast< wxMenu * >(argp2);
40300 if (obj2) {
40301 ecode3 = SWIG_AsVal_int(obj2, &val3);
40302 if (!SWIG_IsOK(ecode3)) {
40303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
40304 }
40305 arg3 = static_cast< int >(val3);
40306 }
40307 if (obj3) {
40308 ecode4 = SWIG_AsVal_int(obj3, &val4);
40309 if (!SWIG_IsOK(ecode4)) {
40310 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
40311 }
40312 arg4 = static_cast< int >(val4);
40313 }
40314 {
40315 PyThreadState* __tstate = wxPyBeginAllowThreads();
40316 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
40317 wxPyEndAllowThreads(__tstate);
40318 if (PyErr_Occurred()) SWIG_fail;
40319 }
40320 {
40321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40322 }
40323 return resultobj;
40324 fail:
40325 return NULL;
40326 }
40327
40328
40329 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40330 PyObject *resultobj = 0;
40331 wxWindow *arg1 = (wxWindow *) 0 ;
40332 wxMenu *arg2 = (wxMenu *) 0 ;
40333 wxPoint const &arg3_defvalue = wxDefaultPosition ;
40334 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
40335 bool result;
40336 void *argp1 = 0 ;
40337 int res1 = 0 ;
40338 void *argp2 = 0 ;
40339 int res2 = 0 ;
40340 wxPoint temp3 ;
40341 PyObject * obj0 = 0 ;
40342 PyObject * obj1 = 0 ;
40343 PyObject * obj2 = 0 ;
40344 char * kwnames[] = {
40345 (char *) "self",(char *) "menu",(char *) "pos", NULL
40346 };
40347
40348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40350 if (!SWIG_IsOK(res1)) {
40351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
40352 }
40353 arg1 = reinterpret_cast< wxWindow * >(argp1);
40354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40355 if (!SWIG_IsOK(res2)) {
40356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
40357 }
40358 arg2 = reinterpret_cast< wxMenu * >(argp2);
40359 if (obj2) {
40360 {
40361 arg3 = &temp3;
40362 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
40363 }
40364 }
40365 {
40366 PyThreadState* __tstate = wxPyBeginAllowThreads();
40367 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
40368 wxPyEndAllowThreads(__tstate);
40369 if (PyErr_Occurred()) SWIG_fail;
40370 }
40371 {
40372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40373 }
40374 return resultobj;
40375 fail:
40376 return NULL;
40377 }
40378
40379
40380 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40381 PyObject *resultobj = 0;
40382 wxWindow *arg1 = (wxWindow *) 0 ;
40383 bool result;
40384 void *argp1 = 0 ;
40385 int res1 = 0 ;
40386 PyObject *swig_obj[1] ;
40387
40388 if (!args) SWIG_fail;
40389 swig_obj[0] = args;
40390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40391 if (!SWIG_IsOK(res1)) {
40392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
40393 }
40394 arg1 = reinterpret_cast< wxWindow * >(argp1);
40395 {
40396 PyThreadState* __tstate = wxPyBeginAllowThreads();
40397 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
40398 wxPyEndAllowThreads(__tstate);
40399 if (PyErr_Occurred()) SWIG_fail;
40400 }
40401 {
40402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40403 }
40404 return resultobj;
40405 fail:
40406 return NULL;
40407 }
40408
40409
40410 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40411 PyObject *resultobj = 0;
40412 wxWindow *arg1 = (wxWindow *) 0 ;
40413 long result;
40414 void *argp1 = 0 ;
40415 int res1 = 0 ;
40416 PyObject *swig_obj[1] ;
40417
40418 if (!args) SWIG_fail;
40419 swig_obj[0] = args;
40420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40421 if (!SWIG_IsOK(res1)) {
40422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40423 }
40424 arg1 = reinterpret_cast< wxWindow * >(argp1);
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 result = (long)wxWindow_GetHandle(arg1);
40428 wxPyEndAllowThreads(__tstate);
40429 if (PyErr_Occurred()) SWIG_fail;
40430 }
40431 resultobj = SWIG_From_long(static_cast< long >(result));
40432 return resultobj;
40433 fail:
40434 return NULL;
40435 }
40436
40437
40438 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40439 PyObject *resultobj = 0;
40440 wxWindow *arg1 = (wxWindow *) 0 ;
40441 long arg2 ;
40442 void *argp1 = 0 ;
40443 int res1 = 0 ;
40444 long val2 ;
40445 int ecode2 = 0 ;
40446 PyObject * obj0 = 0 ;
40447 PyObject * obj1 = 0 ;
40448 char * kwnames[] = {
40449 (char *) "self",(char *) "handle", NULL
40450 };
40451
40452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
40453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40454 if (!SWIG_IsOK(res1)) {
40455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40456 }
40457 arg1 = reinterpret_cast< wxWindow * >(argp1);
40458 ecode2 = SWIG_AsVal_long(obj1, &val2);
40459 if (!SWIG_IsOK(ecode2)) {
40460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
40461 }
40462 arg2 = static_cast< long >(val2);
40463 {
40464 PyThreadState* __tstate = wxPyBeginAllowThreads();
40465 wxWindow_AssociateHandle(arg1,arg2);
40466 wxPyEndAllowThreads(__tstate);
40467 if (PyErr_Occurred()) SWIG_fail;
40468 }
40469 resultobj = SWIG_Py_Void();
40470 return resultobj;
40471 fail:
40472 return NULL;
40473 }
40474
40475
40476 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40477 PyObject *resultobj = 0;
40478 wxWindow *arg1 = (wxWindow *) 0 ;
40479 void *argp1 = 0 ;
40480 int res1 = 0 ;
40481 PyObject *swig_obj[1] ;
40482
40483 if (!args) SWIG_fail;
40484 swig_obj[0] = args;
40485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40486 if (!SWIG_IsOK(res1)) {
40487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
40488 }
40489 arg1 = reinterpret_cast< wxWindow * >(argp1);
40490 {
40491 PyThreadState* __tstate = wxPyBeginAllowThreads();
40492 (arg1)->DissociateHandle();
40493 wxPyEndAllowThreads(__tstate);
40494 if (PyErr_Occurred()) SWIG_fail;
40495 }
40496 resultobj = SWIG_Py_Void();
40497 return resultobj;
40498 fail:
40499 return NULL;
40500 }
40501
40502
40503 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40504 PyObject *resultobj = 0;
40505 wxWindow *arg1 = (wxWindow *) 0 ;
40506 int arg2 ;
40507 bool result;
40508 void *argp1 = 0 ;
40509 int res1 = 0 ;
40510 int val2 ;
40511 int ecode2 = 0 ;
40512 PyObject * obj0 = 0 ;
40513 PyObject * obj1 = 0 ;
40514 char * kwnames[] = {
40515 (char *) "self",(char *) "orient", NULL
40516 };
40517
40518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
40519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40520 if (!SWIG_IsOK(res1)) {
40521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
40522 }
40523 arg1 = reinterpret_cast< wxWindow * >(argp1);
40524 ecode2 = SWIG_AsVal_int(obj1, &val2);
40525 if (!SWIG_IsOK(ecode2)) {
40526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
40527 }
40528 arg2 = static_cast< int >(val2);
40529 {
40530 PyThreadState* __tstate = wxPyBeginAllowThreads();
40531 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
40532 wxPyEndAllowThreads(__tstate);
40533 if (PyErr_Occurred()) SWIG_fail;
40534 }
40535 {
40536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40537 }
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40545 PyObject *resultobj = 0;
40546 wxWindow *arg1 = (wxWindow *) 0 ;
40547 int arg2 ;
40548 int arg3 ;
40549 int arg4 ;
40550 int arg5 ;
40551 bool arg6 = (bool) true ;
40552 void *argp1 = 0 ;
40553 int res1 = 0 ;
40554 int val2 ;
40555 int ecode2 = 0 ;
40556 int val3 ;
40557 int ecode3 = 0 ;
40558 int val4 ;
40559 int ecode4 = 0 ;
40560 int val5 ;
40561 int ecode5 = 0 ;
40562 bool val6 ;
40563 int ecode6 = 0 ;
40564 PyObject * obj0 = 0 ;
40565 PyObject * obj1 = 0 ;
40566 PyObject * obj2 = 0 ;
40567 PyObject * obj3 = 0 ;
40568 PyObject * obj4 = 0 ;
40569 PyObject * obj5 = 0 ;
40570 char * kwnames[] = {
40571 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
40572 };
40573
40574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
40575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40576 if (!SWIG_IsOK(res1)) {
40577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
40578 }
40579 arg1 = reinterpret_cast< wxWindow * >(argp1);
40580 ecode2 = SWIG_AsVal_int(obj1, &val2);
40581 if (!SWIG_IsOK(ecode2)) {
40582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
40583 }
40584 arg2 = static_cast< int >(val2);
40585 ecode3 = SWIG_AsVal_int(obj2, &val3);
40586 if (!SWIG_IsOK(ecode3)) {
40587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
40588 }
40589 arg3 = static_cast< int >(val3);
40590 ecode4 = SWIG_AsVal_int(obj3, &val4);
40591 if (!SWIG_IsOK(ecode4)) {
40592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
40593 }
40594 arg4 = static_cast< int >(val4);
40595 ecode5 = SWIG_AsVal_int(obj4, &val5);
40596 if (!SWIG_IsOK(ecode5)) {
40597 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
40598 }
40599 arg5 = static_cast< int >(val5);
40600 if (obj5) {
40601 ecode6 = SWIG_AsVal_bool(obj5, &val6);
40602 if (!SWIG_IsOK(ecode6)) {
40603 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
40604 }
40605 arg6 = static_cast< bool >(val6);
40606 }
40607 {
40608 PyThreadState* __tstate = wxPyBeginAllowThreads();
40609 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
40610 wxPyEndAllowThreads(__tstate);
40611 if (PyErr_Occurred()) SWIG_fail;
40612 }
40613 resultobj = SWIG_Py_Void();
40614 return resultobj;
40615 fail:
40616 return NULL;
40617 }
40618
40619
40620 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40621 PyObject *resultobj = 0;
40622 wxWindow *arg1 = (wxWindow *) 0 ;
40623 int arg2 ;
40624 int arg3 ;
40625 bool arg4 = (bool) true ;
40626 void *argp1 = 0 ;
40627 int res1 = 0 ;
40628 int val2 ;
40629 int ecode2 = 0 ;
40630 int val3 ;
40631 int ecode3 = 0 ;
40632 bool val4 ;
40633 int ecode4 = 0 ;
40634 PyObject * obj0 = 0 ;
40635 PyObject * obj1 = 0 ;
40636 PyObject * obj2 = 0 ;
40637 PyObject * obj3 = 0 ;
40638 char * kwnames[] = {
40639 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
40640 };
40641
40642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40644 if (!SWIG_IsOK(res1)) {
40645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
40646 }
40647 arg1 = reinterpret_cast< wxWindow * >(argp1);
40648 ecode2 = SWIG_AsVal_int(obj1, &val2);
40649 if (!SWIG_IsOK(ecode2)) {
40650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
40651 }
40652 arg2 = static_cast< int >(val2);
40653 ecode3 = SWIG_AsVal_int(obj2, &val3);
40654 if (!SWIG_IsOK(ecode3)) {
40655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
40656 }
40657 arg3 = static_cast< int >(val3);
40658 if (obj3) {
40659 ecode4 = SWIG_AsVal_bool(obj3, &val4);
40660 if (!SWIG_IsOK(ecode4)) {
40661 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
40662 }
40663 arg4 = static_cast< bool >(val4);
40664 }
40665 {
40666 PyThreadState* __tstate = wxPyBeginAllowThreads();
40667 (arg1)->SetScrollPos(arg2,arg3,arg4);
40668 wxPyEndAllowThreads(__tstate);
40669 if (PyErr_Occurred()) SWIG_fail;
40670 }
40671 resultobj = SWIG_Py_Void();
40672 return resultobj;
40673 fail:
40674 return NULL;
40675 }
40676
40677
40678 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40679 PyObject *resultobj = 0;
40680 wxWindow *arg1 = (wxWindow *) 0 ;
40681 int arg2 ;
40682 int result;
40683 void *argp1 = 0 ;
40684 int res1 = 0 ;
40685 int val2 ;
40686 int ecode2 = 0 ;
40687 PyObject * obj0 = 0 ;
40688 PyObject * obj1 = 0 ;
40689 char * kwnames[] = {
40690 (char *) "self",(char *) "orientation", NULL
40691 };
40692
40693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40695 if (!SWIG_IsOK(res1)) {
40696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40697 }
40698 arg1 = reinterpret_cast< wxWindow * >(argp1);
40699 ecode2 = SWIG_AsVal_int(obj1, &val2);
40700 if (!SWIG_IsOK(ecode2)) {
40701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40702 }
40703 arg2 = static_cast< int >(val2);
40704 {
40705 PyThreadState* __tstate = wxPyBeginAllowThreads();
40706 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40707 wxPyEndAllowThreads(__tstate);
40708 if (PyErr_Occurred()) SWIG_fail;
40709 }
40710 resultobj = SWIG_From_int(static_cast< int >(result));
40711 return resultobj;
40712 fail:
40713 return NULL;
40714 }
40715
40716
40717 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40718 PyObject *resultobj = 0;
40719 wxWindow *arg1 = (wxWindow *) 0 ;
40720 int arg2 ;
40721 int result;
40722 void *argp1 = 0 ;
40723 int res1 = 0 ;
40724 int val2 ;
40725 int ecode2 = 0 ;
40726 PyObject * obj0 = 0 ;
40727 PyObject * obj1 = 0 ;
40728 char * kwnames[] = {
40729 (char *) "self",(char *) "orientation", NULL
40730 };
40731
40732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40734 if (!SWIG_IsOK(res1)) {
40735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40736 }
40737 arg1 = reinterpret_cast< wxWindow * >(argp1);
40738 ecode2 = SWIG_AsVal_int(obj1, &val2);
40739 if (!SWIG_IsOK(ecode2)) {
40740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40741 }
40742 arg2 = static_cast< int >(val2);
40743 {
40744 PyThreadState* __tstate = wxPyBeginAllowThreads();
40745 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40746 wxPyEndAllowThreads(__tstate);
40747 if (PyErr_Occurred()) SWIG_fail;
40748 }
40749 resultobj = SWIG_From_int(static_cast< int >(result));
40750 return resultobj;
40751 fail:
40752 return NULL;
40753 }
40754
40755
40756 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40757 PyObject *resultobj = 0;
40758 wxWindow *arg1 = (wxWindow *) 0 ;
40759 int arg2 ;
40760 int result;
40761 void *argp1 = 0 ;
40762 int res1 = 0 ;
40763 int val2 ;
40764 int ecode2 = 0 ;
40765 PyObject * obj0 = 0 ;
40766 PyObject * obj1 = 0 ;
40767 char * kwnames[] = {
40768 (char *) "self",(char *) "orientation", NULL
40769 };
40770
40771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40773 if (!SWIG_IsOK(res1)) {
40774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40775 }
40776 arg1 = reinterpret_cast< wxWindow * >(argp1);
40777 ecode2 = SWIG_AsVal_int(obj1, &val2);
40778 if (!SWIG_IsOK(ecode2)) {
40779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40780 }
40781 arg2 = static_cast< int >(val2);
40782 {
40783 PyThreadState* __tstate = wxPyBeginAllowThreads();
40784 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40785 wxPyEndAllowThreads(__tstate);
40786 if (PyErr_Occurred()) SWIG_fail;
40787 }
40788 resultobj = SWIG_From_int(static_cast< int >(result));
40789 return resultobj;
40790 fail:
40791 return NULL;
40792 }
40793
40794
40795 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40796 PyObject *resultobj = 0;
40797 wxWindow *arg1 = (wxWindow *) 0 ;
40798 int arg2 ;
40799 int arg3 ;
40800 wxRect *arg4 = (wxRect *) NULL ;
40801 void *argp1 = 0 ;
40802 int res1 = 0 ;
40803 int val2 ;
40804 int ecode2 = 0 ;
40805 int val3 ;
40806 int ecode3 = 0 ;
40807 void *argp4 = 0 ;
40808 int res4 = 0 ;
40809 PyObject * obj0 = 0 ;
40810 PyObject * obj1 = 0 ;
40811 PyObject * obj2 = 0 ;
40812 PyObject * obj3 = 0 ;
40813 char * kwnames[] = {
40814 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40815 };
40816
40817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40819 if (!SWIG_IsOK(res1)) {
40820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40821 }
40822 arg1 = reinterpret_cast< wxWindow * >(argp1);
40823 ecode2 = SWIG_AsVal_int(obj1, &val2);
40824 if (!SWIG_IsOK(ecode2)) {
40825 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40826 }
40827 arg2 = static_cast< int >(val2);
40828 ecode3 = SWIG_AsVal_int(obj2, &val3);
40829 if (!SWIG_IsOK(ecode3)) {
40830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40831 }
40832 arg3 = static_cast< int >(val3);
40833 if (obj3) {
40834 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40835 if (!SWIG_IsOK(res4)) {
40836 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40837 }
40838 arg4 = reinterpret_cast< wxRect * >(argp4);
40839 }
40840 {
40841 PyThreadState* __tstate = wxPyBeginAllowThreads();
40842 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40843 wxPyEndAllowThreads(__tstate);
40844 if (PyErr_Occurred()) SWIG_fail;
40845 }
40846 resultobj = SWIG_Py_Void();
40847 return resultobj;
40848 fail:
40849 return NULL;
40850 }
40851
40852
40853 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40854 PyObject *resultobj = 0;
40855 wxWindow *arg1 = (wxWindow *) 0 ;
40856 int arg2 ;
40857 bool result;
40858 void *argp1 = 0 ;
40859 int res1 = 0 ;
40860 int val2 ;
40861 int ecode2 = 0 ;
40862 PyObject * obj0 = 0 ;
40863 PyObject * obj1 = 0 ;
40864 char * kwnames[] = {
40865 (char *) "self",(char *) "lines", NULL
40866 };
40867
40868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40870 if (!SWIG_IsOK(res1)) {
40871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40872 }
40873 arg1 = reinterpret_cast< wxWindow * >(argp1);
40874 ecode2 = SWIG_AsVal_int(obj1, &val2);
40875 if (!SWIG_IsOK(ecode2)) {
40876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40877 }
40878 arg2 = static_cast< int >(val2);
40879 {
40880 PyThreadState* __tstate = wxPyBeginAllowThreads();
40881 result = (bool)(arg1)->ScrollLines(arg2);
40882 wxPyEndAllowThreads(__tstate);
40883 if (PyErr_Occurred()) SWIG_fail;
40884 }
40885 {
40886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40887 }
40888 return resultobj;
40889 fail:
40890 return NULL;
40891 }
40892
40893
40894 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40895 PyObject *resultobj = 0;
40896 wxWindow *arg1 = (wxWindow *) 0 ;
40897 int arg2 ;
40898 bool result;
40899 void *argp1 = 0 ;
40900 int res1 = 0 ;
40901 int val2 ;
40902 int ecode2 = 0 ;
40903 PyObject * obj0 = 0 ;
40904 PyObject * obj1 = 0 ;
40905 char * kwnames[] = {
40906 (char *) "self",(char *) "pages", NULL
40907 };
40908
40909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40911 if (!SWIG_IsOK(res1)) {
40912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40913 }
40914 arg1 = reinterpret_cast< wxWindow * >(argp1);
40915 ecode2 = SWIG_AsVal_int(obj1, &val2);
40916 if (!SWIG_IsOK(ecode2)) {
40917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40918 }
40919 arg2 = static_cast< int >(val2);
40920 {
40921 PyThreadState* __tstate = wxPyBeginAllowThreads();
40922 result = (bool)(arg1)->ScrollPages(arg2);
40923 wxPyEndAllowThreads(__tstate);
40924 if (PyErr_Occurred()) SWIG_fail;
40925 }
40926 {
40927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40928 }
40929 return resultobj;
40930 fail:
40931 return NULL;
40932 }
40933
40934
40935 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40936 PyObject *resultobj = 0;
40937 wxWindow *arg1 = (wxWindow *) 0 ;
40938 bool result;
40939 void *argp1 = 0 ;
40940 int res1 = 0 ;
40941 PyObject *swig_obj[1] ;
40942
40943 if (!args) SWIG_fail;
40944 swig_obj[0] = args;
40945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40946 if (!SWIG_IsOK(res1)) {
40947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40948 }
40949 arg1 = reinterpret_cast< wxWindow * >(argp1);
40950 {
40951 PyThreadState* __tstate = wxPyBeginAllowThreads();
40952 result = (bool)(arg1)->LineUp();
40953 wxPyEndAllowThreads(__tstate);
40954 if (PyErr_Occurred()) SWIG_fail;
40955 }
40956 {
40957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40958 }
40959 return resultobj;
40960 fail:
40961 return NULL;
40962 }
40963
40964
40965 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40966 PyObject *resultobj = 0;
40967 wxWindow *arg1 = (wxWindow *) 0 ;
40968 bool result;
40969 void *argp1 = 0 ;
40970 int res1 = 0 ;
40971 PyObject *swig_obj[1] ;
40972
40973 if (!args) SWIG_fail;
40974 swig_obj[0] = args;
40975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40976 if (!SWIG_IsOK(res1)) {
40977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40978 }
40979 arg1 = reinterpret_cast< wxWindow * >(argp1);
40980 {
40981 PyThreadState* __tstate = wxPyBeginAllowThreads();
40982 result = (bool)(arg1)->LineDown();
40983 wxPyEndAllowThreads(__tstate);
40984 if (PyErr_Occurred()) SWIG_fail;
40985 }
40986 {
40987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40988 }
40989 return resultobj;
40990 fail:
40991 return NULL;
40992 }
40993
40994
40995 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40996 PyObject *resultobj = 0;
40997 wxWindow *arg1 = (wxWindow *) 0 ;
40998 bool result;
40999 void *argp1 = 0 ;
41000 int res1 = 0 ;
41001 PyObject *swig_obj[1] ;
41002
41003 if (!args) SWIG_fail;
41004 swig_obj[0] = args;
41005 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41006 if (!SWIG_IsOK(res1)) {
41007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
41008 }
41009 arg1 = reinterpret_cast< wxWindow * >(argp1);
41010 {
41011 PyThreadState* __tstate = wxPyBeginAllowThreads();
41012 result = (bool)(arg1)->PageUp();
41013 wxPyEndAllowThreads(__tstate);
41014 if (PyErr_Occurred()) SWIG_fail;
41015 }
41016 {
41017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41018 }
41019 return resultobj;
41020 fail:
41021 return NULL;
41022 }
41023
41024
41025 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41026 PyObject *resultobj = 0;
41027 wxWindow *arg1 = (wxWindow *) 0 ;
41028 bool result;
41029 void *argp1 = 0 ;
41030 int res1 = 0 ;
41031 PyObject *swig_obj[1] ;
41032
41033 if (!args) SWIG_fail;
41034 swig_obj[0] = args;
41035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41036 if (!SWIG_IsOK(res1)) {
41037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
41038 }
41039 arg1 = reinterpret_cast< wxWindow * >(argp1);
41040 {
41041 PyThreadState* __tstate = wxPyBeginAllowThreads();
41042 result = (bool)(arg1)->PageDown();
41043 wxPyEndAllowThreads(__tstate);
41044 if (PyErr_Occurred()) SWIG_fail;
41045 }
41046 {
41047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41048 }
41049 return resultobj;
41050 fail:
41051 return NULL;
41052 }
41053
41054
41055 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41056 PyObject *resultobj = 0;
41057 wxWindow *arg1 = (wxWindow *) 0 ;
41058 wxString *arg2 = 0 ;
41059 void *argp1 = 0 ;
41060 int res1 = 0 ;
41061 bool temp2 = false ;
41062 PyObject * obj0 = 0 ;
41063 PyObject * obj1 = 0 ;
41064 char * kwnames[] = {
41065 (char *) "self",(char *) "text", NULL
41066 };
41067
41068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
41069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41070 if (!SWIG_IsOK(res1)) {
41071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
41072 }
41073 arg1 = reinterpret_cast< wxWindow * >(argp1);
41074 {
41075 arg2 = wxString_in_helper(obj1);
41076 if (arg2 == NULL) SWIG_fail;
41077 temp2 = true;
41078 }
41079 {
41080 PyThreadState* __tstate = wxPyBeginAllowThreads();
41081 (arg1)->SetHelpText((wxString const &)*arg2);
41082 wxPyEndAllowThreads(__tstate);
41083 if (PyErr_Occurred()) SWIG_fail;
41084 }
41085 resultobj = SWIG_Py_Void();
41086 {
41087 if (temp2)
41088 delete arg2;
41089 }
41090 return resultobj;
41091 fail:
41092 {
41093 if (temp2)
41094 delete arg2;
41095 }
41096 return NULL;
41097 }
41098
41099
41100 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41101 PyObject *resultobj = 0;
41102 wxWindow *arg1 = (wxWindow *) 0 ;
41103 wxString *arg2 = 0 ;
41104 void *argp1 = 0 ;
41105 int res1 = 0 ;
41106 bool temp2 = false ;
41107 PyObject * obj0 = 0 ;
41108 PyObject * obj1 = 0 ;
41109 char * kwnames[] = {
41110 (char *) "self",(char *) "text", NULL
41111 };
41112
41113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
41114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41115 if (!SWIG_IsOK(res1)) {
41116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
41117 }
41118 arg1 = reinterpret_cast< wxWindow * >(argp1);
41119 {
41120 arg2 = wxString_in_helper(obj1);
41121 if (arg2 == NULL) SWIG_fail;
41122 temp2 = true;
41123 }
41124 {
41125 PyThreadState* __tstate = wxPyBeginAllowThreads();
41126 (arg1)->SetHelpTextForId((wxString const &)*arg2);
41127 wxPyEndAllowThreads(__tstate);
41128 if (PyErr_Occurred()) SWIG_fail;
41129 }
41130 resultobj = SWIG_Py_Void();
41131 {
41132 if (temp2)
41133 delete arg2;
41134 }
41135 return resultobj;
41136 fail:
41137 {
41138 if (temp2)
41139 delete arg2;
41140 }
41141 return NULL;
41142 }
41143
41144
41145 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41146 PyObject *resultobj = 0;
41147 wxWindow *arg1 = (wxWindow *) 0 ;
41148 wxPoint *arg2 = 0 ;
41149 wxHelpEvent::Origin arg3 ;
41150 wxString result;
41151 void *argp1 = 0 ;
41152 int res1 = 0 ;
41153 wxPoint temp2 ;
41154 void *argp3 ;
41155 int res3 = 0 ;
41156 PyObject * obj0 = 0 ;
41157 PyObject * obj1 = 0 ;
41158 PyObject * obj2 = 0 ;
41159 char * kwnames[] = {
41160 (char *) "self",(char *) "pt",(char *) "origin", NULL
41161 };
41162
41163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41165 if (!SWIG_IsOK(res1)) {
41166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
41167 }
41168 arg1 = reinterpret_cast< wxWindow * >(argp1);
41169 {
41170 arg2 = &temp2;
41171 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
41172 }
41173 {
41174 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
41175 if (!SWIG_IsOK(res3)) {
41176 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41177 }
41178 if (!argp3) {
41179 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
41180 } else {
41181 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
41182 arg3 = *temp;
41183 if (SWIG_IsNewObj(res3)) delete temp;
41184 }
41185 }
41186 {
41187 PyThreadState* __tstate = wxPyBeginAllowThreads();
41188 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
41189 wxPyEndAllowThreads(__tstate);
41190 if (PyErr_Occurred()) SWIG_fail;
41191 }
41192 {
41193 #if wxUSE_UNICODE
41194 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41195 #else
41196 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41197 #endif
41198 }
41199 return resultobj;
41200 fail:
41201 return NULL;
41202 }
41203
41204
41205 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41206 PyObject *resultobj = 0;
41207 wxWindow *arg1 = (wxWindow *) 0 ;
41208 wxString result;
41209 void *argp1 = 0 ;
41210 int res1 = 0 ;
41211 PyObject *swig_obj[1] ;
41212
41213 if (!args) SWIG_fail;
41214 swig_obj[0] = args;
41215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41216 if (!SWIG_IsOK(res1)) {
41217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
41218 }
41219 arg1 = reinterpret_cast< wxWindow * >(argp1);
41220 {
41221 PyThreadState* __tstate = wxPyBeginAllowThreads();
41222 result = ((wxWindow const *)arg1)->GetHelpText();
41223 wxPyEndAllowThreads(__tstate);
41224 if (PyErr_Occurred()) SWIG_fail;
41225 }
41226 {
41227 #if wxUSE_UNICODE
41228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41229 #else
41230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41231 #endif
41232 }
41233 return resultobj;
41234 fail:
41235 return NULL;
41236 }
41237
41238
41239 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41240 PyObject *resultobj = 0;
41241 wxWindow *arg1 = (wxWindow *) 0 ;
41242 wxString *arg2 = 0 ;
41243 void *argp1 = 0 ;
41244 int res1 = 0 ;
41245 bool temp2 = false ;
41246 PyObject * obj0 = 0 ;
41247 PyObject * obj1 = 0 ;
41248 char * kwnames[] = {
41249 (char *) "self",(char *) "tip", NULL
41250 };
41251
41252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
41253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41254 if (!SWIG_IsOK(res1)) {
41255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
41256 }
41257 arg1 = reinterpret_cast< wxWindow * >(argp1);
41258 {
41259 arg2 = wxString_in_helper(obj1);
41260 if (arg2 == NULL) SWIG_fail;
41261 temp2 = true;
41262 }
41263 {
41264 PyThreadState* __tstate = wxPyBeginAllowThreads();
41265 (arg1)->SetToolTip((wxString const &)*arg2);
41266 wxPyEndAllowThreads(__tstate);
41267 if (PyErr_Occurred()) SWIG_fail;
41268 }
41269 resultobj = SWIG_Py_Void();
41270 {
41271 if (temp2)
41272 delete arg2;
41273 }
41274 return resultobj;
41275 fail:
41276 {
41277 if (temp2)
41278 delete arg2;
41279 }
41280 return NULL;
41281 }
41282
41283
41284 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41285 PyObject *resultobj = 0;
41286 wxWindow *arg1 = (wxWindow *) 0 ;
41287 wxToolTip *arg2 = (wxToolTip *) 0 ;
41288 void *argp1 = 0 ;
41289 int res1 = 0 ;
41290 int res2 = 0 ;
41291 PyObject * obj0 = 0 ;
41292 PyObject * obj1 = 0 ;
41293 char * kwnames[] = {
41294 (char *) "self",(char *) "tip", NULL
41295 };
41296
41297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
41298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41299 if (!SWIG_IsOK(res1)) {
41300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
41301 }
41302 arg1 = reinterpret_cast< wxWindow * >(argp1);
41303 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
41304 if (!SWIG_IsOK(res2)) {
41305 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
41306 }
41307 {
41308 PyThreadState* __tstate = wxPyBeginAllowThreads();
41309 (arg1)->SetToolTip(arg2);
41310 wxPyEndAllowThreads(__tstate);
41311 if (PyErr_Occurred()) SWIG_fail;
41312 }
41313 resultobj = SWIG_Py_Void();
41314 return resultobj;
41315 fail:
41316 return NULL;
41317 }
41318
41319
41320 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41321 PyObject *resultobj = 0;
41322 wxWindow *arg1 = (wxWindow *) 0 ;
41323 wxToolTip *result = 0 ;
41324 void *argp1 = 0 ;
41325 int res1 = 0 ;
41326 PyObject *swig_obj[1] ;
41327
41328 if (!args) SWIG_fail;
41329 swig_obj[0] = args;
41330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41331 if (!SWIG_IsOK(res1)) {
41332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
41333 }
41334 arg1 = reinterpret_cast< wxWindow * >(argp1);
41335 {
41336 PyThreadState* __tstate = wxPyBeginAllowThreads();
41337 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
41338 wxPyEndAllowThreads(__tstate);
41339 if (PyErr_Occurred()) SWIG_fail;
41340 }
41341 {
41342 resultobj = wxPyMake_wxObject(result, (bool)0);
41343 }
41344 return resultobj;
41345 fail:
41346 return NULL;
41347 }
41348
41349
41350 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41351 PyObject *resultobj = 0;
41352 wxWindow *arg1 = (wxWindow *) 0 ;
41353 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
41354 void *argp1 = 0 ;
41355 int res1 = 0 ;
41356 int res2 = 0 ;
41357 PyObject * obj0 = 0 ;
41358 PyObject * obj1 = 0 ;
41359 char * kwnames[] = {
41360 (char *) "self",(char *) "dropTarget", NULL
41361 };
41362
41363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
41364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41365 if (!SWIG_IsOK(res1)) {
41366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
41367 }
41368 arg1 = reinterpret_cast< wxWindow * >(argp1);
41369 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
41370 if (!SWIG_IsOK(res2)) {
41371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
41372 }
41373 {
41374 PyThreadState* __tstate = wxPyBeginAllowThreads();
41375 (arg1)->SetDropTarget(arg2);
41376 wxPyEndAllowThreads(__tstate);
41377 if (PyErr_Occurred()) SWIG_fail;
41378 }
41379 resultobj = SWIG_Py_Void();
41380 return resultobj;
41381 fail:
41382 return NULL;
41383 }
41384
41385
41386 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41387 PyObject *resultobj = 0;
41388 wxWindow *arg1 = (wxWindow *) 0 ;
41389 wxPyDropTarget *result = 0 ;
41390 void *argp1 = 0 ;
41391 int res1 = 0 ;
41392 PyObject *swig_obj[1] ;
41393
41394 if (!args) SWIG_fail;
41395 swig_obj[0] = args;
41396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41397 if (!SWIG_IsOK(res1)) {
41398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
41399 }
41400 arg1 = reinterpret_cast< wxWindow * >(argp1);
41401 {
41402 PyThreadState* __tstate = wxPyBeginAllowThreads();
41403 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
41404 wxPyEndAllowThreads(__tstate);
41405 if (PyErr_Occurred()) SWIG_fail;
41406 }
41407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
41408 return resultobj;
41409 fail:
41410 return NULL;
41411 }
41412
41413
41414 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41415 PyObject *resultobj = 0;
41416 wxWindow *arg1 = (wxWindow *) 0 ;
41417 bool arg2 ;
41418 void *argp1 = 0 ;
41419 int res1 = 0 ;
41420 bool val2 ;
41421 int ecode2 = 0 ;
41422 PyObject * obj0 = 0 ;
41423 PyObject * obj1 = 0 ;
41424 char * kwnames[] = {
41425 (char *) "self",(char *) "accept", NULL
41426 };
41427
41428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
41429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41430 if (!SWIG_IsOK(res1)) {
41431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
41432 }
41433 arg1 = reinterpret_cast< wxWindow * >(argp1);
41434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41435 if (!SWIG_IsOK(ecode2)) {
41436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
41437 }
41438 arg2 = static_cast< bool >(val2);
41439 {
41440 PyThreadState* __tstate = wxPyBeginAllowThreads();
41441 wxWindow_DragAcceptFiles(arg1,arg2);
41442 wxPyEndAllowThreads(__tstate);
41443 if (PyErr_Occurred()) SWIG_fail;
41444 }
41445 resultobj = SWIG_Py_Void();
41446 return resultobj;
41447 fail:
41448 return NULL;
41449 }
41450
41451
41452 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41453 PyObject *resultobj = 0;
41454 wxWindow *arg1 = (wxWindow *) 0 ;
41455 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
41456 void *argp1 = 0 ;
41457 int res1 = 0 ;
41458 int res2 = 0 ;
41459 PyObject * obj0 = 0 ;
41460 PyObject * obj1 = 0 ;
41461 char * kwnames[] = {
41462 (char *) "self",(char *) "constraints", NULL
41463 };
41464
41465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
41466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41467 if (!SWIG_IsOK(res1)) {
41468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
41469 }
41470 arg1 = reinterpret_cast< wxWindow * >(argp1);
41471 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
41472 if (!SWIG_IsOK(res2)) {
41473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
41474 }
41475 {
41476 PyThreadState* __tstate = wxPyBeginAllowThreads();
41477 (arg1)->SetConstraints(arg2);
41478 wxPyEndAllowThreads(__tstate);
41479 if (PyErr_Occurred()) SWIG_fail;
41480 }
41481 resultobj = SWIG_Py_Void();
41482 return resultobj;
41483 fail:
41484 return NULL;
41485 }
41486
41487
41488 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41489 PyObject *resultobj = 0;
41490 wxWindow *arg1 = (wxWindow *) 0 ;
41491 wxLayoutConstraints *result = 0 ;
41492 void *argp1 = 0 ;
41493 int res1 = 0 ;
41494 PyObject *swig_obj[1] ;
41495
41496 if (!args) SWIG_fail;
41497 swig_obj[0] = args;
41498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41499 if (!SWIG_IsOK(res1)) {
41500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
41501 }
41502 arg1 = reinterpret_cast< wxWindow * >(argp1);
41503 {
41504 PyThreadState* __tstate = wxPyBeginAllowThreads();
41505 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
41506 wxPyEndAllowThreads(__tstate);
41507 if (PyErr_Occurred()) SWIG_fail;
41508 }
41509 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
41510 return resultobj;
41511 fail:
41512 return NULL;
41513 }
41514
41515
41516 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41517 PyObject *resultobj = 0;
41518 wxWindow *arg1 = (wxWindow *) 0 ;
41519 bool arg2 ;
41520 void *argp1 = 0 ;
41521 int res1 = 0 ;
41522 bool val2 ;
41523 int ecode2 = 0 ;
41524 PyObject * obj0 = 0 ;
41525 PyObject * obj1 = 0 ;
41526 char * kwnames[] = {
41527 (char *) "self",(char *) "autoLayout", NULL
41528 };
41529
41530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
41531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41532 if (!SWIG_IsOK(res1)) {
41533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
41534 }
41535 arg1 = reinterpret_cast< wxWindow * >(argp1);
41536 ecode2 = SWIG_AsVal_bool(obj1, &val2);
41537 if (!SWIG_IsOK(ecode2)) {
41538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
41539 }
41540 arg2 = static_cast< bool >(val2);
41541 {
41542 PyThreadState* __tstate = wxPyBeginAllowThreads();
41543 (arg1)->SetAutoLayout(arg2);
41544 wxPyEndAllowThreads(__tstate);
41545 if (PyErr_Occurred()) SWIG_fail;
41546 }
41547 resultobj = SWIG_Py_Void();
41548 return resultobj;
41549 fail:
41550 return NULL;
41551 }
41552
41553
41554 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41555 PyObject *resultobj = 0;
41556 wxWindow *arg1 = (wxWindow *) 0 ;
41557 bool result;
41558 void *argp1 = 0 ;
41559 int res1 = 0 ;
41560 PyObject *swig_obj[1] ;
41561
41562 if (!args) SWIG_fail;
41563 swig_obj[0] = args;
41564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41565 if (!SWIG_IsOK(res1)) {
41566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
41567 }
41568 arg1 = reinterpret_cast< wxWindow * >(argp1);
41569 {
41570 PyThreadState* __tstate = wxPyBeginAllowThreads();
41571 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
41572 wxPyEndAllowThreads(__tstate);
41573 if (PyErr_Occurred()) SWIG_fail;
41574 }
41575 {
41576 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41577 }
41578 return resultobj;
41579 fail:
41580 return NULL;
41581 }
41582
41583
41584 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41585 PyObject *resultobj = 0;
41586 wxWindow *arg1 = (wxWindow *) 0 ;
41587 bool result;
41588 void *argp1 = 0 ;
41589 int res1 = 0 ;
41590 PyObject *swig_obj[1] ;
41591
41592 if (!args) SWIG_fail;
41593 swig_obj[0] = args;
41594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41595 if (!SWIG_IsOK(res1)) {
41596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
41597 }
41598 arg1 = reinterpret_cast< wxWindow * >(argp1);
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 result = (bool)(arg1)->Layout();
41602 wxPyEndAllowThreads(__tstate);
41603 if (PyErr_Occurred()) SWIG_fail;
41604 }
41605 {
41606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41607 }
41608 return resultobj;
41609 fail:
41610 return NULL;
41611 }
41612
41613
41614 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj = 0;
41616 wxWindow *arg1 = (wxWindow *) 0 ;
41617 wxSizer *arg2 = (wxSizer *) 0 ;
41618 bool arg3 = (bool) true ;
41619 void *argp1 = 0 ;
41620 int res1 = 0 ;
41621 int res2 = 0 ;
41622 bool val3 ;
41623 int ecode3 = 0 ;
41624 PyObject * obj0 = 0 ;
41625 PyObject * obj1 = 0 ;
41626 PyObject * obj2 = 0 ;
41627 char * kwnames[] = {
41628 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41629 };
41630
41631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41633 if (!SWIG_IsOK(res1)) {
41634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41635 }
41636 arg1 = reinterpret_cast< wxWindow * >(argp1);
41637 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41638 if (!SWIG_IsOK(res2)) {
41639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41640 }
41641 if (obj2) {
41642 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41643 if (!SWIG_IsOK(ecode3)) {
41644 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
41645 }
41646 arg3 = static_cast< bool >(val3);
41647 }
41648 {
41649 PyThreadState* __tstate = wxPyBeginAllowThreads();
41650 (arg1)->SetSizer(arg2,arg3);
41651 wxPyEndAllowThreads(__tstate);
41652 if (PyErr_Occurred()) SWIG_fail;
41653 }
41654 resultobj = SWIG_Py_Void();
41655 return resultobj;
41656 fail:
41657 return NULL;
41658 }
41659
41660
41661 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41662 PyObject *resultobj = 0;
41663 wxWindow *arg1 = (wxWindow *) 0 ;
41664 wxSizer *arg2 = (wxSizer *) 0 ;
41665 bool arg3 = (bool) true ;
41666 void *argp1 = 0 ;
41667 int res1 = 0 ;
41668 int res2 = 0 ;
41669 bool val3 ;
41670 int ecode3 = 0 ;
41671 PyObject * obj0 = 0 ;
41672 PyObject * obj1 = 0 ;
41673 PyObject * obj2 = 0 ;
41674 char * kwnames[] = {
41675 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41676 };
41677
41678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41680 if (!SWIG_IsOK(res1)) {
41681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41682 }
41683 arg1 = reinterpret_cast< wxWindow * >(argp1);
41684 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41685 if (!SWIG_IsOK(res2)) {
41686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41687 }
41688 if (obj2) {
41689 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41690 if (!SWIG_IsOK(ecode3)) {
41691 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41692 }
41693 arg3 = static_cast< bool >(val3);
41694 }
41695 {
41696 PyThreadState* __tstate = wxPyBeginAllowThreads();
41697 (arg1)->SetSizerAndFit(arg2,arg3);
41698 wxPyEndAllowThreads(__tstate);
41699 if (PyErr_Occurred()) SWIG_fail;
41700 }
41701 resultobj = SWIG_Py_Void();
41702 return resultobj;
41703 fail:
41704 return NULL;
41705 }
41706
41707
41708 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41709 PyObject *resultobj = 0;
41710 wxWindow *arg1 = (wxWindow *) 0 ;
41711 wxSizer *result = 0 ;
41712 void *argp1 = 0 ;
41713 int res1 = 0 ;
41714 PyObject *swig_obj[1] ;
41715
41716 if (!args) SWIG_fail;
41717 swig_obj[0] = args;
41718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41719 if (!SWIG_IsOK(res1)) {
41720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41721 }
41722 arg1 = reinterpret_cast< wxWindow * >(argp1);
41723 {
41724 PyThreadState* __tstate = wxPyBeginAllowThreads();
41725 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41726 wxPyEndAllowThreads(__tstate);
41727 if (PyErr_Occurred()) SWIG_fail;
41728 }
41729 {
41730 resultobj = wxPyMake_wxObject(result, (bool)0);
41731 }
41732 return resultobj;
41733 fail:
41734 return NULL;
41735 }
41736
41737
41738 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41739 PyObject *resultobj = 0;
41740 wxWindow *arg1 = (wxWindow *) 0 ;
41741 wxSizer *arg2 = (wxSizer *) 0 ;
41742 void *argp1 = 0 ;
41743 int res1 = 0 ;
41744 void *argp2 = 0 ;
41745 int res2 = 0 ;
41746 PyObject * obj0 = 0 ;
41747 PyObject * obj1 = 0 ;
41748 char * kwnames[] = {
41749 (char *) "self",(char *) "sizer", NULL
41750 };
41751
41752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41754 if (!SWIG_IsOK(res1)) {
41755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41756 }
41757 arg1 = reinterpret_cast< wxWindow * >(argp1);
41758 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41759 if (!SWIG_IsOK(res2)) {
41760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41761 }
41762 arg2 = reinterpret_cast< wxSizer * >(argp2);
41763 {
41764 PyThreadState* __tstate = wxPyBeginAllowThreads();
41765 (arg1)->SetContainingSizer(arg2);
41766 wxPyEndAllowThreads(__tstate);
41767 if (PyErr_Occurred()) SWIG_fail;
41768 }
41769 resultobj = SWIG_Py_Void();
41770 return resultobj;
41771 fail:
41772 return NULL;
41773 }
41774
41775
41776 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41777 PyObject *resultobj = 0;
41778 wxWindow *arg1 = (wxWindow *) 0 ;
41779 wxSizer *result = 0 ;
41780 void *argp1 = 0 ;
41781 int res1 = 0 ;
41782 PyObject *swig_obj[1] ;
41783
41784 if (!args) SWIG_fail;
41785 swig_obj[0] = args;
41786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41787 if (!SWIG_IsOK(res1)) {
41788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41789 }
41790 arg1 = reinterpret_cast< wxWindow * >(argp1);
41791 {
41792 PyThreadState* __tstate = wxPyBeginAllowThreads();
41793 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41794 wxPyEndAllowThreads(__tstate);
41795 if (PyErr_Occurred()) SWIG_fail;
41796 }
41797 {
41798 resultobj = wxPyMake_wxObject(result, (bool)0);
41799 }
41800 return resultobj;
41801 fail:
41802 return NULL;
41803 }
41804
41805
41806 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41807 PyObject *resultobj = 0;
41808 wxWindow *arg1 = (wxWindow *) 0 ;
41809 void *argp1 = 0 ;
41810 int res1 = 0 ;
41811 PyObject *swig_obj[1] ;
41812
41813 if (!args) SWIG_fail;
41814 swig_obj[0] = args;
41815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41816 if (!SWIG_IsOK(res1)) {
41817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41818 }
41819 arg1 = reinterpret_cast< wxWindow * >(argp1);
41820 {
41821 PyThreadState* __tstate = wxPyBeginAllowThreads();
41822 (arg1)->InheritAttributes();
41823 wxPyEndAllowThreads(__tstate);
41824 if (PyErr_Occurred()) SWIG_fail;
41825 }
41826 resultobj = SWIG_Py_Void();
41827 return resultobj;
41828 fail:
41829 return NULL;
41830 }
41831
41832
41833 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41834 PyObject *resultobj = 0;
41835 wxWindow *arg1 = (wxWindow *) 0 ;
41836 bool result;
41837 void *argp1 = 0 ;
41838 int res1 = 0 ;
41839 PyObject *swig_obj[1] ;
41840
41841 if (!args) SWIG_fail;
41842 swig_obj[0] = args;
41843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41844 if (!SWIG_IsOK(res1)) {
41845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41846 }
41847 arg1 = reinterpret_cast< wxWindow * >(argp1);
41848 {
41849 PyThreadState* __tstate = wxPyBeginAllowThreads();
41850 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41851 wxPyEndAllowThreads(__tstate);
41852 if (PyErr_Occurred()) SWIG_fail;
41853 }
41854 {
41855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41856 }
41857 return resultobj;
41858 fail:
41859 return NULL;
41860 }
41861
41862
41863 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41864 PyObject *resultobj = 0;
41865 wxWindow *arg1 = (wxWindow *) 0 ;
41866 bool result;
41867 void *argp1 = 0 ;
41868 int res1 = 0 ;
41869 PyObject *swig_obj[1] ;
41870
41871 if (!args) SWIG_fail;
41872 swig_obj[0] = args;
41873 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41874 if (!SWIG_IsOK(res1)) {
41875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41876 }
41877 arg1 = reinterpret_cast< wxWindow * >(argp1);
41878 {
41879 PyThreadState* __tstate = wxPyBeginAllowThreads();
41880 result = (bool)(arg1)->CanSetTransparent();
41881 wxPyEndAllowThreads(__tstate);
41882 if (PyErr_Occurred()) SWIG_fail;
41883 }
41884 {
41885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41886 }
41887 return resultobj;
41888 fail:
41889 return NULL;
41890 }
41891
41892
41893 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41894 PyObject *resultobj = 0;
41895 wxWindow *arg1 = (wxWindow *) 0 ;
41896 byte arg2 ;
41897 bool result;
41898 void *argp1 = 0 ;
41899 int res1 = 0 ;
41900 unsigned char val2 ;
41901 int ecode2 = 0 ;
41902 PyObject * obj0 = 0 ;
41903 PyObject * obj1 = 0 ;
41904 char * kwnames[] = {
41905 (char *) "self",(char *) "alpha", NULL
41906 };
41907
41908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41910 if (!SWIG_IsOK(res1)) {
41911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41912 }
41913 arg1 = reinterpret_cast< wxWindow * >(argp1);
41914 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41915 if (!SWIG_IsOK(ecode2)) {
41916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41917 }
41918 arg2 = static_cast< byte >(val2);
41919 {
41920 PyThreadState* __tstate = wxPyBeginAllowThreads();
41921 result = (bool)(arg1)->SetTransparent(arg2);
41922 wxPyEndAllowThreads(__tstate);
41923 if (PyErr_Occurred()) SWIG_fail;
41924 }
41925 {
41926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41927 }
41928 return resultobj;
41929 fail:
41930 return NULL;
41931 }
41932
41933
41934 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41935 PyObject *obj;
41936 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41937 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41938 return SWIG_Py_Void();
41939 }
41940
41941 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41942 return SWIG_Python_InitShadowInstance(args);
41943 }
41944
41945 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41946 PyObject *resultobj = 0;
41947 long arg1 ;
41948 wxWindow *arg2 = (wxWindow *) NULL ;
41949 wxWindow *result = 0 ;
41950 long val1 ;
41951 int ecode1 = 0 ;
41952 void *argp2 = 0 ;
41953 int res2 = 0 ;
41954 PyObject * obj0 = 0 ;
41955 PyObject * obj1 = 0 ;
41956 char * kwnames[] = {
41957 (char *) "id",(char *) "parent", NULL
41958 };
41959
41960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41961 ecode1 = SWIG_AsVal_long(obj0, &val1);
41962 if (!SWIG_IsOK(ecode1)) {
41963 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41964 }
41965 arg1 = static_cast< long >(val1);
41966 if (obj1) {
41967 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41968 if (!SWIG_IsOK(res2)) {
41969 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41970 }
41971 arg2 = reinterpret_cast< wxWindow * >(argp2);
41972 }
41973 {
41974 if (!wxPyCheckForApp()) SWIG_fail;
41975 PyThreadState* __tstate = wxPyBeginAllowThreads();
41976 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41977 wxPyEndAllowThreads(__tstate);
41978 if (PyErr_Occurred()) SWIG_fail;
41979 }
41980 {
41981 resultobj = wxPyMake_wxObject(result, 0);
41982 }
41983 return resultobj;
41984 fail:
41985 return NULL;
41986 }
41987
41988
41989 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41990 PyObject *resultobj = 0;
41991 wxString *arg1 = 0 ;
41992 wxWindow *arg2 = (wxWindow *) NULL ;
41993 wxWindow *result = 0 ;
41994 bool temp1 = false ;
41995 void *argp2 = 0 ;
41996 int res2 = 0 ;
41997 PyObject * obj0 = 0 ;
41998 PyObject * obj1 = 0 ;
41999 char * kwnames[] = {
42000 (char *) "name",(char *) "parent", NULL
42001 };
42002
42003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
42004 {
42005 arg1 = wxString_in_helper(obj0);
42006 if (arg1 == NULL) SWIG_fail;
42007 temp1 = true;
42008 }
42009 if (obj1) {
42010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42011 if (!SWIG_IsOK(res2)) {
42012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
42013 }
42014 arg2 = reinterpret_cast< wxWindow * >(argp2);
42015 }
42016 {
42017 if (!wxPyCheckForApp()) SWIG_fail;
42018 PyThreadState* __tstate = wxPyBeginAllowThreads();
42019 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
42020 wxPyEndAllowThreads(__tstate);
42021 if (PyErr_Occurred()) SWIG_fail;
42022 }
42023 {
42024 resultobj = wxPyMake_wxObject(result, 0);
42025 }
42026 {
42027 if (temp1)
42028 delete arg1;
42029 }
42030 return resultobj;
42031 fail:
42032 {
42033 if (temp1)
42034 delete arg1;
42035 }
42036 return NULL;
42037 }
42038
42039
42040 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42041 PyObject *resultobj = 0;
42042 wxString *arg1 = 0 ;
42043 wxWindow *arg2 = (wxWindow *) NULL ;
42044 wxWindow *result = 0 ;
42045 bool temp1 = false ;
42046 void *argp2 = 0 ;
42047 int res2 = 0 ;
42048 PyObject * obj0 = 0 ;
42049 PyObject * obj1 = 0 ;
42050 char * kwnames[] = {
42051 (char *) "label",(char *) "parent", NULL
42052 };
42053
42054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
42055 {
42056 arg1 = wxString_in_helper(obj0);
42057 if (arg1 == NULL) SWIG_fail;
42058 temp1 = true;
42059 }
42060 if (obj1) {
42061 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42062 if (!SWIG_IsOK(res2)) {
42063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
42064 }
42065 arg2 = reinterpret_cast< wxWindow * >(argp2);
42066 }
42067 {
42068 if (!wxPyCheckForApp()) SWIG_fail;
42069 PyThreadState* __tstate = wxPyBeginAllowThreads();
42070 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
42071 wxPyEndAllowThreads(__tstate);
42072 if (PyErr_Occurred()) SWIG_fail;
42073 }
42074 {
42075 resultobj = wxPyMake_wxObject(result, 0);
42076 }
42077 {
42078 if (temp1)
42079 delete arg1;
42080 }
42081 return resultobj;
42082 fail:
42083 {
42084 if (temp1)
42085 delete arg1;
42086 }
42087 return NULL;
42088 }
42089
42090
42091 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42092 PyObject *resultobj = 0;
42093 wxWindow *arg1 = (wxWindow *) 0 ;
42094 unsigned long arg2 ;
42095 wxWindow *result = 0 ;
42096 void *argp1 = 0 ;
42097 int res1 = 0 ;
42098 unsigned long val2 ;
42099 int ecode2 = 0 ;
42100 PyObject * obj0 = 0 ;
42101 PyObject * obj1 = 0 ;
42102 char * kwnames[] = {
42103 (char *) "parent",(char *) "_hWnd", NULL
42104 };
42105
42106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
42107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
42108 if (!SWIG_IsOK(res1)) {
42109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
42110 }
42111 arg1 = reinterpret_cast< wxWindow * >(argp1);
42112 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
42113 if (!SWIG_IsOK(ecode2)) {
42114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
42115 }
42116 arg2 = static_cast< unsigned long >(val2);
42117 {
42118 if (!wxPyCheckForApp()) SWIG_fail;
42119 PyThreadState* __tstate = wxPyBeginAllowThreads();
42120 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
42121 wxPyEndAllowThreads(__tstate);
42122 if (PyErr_Occurred()) SWIG_fail;
42123 }
42124 {
42125 resultobj = wxPyMake_wxObject(result, 0);
42126 }
42127 return resultobj;
42128 fail:
42129 return NULL;
42130 }
42131
42132
42133 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42134 PyObject *resultobj = 0;
42135 PyObject *result = 0 ;
42136
42137 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
42138 {
42139 PyThreadState* __tstate = wxPyBeginAllowThreads();
42140 result = (PyObject *)GetTopLevelWindows();
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 resultobj = result;
42145 return resultobj;
42146 fail:
42147 return NULL;
42148 }
42149
42150
42151 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42152 PyObject *resultobj = 0;
42153 wxValidator *result = 0 ;
42154
42155 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
42156 {
42157 PyThreadState* __tstate = wxPyBeginAllowThreads();
42158 result = (wxValidator *)new wxValidator();
42159 wxPyEndAllowThreads(__tstate);
42160 if (PyErr_Occurred()) SWIG_fail;
42161 }
42162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
42163 return resultobj;
42164 fail:
42165 return NULL;
42166 }
42167
42168
42169 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42170 PyObject *resultobj = 0;
42171 wxValidator *arg1 = (wxValidator *) 0 ;
42172 wxValidator *result = 0 ;
42173 void *argp1 = 0 ;
42174 int res1 = 0 ;
42175 PyObject *swig_obj[1] ;
42176
42177 if (!args) SWIG_fail;
42178 swig_obj[0] = args;
42179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42180 if (!SWIG_IsOK(res1)) {
42181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
42182 }
42183 arg1 = reinterpret_cast< wxValidator * >(argp1);
42184 {
42185 PyThreadState* __tstate = wxPyBeginAllowThreads();
42186 result = (wxValidator *)(arg1)->Clone();
42187 wxPyEndAllowThreads(__tstate);
42188 if (PyErr_Occurred()) SWIG_fail;
42189 }
42190 {
42191 resultobj = wxPyMake_wxObject(result, 0);
42192 }
42193 return resultobj;
42194 fail:
42195 return NULL;
42196 }
42197
42198
42199 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42200 PyObject *resultobj = 0;
42201 wxValidator *arg1 = (wxValidator *) 0 ;
42202 wxWindow *arg2 = (wxWindow *) 0 ;
42203 bool result;
42204 void *argp1 = 0 ;
42205 int res1 = 0 ;
42206 void *argp2 = 0 ;
42207 int res2 = 0 ;
42208 PyObject * obj0 = 0 ;
42209 PyObject * obj1 = 0 ;
42210 char * kwnames[] = {
42211 (char *) "self",(char *) "parent", NULL
42212 };
42213
42214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
42215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42216 if (!SWIG_IsOK(res1)) {
42217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
42218 }
42219 arg1 = reinterpret_cast< wxValidator * >(argp1);
42220 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42221 if (!SWIG_IsOK(res2)) {
42222 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
42223 }
42224 arg2 = reinterpret_cast< wxWindow * >(argp2);
42225 {
42226 PyThreadState* __tstate = wxPyBeginAllowThreads();
42227 result = (bool)(arg1)->Validate(arg2);
42228 wxPyEndAllowThreads(__tstate);
42229 if (PyErr_Occurred()) SWIG_fail;
42230 }
42231 {
42232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42233 }
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42241 PyObject *resultobj = 0;
42242 wxValidator *arg1 = (wxValidator *) 0 ;
42243 bool result;
42244 void *argp1 = 0 ;
42245 int res1 = 0 ;
42246 PyObject *swig_obj[1] ;
42247
42248 if (!args) SWIG_fail;
42249 swig_obj[0] = args;
42250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42251 if (!SWIG_IsOK(res1)) {
42252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42253 }
42254 arg1 = reinterpret_cast< wxValidator * >(argp1);
42255 {
42256 PyThreadState* __tstate = wxPyBeginAllowThreads();
42257 result = (bool)(arg1)->TransferToWindow();
42258 wxPyEndAllowThreads(__tstate);
42259 if (PyErr_Occurred()) SWIG_fail;
42260 }
42261 {
42262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42263 }
42264 return resultobj;
42265 fail:
42266 return NULL;
42267 }
42268
42269
42270 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42271 PyObject *resultobj = 0;
42272 wxValidator *arg1 = (wxValidator *) 0 ;
42273 bool result;
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_wxValidator, 0 | 0 );
42281 if (!SWIG_IsOK(res1)) {
42282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42283 }
42284 arg1 = reinterpret_cast< wxValidator * >(argp1);
42285 {
42286 PyThreadState* __tstate = wxPyBeginAllowThreads();
42287 result = (bool)(arg1)->TransferFromWindow();
42288 wxPyEndAllowThreads(__tstate);
42289 if (PyErr_Occurred()) SWIG_fail;
42290 }
42291 {
42292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42293 }
42294 return resultobj;
42295 fail:
42296 return NULL;
42297 }
42298
42299
42300 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42301 PyObject *resultobj = 0;
42302 wxValidator *arg1 = (wxValidator *) 0 ;
42303 wxWindow *result = 0 ;
42304 void *argp1 = 0 ;
42305 int res1 = 0 ;
42306 PyObject *swig_obj[1] ;
42307
42308 if (!args) SWIG_fail;
42309 swig_obj[0] = args;
42310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42311 if (!SWIG_IsOK(res1)) {
42312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42313 }
42314 arg1 = reinterpret_cast< wxValidator * >(argp1);
42315 {
42316 PyThreadState* __tstate = wxPyBeginAllowThreads();
42317 result = (wxWindow *)(arg1)->GetWindow();
42318 wxPyEndAllowThreads(__tstate);
42319 if (PyErr_Occurred()) SWIG_fail;
42320 }
42321 {
42322 resultobj = wxPyMake_wxObject(result, 0);
42323 }
42324 return resultobj;
42325 fail:
42326 return NULL;
42327 }
42328
42329
42330 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42331 PyObject *resultobj = 0;
42332 wxValidator *arg1 = (wxValidator *) 0 ;
42333 wxWindow *arg2 = (wxWindow *) 0 ;
42334 void *argp1 = 0 ;
42335 int res1 = 0 ;
42336 void *argp2 = 0 ;
42337 int res2 = 0 ;
42338 PyObject * obj0 = 0 ;
42339 PyObject * obj1 = 0 ;
42340 char * kwnames[] = {
42341 (char *) "self",(char *) "window", NULL
42342 };
42343
42344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
42345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
42346 if (!SWIG_IsOK(res1)) {
42347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
42348 }
42349 arg1 = reinterpret_cast< wxValidator * >(argp1);
42350 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
42351 if (!SWIG_IsOK(res2)) {
42352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
42353 }
42354 arg2 = reinterpret_cast< wxWindow * >(argp2);
42355 {
42356 PyThreadState* __tstate = wxPyBeginAllowThreads();
42357 (arg1)->SetWindow(arg2);
42358 wxPyEndAllowThreads(__tstate);
42359 if (PyErr_Occurred()) SWIG_fail;
42360 }
42361 resultobj = SWIG_Py_Void();
42362 return resultobj;
42363 fail:
42364 return NULL;
42365 }
42366
42367
42368 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42369 PyObject *resultobj = 0;
42370 bool result;
42371
42372 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
42373 {
42374 PyThreadState* __tstate = wxPyBeginAllowThreads();
42375 result = (bool)wxValidator::IsSilent();
42376 wxPyEndAllowThreads(__tstate);
42377 if (PyErr_Occurred()) SWIG_fail;
42378 }
42379 {
42380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42381 }
42382 return resultobj;
42383 fail:
42384 return NULL;
42385 }
42386
42387
42388 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42389 PyObject *resultobj = 0;
42390 int arg1 = (int) true ;
42391 int val1 ;
42392 int ecode1 = 0 ;
42393 PyObject * obj0 = 0 ;
42394 char * kwnames[] = {
42395 (char *) "doIt", NULL
42396 };
42397
42398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
42399 if (obj0) {
42400 ecode1 = SWIG_AsVal_int(obj0, &val1);
42401 if (!SWIG_IsOK(ecode1)) {
42402 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
42403 }
42404 arg1 = static_cast< int >(val1);
42405 }
42406 {
42407 PyThreadState* __tstate = wxPyBeginAllowThreads();
42408 wxValidator::SetBellOnError(arg1);
42409 wxPyEndAllowThreads(__tstate);
42410 if (PyErr_Occurred()) SWIG_fail;
42411 }
42412 resultobj = SWIG_Py_Void();
42413 return resultobj;
42414 fail:
42415 return NULL;
42416 }
42417
42418
42419 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42420 PyObject *obj;
42421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42422 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
42423 return SWIG_Py_Void();
42424 }
42425
42426 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42427 return SWIG_Python_InitShadowInstance(args);
42428 }
42429
42430 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42431 PyObject *resultobj = 0;
42432 wxPyValidator *result = 0 ;
42433
42434 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
42435 {
42436 PyThreadState* __tstate = wxPyBeginAllowThreads();
42437 result = (wxPyValidator *)new wxPyValidator();
42438 wxPyEndAllowThreads(__tstate);
42439 if (PyErr_Occurred()) SWIG_fail;
42440 }
42441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
42442 return resultobj;
42443 fail:
42444 return NULL;
42445 }
42446
42447
42448 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42449 PyObject *resultobj = 0;
42450 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
42451 PyObject *arg2 = (PyObject *) 0 ;
42452 PyObject *arg3 = (PyObject *) 0 ;
42453 int arg4 = (int) 1 ;
42454 void *argp1 = 0 ;
42455 int res1 = 0 ;
42456 int val4 ;
42457 int ecode4 = 0 ;
42458 PyObject * obj0 = 0 ;
42459 PyObject * obj1 = 0 ;
42460 PyObject * obj2 = 0 ;
42461 PyObject * obj3 = 0 ;
42462 char * kwnames[] = {
42463 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
42464 };
42465
42466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
42468 if (!SWIG_IsOK(res1)) {
42469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
42470 }
42471 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
42472 arg2 = obj1;
42473 arg3 = obj2;
42474 if (obj3) {
42475 ecode4 = SWIG_AsVal_int(obj3, &val4);
42476 if (!SWIG_IsOK(ecode4)) {
42477 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
42478 }
42479 arg4 = static_cast< int >(val4);
42480 }
42481 {
42482 PyThreadState* __tstate = wxPyBeginAllowThreads();
42483 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
42484 wxPyEndAllowThreads(__tstate);
42485 if (PyErr_Occurred()) SWIG_fail;
42486 }
42487 resultobj = SWIG_Py_Void();
42488 return resultobj;
42489 fail:
42490 return NULL;
42491 }
42492
42493
42494 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42495 PyObject *obj;
42496 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42497 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
42498 return SWIG_Py_Void();
42499 }
42500
42501 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42502 return SWIG_Python_InitShadowInstance(args);
42503 }
42504
42505 SWIGINTERN int DefaultValidator_set(PyObject *) {
42506 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
42507 return 1;
42508 }
42509
42510
42511 SWIGINTERN PyObject *DefaultValidator_get(void) {
42512 PyObject *pyobj = 0;
42513
42514 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
42515 return pyobj;
42516 }
42517
42518
42519 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42520 PyObject *resultobj = 0;
42521 wxString const &arg1_defvalue = wxPyEmptyString ;
42522 wxString *arg1 = (wxString *) &arg1_defvalue ;
42523 long arg2 = (long) 0 ;
42524 wxMenu *result = 0 ;
42525 bool temp1 = false ;
42526 long val2 ;
42527 int ecode2 = 0 ;
42528 PyObject * obj0 = 0 ;
42529 PyObject * obj1 = 0 ;
42530 char * kwnames[] = {
42531 (char *) "title",(char *) "style", NULL
42532 };
42533
42534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
42535 if (obj0) {
42536 {
42537 arg1 = wxString_in_helper(obj0);
42538 if (arg1 == NULL) SWIG_fail;
42539 temp1 = true;
42540 }
42541 }
42542 if (obj1) {
42543 ecode2 = SWIG_AsVal_long(obj1, &val2);
42544 if (!SWIG_IsOK(ecode2)) {
42545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
42546 }
42547 arg2 = static_cast< long >(val2);
42548 }
42549 {
42550 if (!wxPyCheckForApp()) SWIG_fail;
42551 PyThreadState* __tstate = wxPyBeginAllowThreads();
42552 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
42553 wxPyEndAllowThreads(__tstate);
42554 if (PyErr_Occurred()) SWIG_fail;
42555 }
42556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
42557 {
42558 if (temp1)
42559 delete arg1;
42560 }
42561 return resultobj;
42562 fail:
42563 {
42564 if (temp1)
42565 delete arg1;
42566 }
42567 return NULL;
42568 }
42569
42570
42571 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42572 PyObject *resultobj = 0;
42573 wxMenu *arg1 = (wxMenu *) 0 ;
42574 int arg2 ;
42575 wxString const &arg3_defvalue = wxPyEmptyString ;
42576 wxString *arg3 = (wxString *) &arg3_defvalue ;
42577 wxString const &arg4_defvalue = wxPyEmptyString ;
42578 wxString *arg4 = (wxString *) &arg4_defvalue ;
42579 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42580 wxMenuItem *result = 0 ;
42581 void *argp1 = 0 ;
42582 int res1 = 0 ;
42583 int val2 ;
42584 int ecode2 = 0 ;
42585 bool temp3 = false ;
42586 bool temp4 = false ;
42587 int val5 ;
42588 int ecode5 = 0 ;
42589 PyObject * obj0 = 0 ;
42590 PyObject * obj1 = 0 ;
42591 PyObject * obj2 = 0 ;
42592 PyObject * obj3 = 0 ;
42593 PyObject * obj4 = 0 ;
42594 char * kwnames[] = {
42595 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42596 };
42597
42598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42600 if (!SWIG_IsOK(res1)) {
42601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
42602 }
42603 arg1 = reinterpret_cast< wxMenu * >(argp1);
42604 ecode2 = SWIG_AsVal_int(obj1, &val2);
42605 if (!SWIG_IsOK(ecode2)) {
42606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
42607 }
42608 arg2 = static_cast< int >(val2);
42609 if (obj2) {
42610 {
42611 arg3 = wxString_in_helper(obj2);
42612 if (arg3 == NULL) SWIG_fail;
42613 temp3 = true;
42614 }
42615 }
42616 if (obj3) {
42617 {
42618 arg4 = wxString_in_helper(obj3);
42619 if (arg4 == NULL) SWIG_fail;
42620 temp4 = true;
42621 }
42622 }
42623 if (obj4) {
42624 ecode5 = SWIG_AsVal_int(obj4, &val5);
42625 if (!SWIG_IsOK(ecode5)) {
42626 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
42627 }
42628 arg5 = static_cast< wxItemKind >(val5);
42629 }
42630 {
42631 PyThreadState* __tstate = wxPyBeginAllowThreads();
42632 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42633 wxPyEndAllowThreads(__tstate);
42634 if (PyErr_Occurred()) SWIG_fail;
42635 }
42636 {
42637 resultobj = wxPyMake_wxObject(result, (bool)0);
42638 }
42639 {
42640 if (temp3)
42641 delete arg3;
42642 }
42643 {
42644 if (temp4)
42645 delete arg4;
42646 }
42647 return resultobj;
42648 fail:
42649 {
42650 if (temp3)
42651 delete arg3;
42652 }
42653 {
42654 if (temp4)
42655 delete arg4;
42656 }
42657 return NULL;
42658 }
42659
42660
42661 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42662 PyObject *resultobj = 0;
42663 wxMenu *arg1 = (wxMenu *) 0 ;
42664 wxMenuItem *result = 0 ;
42665 void *argp1 = 0 ;
42666 int res1 = 0 ;
42667 PyObject *swig_obj[1] ;
42668
42669 if (!args) SWIG_fail;
42670 swig_obj[0] = args;
42671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42672 if (!SWIG_IsOK(res1)) {
42673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42674 }
42675 arg1 = reinterpret_cast< wxMenu * >(argp1);
42676 {
42677 PyThreadState* __tstate = wxPyBeginAllowThreads();
42678 result = (wxMenuItem *)(arg1)->AppendSeparator();
42679 wxPyEndAllowThreads(__tstate);
42680 if (PyErr_Occurred()) SWIG_fail;
42681 }
42682 {
42683 resultobj = wxPyMake_wxObject(result, (bool)0);
42684 }
42685 return resultobj;
42686 fail:
42687 return NULL;
42688 }
42689
42690
42691 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42692 PyObject *resultobj = 0;
42693 wxMenu *arg1 = (wxMenu *) 0 ;
42694 int arg2 ;
42695 wxString *arg3 = 0 ;
42696 wxString const &arg4_defvalue = wxPyEmptyString ;
42697 wxString *arg4 = (wxString *) &arg4_defvalue ;
42698 wxMenuItem *result = 0 ;
42699 void *argp1 = 0 ;
42700 int res1 = 0 ;
42701 int val2 ;
42702 int ecode2 = 0 ;
42703 bool temp3 = false ;
42704 bool temp4 = false ;
42705 PyObject * obj0 = 0 ;
42706 PyObject * obj1 = 0 ;
42707 PyObject * obj2 = 0 ;
42708 PyObject * obj3 = 0 ;
42709 char * kwnames[] = {
42710 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42711 };
42712
42713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42715 if (!SWIG_IsOK(res1)) {
42716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42717 }
42718 arg1 = reinterpret_cast< wxMenu * >(argp1);
42719 ecode2 = SWIG_AsVal_int(obj1, &val2);
42720 if (!SWIG_IsOK(ecode2)) {
42721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42722 }
42723 arg2 = static_cast< int >(val2);
42724 {
42725 arg3 = wxString_in_helper(obj2);
42726 if (arg3 == NULL) SWIG_fail;
42727 temp3 = true;
42728 }
42729 if (obj3) {
42730 {
42731 arg4 = wxString_in_helper(obj3);
42732 if (arg4 == NULL) SWIG_fail;
42733 temp4 = true;
42734 }
42735 }
42736 {
42737 PyThreadState* __tstate = wxPyBeginAllowThreads();
42738 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42739 wxPyEndAllowThreads(__tstate);
42740 if (PyErr_Occurred()) SWIG_fail;
42741 }
42742 {
42743 resultobj = wxPyMake_wxObject(result, (bool)0);
42744 }
42745 {
42746 if (temp3)
42747 delete arg3;
42748 }
42749 {
42750 if (temp4)
42751 delete arg4;
42752 }
42753 return resultobj;
42754 fail:
42755 {
42756 if (temp3)
42757 delete arg3;
42758 }
42759 {
42760 if (temp4)
42761 delete arg4;
42762 }
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42768 PyObject *resultobj = 0;
42769 wxMenu *arg1 = (wxMenu *) 0 ;
42770 int arg2 ;
42771 wxString *arg3 = 0 ;
42772 wxString const &arg4_defvalue = wxPyEmptyString ;
42773 wxString *arg4 = (wxString *) &arg4_defvalue ;
42774 wxMenuItem *result = 0 ;
42775 void *argp1 = 0 ;
42776 int res1 = 0 ;
42777 int val2 ;
42778 int ecode2 = 0 ;
42779 bool temp3 = false ;
42780 bool temp4 = false ;
42781 PyObject * obj0 = 0 ;
42782 PyObject * obj1 = 0 ;
42783 PyObject * obj2 = 0 ;
42784 PyObject * obj3 = 0 ;
42785 char * kwnames[] = {
42786 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42787 };
42788
42789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42791 if (!SWIG_IsOK(res1)) {
42792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42793 }
42794 arg1 = reinterpret_cast< wxMenu * >(argp1);
42795 ecode2 = SWIG_AsVal_int(obj1, &val2);
42796 if (!SWIG_IsOK(ecode2)) {
42797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42798 }
42799 arg2 = static_cast< int >(val2);
42800 {
42801 arg3 = wxString_in_helper(obj2);
42802 if (arg3 == NULL) SWIG_fail;
42803 temp3 = true;
42804 }
42805 if (obj3) {
42806 {
42807 arg4 = wxString_in_helper(obj3);
42808 if (arg4 == NULL) SWIG_fail;
42809 temp4 = true;
42810 }
42811 }
42812 {
42813 PyThreadState* __tstate = wxPyBeginAllowThreads();
42814 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42815 wxPyEndAllowThreads(__tstate);
42816 if (PyErr_Occurred()) SWIG_fail;
42817 }
42818 {
42819 resultobj = wxPyMake_wxObject(result, (bool)0);
42820 }
42821 {
42822 if (temp3)
42823 delete arg3;
42824 }
42825 {
42826 if (temp4)
42827 delete arg4;
42828 }
42829 return resultobj;
42830 fail:
42831 {
42832 if (temp3)
42833 delete arg3;
42834 }
42835 {
42836 if (temp4)
42837 delete arg4;
42838 }
42839 return NULL;
42840 }
42841
42842
42843 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42844 PyObject *resultobj = 0;
42845 wxMenu *arg1 = (wxMenu *) 0 ;
42846 int arg2 ;
42847 wxString *arg3 = 0 ;
42848 wxMenu *arg4 = (wxMenu *) 0 ;
42849 wxString const &arg5_defvalue = wxPyEmptyString ;
42850 wxString *arg5 = (wxString *) &arg5_defvalue ;
42851 wxMenuItem *result = 0 ;
42852 void *argp1 = 0 ;
42853 int res1 = 0 ;
42854 int val2 ;
42855 int ecode2 = 0 ;
42856 bool temp3 = false ;
42857 void *argp4 = 0 ;
42858 int res4 = 0 ;
42859 bool temp5 = false ;
42860 PyObject * obj0 = 0 ;
42861 PyObject * obj1 = 0 ;
42862 PyObject * obj2 = 0 ;
42863 PyObject * obj3 = 0 ;
42864 PyObject * obj4 = 0 ;
42865 char * kwnames[] = {
42866 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42867 };
42868
42869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42871 if (!SWIG_IsOK(res1)) {
42872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42873 }
42874 arg1 = reinterpret_cast< wxMenu * >(argp1);
42875 ecode2 = SWIG_AsVal_int(obj1, &val2);
42876 if (!SWIG_IsOK(ecode2)) {
42877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42878 }
42879 arg2 = static_cast< int >(val2);
42880 {
42881 arg3 = wxString_in_helper(obj2);
42882 if (arg3 == NULL) SWIG_fail;
42883 temp3 = true;
42884 }
42885 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42886 if (!SWIG_IsOK(res4)) {
42887 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42888 }
42889 arg4 = reinterpret_cast< wxMenu * >(argp4);
42890 if (obj4) {
42891 {
42892 arg5 = wxString_in_helper(obj4);
42893 if (arg5 == NULL) SWIG_fail;
42894 temp5 = true;
42895 }
42896 }
42897 {
42898 PyThreadState* __tstate = wxPyBeginAllowThreads();
42899 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42900 wxPyEndAllowThreads(__tstate);
42901 if (PyErr_Occurred()) SWIG_fail;
42902 }
42903 {
42904 resultobj = wxPyMake_wxObject(result, (bool)0);
42905 }
42906 {
42907 if (temp3)
42908 delete arg3;
42909 }
42910 {
42911 if (temp5)
42912 delete arg5;
42913 }
42914 return resultobj;
42915 fail:
42916 {
42917 if (temp3)
42918 delete arg3;
42919 }
42920 {
42921 if (temp5)
42922 delete arg5;
42923 }
42924 return NULL;
42925 }
42926
42927
42928 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42929 PyObject *resultobj = 0;
42930 wxMenu *arg1 = (wxMenu *) 0 ;
42931 wxMenu *arg2 = (wxMenu *) 0 ;
42932 wxString *arg3 = 0 ;
42933 wxString const &arg4_defvalue = wxPyEmptyString ;
42934 wxString *arg4 = (wxString *) &arg4_defvalue ;
42935 wxMenuItem *result = 0 ;
42936 void *argp1 = 0 ;
42937 int res1 = 0 ;
42938 void *argp2 = 0 ;
42939 int res2 = 0 ;
42940 bool temp3 = false ;
42941 bool temp4 = false ;
42942 PyObject * obj0 = 0 ;
42943 PyObject * obj1 = 0 ;
42944 PyObject * obj2 = 0 ;
42945 PyObject * obj3 = 0 ;
42946 char * kwnames[] = {
42947 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42948 };
42949
42950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42952 if (!SWIG_IsOK(res1)) {
42953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42954 }
42955 arg1 = reinterpret_cast< wxMenu * >(argp1);
42956 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42957 if (!SWIG_IsOK(res2)) {
42958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42959 }
42960 arg2 = reinterpret_cast< wxMenu * >(argp2);
42961 {
42962 arg3 = wxString_in_helper(obj2);
42963 if (arg3 == NULL) SWIG_fail;
42964 temp3 = true;
42965 }
42966 if (obj3) {
42967 {
42968 arg4 = wxString_in_helper(obj3);
42969 if (arg4 == NULL) SWIG_fail;
42970 temp4 = true;
42971 }
42972 }
42973 {
42974 PyThreadState* __tstate = wxPyBeginAllowThreads();
42975 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 {
42980 resultobj = wxPyMake_wxObject(result, (bool)0);
42981 }
42982 {
42983 if (temp3)
42984 delete arg3;
42985 }
42986 {
42987 if (temp4)
42988 delete arg4;
42989 }
42990 return resultobj;
42991 fail:
42992 {
42993 if (temp3)
42994 delete arg3;
42995 }
42996 {
42997 if (temp4)
42998 delete arg4;
42999 }
43000 return NULL;
43001 }
43002
43003
43004 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43005 PyObject *resultobj = 0;
43006 wxMenu *arg1 = (wxMenu *) 0 ;
43007 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43008 wxMenuItem *result = 0 ;
43009 void *argp1 = 0 ;
43010 int res1 = 0 ;
43011 int res2 = 0 ;
43012 PyObject * obj0 = 0 ;
43013 PyObject * obj1 = 0 ;
43014 char * kwnames[] = {
43015 (char *) "self",(char *) "item", NULL
43016 };
43017
43018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
43019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43020 if (!SWIG_IsOK(res1)) {
43021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43022 }
43023 arg1 = reinterpret_cast< wxMenu * >(argp1);
43024 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43025 if (!SWIG_IsOK(res2)) {
43026 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43027 }
43028 {
43029 PyThreadState* __tstate = wxPyBeginAllowThreads();
43030 result = (wxMenuItem *)(arg1)->Append(arg2);
43031 wxPyEndAllowThreads(__tstate);
43032 if (PyErr_Occurred()) SWIG_fail;
43033 }
43034 {
43035 resultobj = wxPyMake_wxObject(result, (bool)0);
43036 }
43037 return resultobj;
43038 fail:
43039 return NULL;
43040 }
43041
43042
43043 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43044 PyObject *resultobj = 0;
43045 wxMenu *arg1 = (wxMenu *) 0 ;
43046 size_t arg2 ;
43047 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
43048 wxMenuItem *result = 0 ;
43049 void *argp1 = 0 ;
43050 int res1 = 0 ;
43051 size_t val2 ;
43052 int ecode2 = 0 ;
43053 int res3 = 0 ;
43054 PyObject * obj0 = 0 ;
43055 PyObject * obj1 = 0 ;
43056 PyObject * obj2 = 0 ;
43057 char * kwnames[] = {
43058 (char *) "self",(char *) "pos",(char *) "item", NULL
43059 };
43060
43061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43063 if (!SWIG_IsOK(res1)) {
43064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43065 }
43066 arg1 = reinterpret_cast< wxMenu * >(argp1);
43067 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43068 if (!SWIG_IsOK(ecode2)) {
43069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
43070 }
43071 arg2 = static_cast< size_t >(val2);
43072 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43073 if (!SWIG_IsOK(res3)) {
43074 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
43075 }
43076 {
43077 PyThreadState* __tstate = wxPyBeginAllowThreads();
43078 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
43079 wxPyEndAllowThreads(__tstate);
43080 if (PyErr_Occurred()) SWIG_fail;
43081 }
43082 {
43083 resultobj = wxPyMake_wxObject(result, (bool)0);
43084 }
43085 return resultobj;
43086 fail:
43087 return NULL;
43088 }
43089
43090
43091 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43092 PyObject *resultobj = 0;
43093 wxMenu *arg1 = (wxMenu *) 0 ;
43094 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43095 wxMenuItem *result = 0 ;
43096 void *argp1 = 0 ;
43097 int res1 = 0 ;
43098 int res2 = 0 ;
43099 PyObject * obj0 = 0 ;
43100 PyObject * obj1 = 0 ;
43101 char * kwnames[] = {
43102 (char *) "self",(char *) "item", NULL
43103 };
43104
43105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
43106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43107 if (!SWIG_IsOK(res1)) {
43108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43109 }
43110 arg1 = reinterpret_cast< wxMenu * >(argp1);
43111 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
43112 if (!SWIG_IsOK(res2)) {
43113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43114 }
43115 {
43116 PyThreadState* __tstate = wxPyBeginAllowThreads();
43117 result = (wxMenuItem *)(arg1)->Prepend(arg2);
43118 wxPyEndAllowThreads(__tstate);
43119 if (PyErr_Occurred()) SWIG_fail;
43120 }
43121 {
43122 resultobj = wxPyMake_wxObject(result, (bool)0);
43123 }
43124 return resultobj;
43125 fail:
43126 return NULL;
43127 }
43128
43129
43130 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43131 PyObject *resultobj = 0;
43132 wxMenu *arg1 = (wxMenu *) 0 ;
43133 void *argp1 = 0 ;
43134 int res1 = 0 ;
43135 PyObject *swig_obj[1] ;
43136
43137 if (!args) SWIG_fail;
43138 swig_obj[0] = args;
43139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43140 if (!SWIG_IsOK(res1)) {
43141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
43142 }
43143 arg1 = reinterpret_cast< wxMenu * >(argp1);
43144 {
43145 PyThreadState* __tstate = wxPyBeginAllowThreads();
43146 (arg1)->Break();
43147 wxPyEndAllowThreads(__tstate);
43148 if (PyErr_Occurred()) SWIG_fail;
43149 }
43150 resultobj = SWIG_Py_Void();
43151 return resultobj;
43152 fail:
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43158 PyObject *resultobj = 0;
43159 wxMenu *arg1 = (wxMenu *) 0 ;
43160 size_t arg2 ;
43161 int arg3 ;
43162 wxString const &arg4_defvalue = wxPyEmptyString ;
43163 wxString *arg4 = (wxString *) &arg4_defvalue ;
43164 wxString const &arg5_defvalue = wxPyEmptyString ;
43165 wxString *arg5 = (wxString *) &arg5_defvalue ;
43166 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
43167 wxMenuItem *result = 0 ;
43168 void *argp1 = 0 ;
43169 int res1 = 0 ;
43170 size_t val2 ;
43171 int ecode2 = 0 ;
43172 int val3 ;
43173 int ecode3 = 0 ;
43174 bool temp4 = false ;
43175 bool temp5 = false ;
43176 int val6 ;
43177 int ecode6 = 0 ;
43178 PyObject * obj0 = 0 ;
43179 PyObject * obj1 = 0 ;
43180 PyObject * obj2 = 0 ;
43181 PyObject * obj3 = 0 ;
43182 PyObject * obj4 = 0 ;
43183 PyObject * obj5 = 0 ;
43184 char * kwnames[] = {
43185 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43186 };
43187
43188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43190 if (!SWIG_IsOK(res1)) {
43191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
43192 }
43193 arg1 = reinterpret_cast< wxMenu * >(argp1);
43194 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43195 if (!SWIG_IsOK(ecode2)) {
43196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
43197 }
43198 arg2 = static_cast< size_t >(val2);
43199 ecode3 = SWIG_AsVal_int(obj2, &val3);
43200 if (!SWIG_IsOK(ecode3)) {
43201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
43202 }
43203 arg3 = static_cast< int >(val3);
43204 if (obj3) {
43205 {
43206 arg4 = wxString_in_helper(obj3);
43207 if (arg4 == NULL) SWIG_fail;
43208 temp4 = true;
43209 }
43210 }
43211 if (obj4) {
43212 {
43213 arg5 = wxString_in_helper(obj4);
43214 if (arg5 == NULL) SWIG_fail;
43215 temp5 = true;
43216 }
43217 }
43218 if (obj5) {
43219 ecode6 = SWIG_AsVal_int(obj5, &val6);
43220 if (!SWIG_IsOK(ecode6)) {
43221 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
43222 }
43223 arg6 = static_cast< wxItemKind >(val6);
43224 }
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 {
43232 resultobj = wxPyMake_wxObject(result, (bool)0);
43233 }
43234 {
43235 if (temp4)
43236 delete arg4;
43237 }
43238 {
43239 if (temp5)
43240 delete arg5;
43241 }
43242 return resultobj;
43243 fail:
43244 {
43245 if (temp4)
43246 delete arg4;
43247 }
43248 {
43249 if (temp5)
43250 delete arg5;
43251 }
43252 return NULL;
43253 }
43254
43255
43256 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43257 PyObject *resultobj = 0;
43258 wxMenu *arg1 = (wxMenu *) 0 ;
43259 size_t arg2 ;
43260 wxMenuItem *result = 0 ;
43261 void *argp1 = 0 ;
43262 int res1 = 0 ;
43263 size_t val2 ;
43264 int ecode2 = 0 ;
43265 PyObject * obj0 = 0 ;
43266 PyObject * obj1 = 0 ;
43267 char * kwnames[] = {
43268 (char *) "self",(char *) "pos", NULL
43269 };
43270
43271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
43272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43273 if (!SWIG_IsOK(res1)) {
43274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43275 }
43276 arg1 = reinterpret_cast< wxMenu * >(argp1);
43277 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43278 if (!SWIG_IsOK(ecode2)) {
43279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
43280 }
43281 arg2 = static_cast< size_t >(val2);
43282 {
43283 PyThreadState* __tstate = wxPyBeginAllowThreads();
43284 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
43285 wxPyEndAllowThreads(__tstate);
43286 if (PyErr_Occurred()) SWIG_fail;
43287 }
43288 {
43289 resultobj = wxPyMake_wxObject(result, (bool)0);
43290 }
43291 return resultobj;
43292 fail:
43293 return NULL;
43294 }
43295
43296
43297 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43298 PyObject *resultobj = 0;
43299 wxMenu *arg1 = (wxMenu *) 0 ;
43300 size_t arg2 ;
43301 int arg3 ;
43302 wxString *arg4 = 0 ;
43303 wxString const &arg5_defvalue = wxPyEmptyString ;
43304 wxString *arg5 = (wxString *) &arg5_defvalue ;
43305 wxMenuItem *result = 0 ;
43306 void *argp1 = 0 ;
43307 int res1 = 0 ;
43308 size_t val2 ;
43309 int ecode2 = 0 ;
43310 int val3 ;
43311 int ecode3 = 0 ;
43312 bool temp4 = false ;
43313 bool temp5 = false ;
43314 PyObject * obj0 = 0 ;
43315 PyObject * obj1 = 0 ;
43316 PyObject * obj2 = 0 ;
43317 PyObject * obj3 = 0 ;
43318 PyObject * obj4 = 0 ;
43319 char * kwnames[] = {
43320 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43321 };
43322
43323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43325 if (!SWIG_IsOK(res1)) {
43326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43327 }
43328 arg1 = reinterpret_cast< wxMenu * >(argp1);
43329 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43330 if (!SWIG_IsOK(ecode2)) {
43331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
43332 }
43333 arg2 = static_cast< size_t >(val2);
43334 ecode3 = SWIG_AsVal_int(obj2, &val3);
43335 if (!SWIG_IsOK(ecode3)) {
43336 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
43337 }
43338 arg3 = static_cast< int >(val3);
43339 {
43340 arg4 = wxString_in_helper(obj3);
43341 if (arg4 == NULL) SWIG_fail;
43342 temp4 = true;
43343 }
43344 if (obj4) {
43345 {
43346 arg5 = wxString_in_helper(obj4);
43347 if (arg5 == NULL) SWIG_fail;
43348 temp5 = true;
43349 }
43350 }
43351 {
43352 PyThreadState* __tstate = wxPyBeginAllowThreads();
43353 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43354 wxPyEndAllowThreads(__tstate);
43355 if (PyErr_Occurred()) SWIG_fail;
43356 }
43357 {
43358 resultobj = wxPyMake_wxObject(result, (bool)0);
43359 }
43360 {
43361 if (temp4)
43362 delete arg4;
43363 }
43364 {
43365 if (temp5)
43366 delete arg5;
43367 }
43368 return resultobj;
43369 fail:
43370 {
43371 if (temp4)
43372 delete arg4;
43373 }
43374 {
43375 if (temp5)
43376 delete arg5;
43377 }
43378 return NULL;
43379 }
43380
43381
43382 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43383 PyObject *resultobj = 0;
43384 wxMenu *arg1 = (wxMenu *) 0 ;
43385 size_t arg2 ;
43386 int arg3 ;
43387 wxString *arg4 = 0 ;
43388 wxString const &arg5_defvalue = wxPyEmptyString ;
43389 wxString *arg5 = (wxString *) &arg5_defvalue ;
43390 wxMenuItem *result = 0 ;
43391 void *argp1 = 0 ;
43392 int res1 = 0 ;
43393 size_t val2 ;
43394 int ecode2 = 0 ;
43395 int val3 ;
43396 int ecode3 = 0 ;
43397 bool temp4 = false ;
43398 bool temp5 = false ;
43399 PyObject * obj0 = 0 ;
43400 PyObject * obj1 = 0 ;
43401 PyObject * obj2 = 0 ;
43402 PyObject * obj3 = 0 ;
43403 PyObject * obj4 = 0 ;
43404 char * kwnames[] = {
43405 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
43406 };
43407
43408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43410 if (!SWIG_IsOK(res1)) {
43411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43412 }
43413 arg1 = reinterpret_cast< wxMenu * >(argp1);
43414 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43415 if (!SWIG_IsOK(ecode2)) {
43416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
43417 }
43418 arg2 = static_cast< size_t >(val2);
43419 ecode3 = SWIG_AsVal_int(obj2, &val3);
43420 if (!SWIG_IsOK(ecode3)) {
43421 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
43422 }
43423 arg3 = static_cast< int >(val3);
43424 {
43425 arg4 = wxString_in_helper(obj3);
43426 if (arg4 == NULL) SWIG_fail;
43427 temp4 = true;
43428 }
43429 if (obj4) {
43430 {
43431 arg5 = wxString_in_helper(obj4);
43432 if (arg5 == NULL) SWIG_fail;
43433 temp5 = true;
43434 }
43435 }
43436 {
43437 PyThreadState* __tstate = wxPyBeginAllowThreads();
43438 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
43439 wxPyEndAllowThreads(__tstate);
43440 if (PyErr_Occurred()) SWIG_fail;
43441 }
43442 {
43443 resultobj = wxPyMake_wxObject(result, (bool)0);
43444 }
43445 {
43446 if (temp4)
43447 delete arg4;
43448 }
43449 {
43450 if (temp5)
43451 delete arg5;
43452 }
43453 return resultobj;
43454 fail:
43455 {
43456 if (temp4)
43457 delete arg4;
43458 }
43459 {
43460 if (temp5)
43461 delete arg5;
43462 }
43463 return NULL;
43464 }
43465
43466
43467 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43468 PyObject *resultobj = 0;
43469 wxMenu *arg1 = (wxMenu *) 0 ;
43470 size_t arg2 ;
43471 int arg3 ;
43472 wxString *arg4 = 0 ;
43473 wxMenu *arg5 = (wxMenu *) 0 ;
43474 wxString const &arg6_defvalue = wxPyEmptyString ;
43475 wxString *arg6 = (wxString *) &arg6_defvalue ;
43476 wxMenuItem *result = 0 ;
43477 void *argp1 = 0 ;
43478 int res1 = 0 ;
43479 size_t val2 ;
43480 int ecode2 = 0 ;
43481 int val3 ;
43482 int ecode3 = 0 ;
43483 bool temp4 = false ;
43484 void *argp5 = 0 ;
43485 int res5 = 0 ;
43486 bool temp6 = false ;
43487 PyObject * obj0 = 0 ;
43488 PyObject * obj1 = 0 ;
43489 PyObject * obj2 = 0 ;
43490 PyObject * obj3 = 0 ;
43491 PyObject * obj4 = 0 ;
43492 PyObject * obj5 = 0 ;
43493 char * kwnames[] = {
43494 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43495 };
43496
43497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
43498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43499 if (!SWIG_IsOK(res1)) {
43500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43501 }
43502 arg1 = reinterpret_cast< wxMenu * >(argp1);
43503 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43504 if (!SWIG_IsOK(ecode2)) {
43505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
43506 }
43507 arg2 = static_cast< size_t >(val2);
43508 ecode3 = SWIG_AsVal_int(obj2, &val3);
43509 if (!SWIG_IsOK(ecode3)) {
43510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
43511 }
43512 arg3 = static_cast< int >(val3);
43513 {
43514 arg4 = wxString_in_helper(obj3);
43515 if (arg4 == NULL) SWIG_fail;
43516 temp4 = true;
43517 }
43518 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
43519 if (!SWIG_IsOK(res5)) {
43520 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
43521 }
43522 arg5 = reinterpret_cast< wxMenu * >(argp5);
43523 if (obj5) {
43524 {
43525 arg6 = wxString_in_helper(obj5);
43526 if (arg6 == NULL) SWIG_fail;
43527 temp6 = true;
43528 }
43529 }
43530 {
43531 PyThreadState* __tstate = wxPyBeginAllowThreads();
43532 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
43533 wxPyEndAllowThreads(__tstate);
43534 if (PyErr_Occurred()) SWIG_fail;
43535 }
43536 {
43537 resultobj = wxPyMake_wxObject(result, (bool)0);
43538 }
43539 {
43540 if (temp4)
43541 delete arg4;
43542 }
43543 {
43544 if (temp6)
43545 delete arg6;
43546 }
43547 return resultobj;
43548 fail:
43549 {
43550 if (temp4)
43551 delete arg4;
43552 }
43553 {
43554 if (temp6)
43555 delete arg6;
43556 }
43557 return NULL;
43558 }
43559
43560
43561 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43562 PyObject *resultobj = 0;
43563 wxMenu *arg1 = (wxMenu *) 0 ;
43564 int arg2 ;
43565 wxString const &arg3_defvalue = wxPyEmptyString ;
43566 wxString *arg3 = (wxString *) &arg3_defvalue ;
43567 wxString const &arg4_defvalue = wxPyEmptyString ;
43568 wxString *arg4 = (wxString *) &arg4_defvalue ;
43569 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
43570 wxMenuItem *result = 0 ;
43571 void *argp1 = 0 ;
43572 int res1 = 0 ;
43573 int val2 ;
43574 int ecode2 = 0 ;
43575 bool temp3 = false ;
43576 bool temp4 = false ;
43577 int val5 ;
43578 int ecode5 = 0 ;
43579 PyObject * obj0 = 0 ;
43580 PyObject * obj1 = 0 ;
43581 PyObject * obj2 = 0 ;
43582 PyObject * obj3 = 0 ;
43583 PyObject * obj4 = 0 ;
43584 char * kwnames[] = {
43585 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
43586 };
43587
43588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43590 if (!SWIG_IsOK(res1)) {
43591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
43592 }
43593 arg1 = reinterpret_cast< wxMenu * >(argp1);
43594 ecode2 = SWIG_AsVal_int(obj1, &val2);
43595 if (!SWIG_IsOK(ecode2)) {
43596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
43597 }
43598 arg2 = static_cast< int >(val2);
43599 if (obj2) {
43600 {
43601 arg3 = wxString_in_helper(obj2);
43602 if (arg3 == NULL) SWIG_fail;
43603 temp3 = true;
43604 }
43605 }
43606 if (obj3) {
43607 {
43608 arg4 = wxString_in_helper(obj3);
43609 if (arg4 == NULL) SWIG_fail;
43610 temp4 = true;
43611 }
43612 }
43613 if (obj4) {
43614 ecode5 = SWIG_AsVal_int(obj4, &val5);
43615 if (!SWIG_IsOK(ecode5)) {
43616 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
43617 }
43618 arg5 = static_cast< wxItemKind >(val5);
43619 }
43620 {
43621 PyThreadState* __tstate = wxPyBeginAllowThreads();
43622 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
43623 wxPyEndAllowThreads(__tstate);
43624 if (PyErr_Occurred()) SWIG_fail;
43625 }
43626 {
43627 resultobj = wxPyMake_wxObject(result, (bool)0);
43628 }
43629 {
43630 if (temp3)
43631 delete arg3;
43632 }
43633 {
43634 if (temp4)
43635 delete arg4;
43636 }
43637 return resultobj;
43638 fail:
43639 {
43640 if (temp3)
43641 delete arg3;
43642 }
43643 {
43644 if (temp4)
43645 delete arg4;
43646 }
43647 return NULL;
43648 }
43649
43650
43651 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43652 PyObject *resultobj = 0;
43653 wxMenu *arg1 = (wxMenu *) 0 ;
43654 wxMenuItem *result = 0 ;
43655 void *argp1 = 0 ;
43656 int res1 = 0 ;
43657 PyObject *swig_obj[1] ;
43658
43659 if (!args) SWIG_fail;
43660 swig_obj[0] = args;
43661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43662 if (!SWIG_IsOK(res1)) {
43663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
43664 }
43665 arg1 = reinterpret_cast< wxMenu * >(argp1);
43666 {
43667 PyThreadState* __tstate = wxPyBeginAllowThreads();
43668 result = (wxMenuItem *)(arg1)->PrependSeparator();
43669 wxPyEndAllowThreads(__tstate);
43670 if (PyErr_Occurred()) SWIG_fail;
43671 }
43672 {
43673 resultobj = wxPyMake_wxObject(result, (bool)0);
43674 }
43675 return resultobj;
43676 fail:
43677 return NULL;
43678 }
43679
43680
43681 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43682 PyObject *resultobj = 0;
43683 wxMenu *arg1 = (wxMenu *) 0 ;
43684 int arg2 ;
43685 wxString *arg3 = 0 ;
43686 wxString const &arg4_defvalue = wxPyEmptyString ;
43687 wxString *arg4 = (wxString *) &arg4_defvalue ;
43688 wxMenuItem *result = 0 ;
43689 void *argp1 = 0 ;
43690 int res1 = 0 ;
43691 int val2 ;
43692 int ecode2 = 0 ;
43693 bool temp3 = false ;
43694 bool temp4 = false ;
43695 PyObject * obj0 = 0 ;
43696 PyObject * obj1 = 0 ;
43697 PyObject * obj2 = 0 ;
43698 PyObject * obj3 = 0 ;
43699 char * kwnames[] = {
43700 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43701 };
43702
43703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43705 if (!SWIG_IsOK(res1)) {
43706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43707 }
43708 arg1 = reinterpret_cast< wxMenu * >(argp1);
43709 ecode2 = SWIG_AsVal_int(obj1, &val2);
43710 if (!SWIG_IsOK(ecode2)) {
43711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43712 }
43713 arg2 = static_cast< int >(val2);
43714 {
43715 arg3 = wxString_in_helper(obj2);
43716 if (arg3 == NULL) SWIG_fail;
43717 temp3 = true;
43718 }
43719 if (obj3) {
43720 {
43721 arg4 = wxString_in_helper(obj3);
43722 if (arg4 == NULL) SWIG_fail;
43723 temp4 = true;
43724 }
43725 }
43726 {
43727 PyThreadState* __tstate = wxPyBeginAllowThreads();
43728 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43729 wxPyEndAllowThreads(__tstate);
43730 if (PyErr_Occurred()) SWIG_fail;
43731 }
43732 {
43733 resultobj = wxPyMake_wxObject(result, (bool)0);
43734 }
43735 {
43736 if (temp3)
43737 delete arg3;
43738 }
43739 {
43740 if (temp4)
43741 delete arg4;
43742 }
43743 return resultobj;
43744 fail:
43745 {
43746 if (temp3)
43747 delete arg3;
43748 }
43749 {
43750 if (temp4)
43751 delete arg4;
43752 }
43753 return NULL;
43754 }
43755
43756
43757 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43758 PyObject *resultobj = 0;
43759 wxMenu *arg1 = (wxMenu *) 0 ;
43760 int arg2 ;
43761 wxString *arg3 = 0 ;
43762 wxString const &arg4_defvalue = wxPyEmptyString ;
43763 wxString *arg4 = (wxString *) &arg4_defvalue ;
43764 wxMenuItem *result = 0 ;
43765 void *argp1 = 0 ;
43766 int res1 = 0 ;
43767 int val2 ;
43768 int ecode2 = 0 ;
43769 bool temp3 = false ;
43770 bool temp4 = false ;
43771 PyObject * obj0 = 0 ;
43772 PyObject * obj1 = 0 ;
43773 PyObject * obj2 = 0 ;
43774 PyObject * obj3 = 0 ;
43775 char * kwnames[] = {
43776 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43777 };
43778
43779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43781 if (!SWIG_IsOK(res1)) {
43782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43783 }
43784 arg1 = reinterpret_cast< wxMenu * >(argp1);
43785 ecode2 = SWIG_AsVal_int(obj1, &val2);
43786 if (!SWIG_IsOK(ecode2)) {
43787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43788 }
43789 arg2 = static_cast< int >(val2);
43790 {
43791 arg3 = wxString_in_helper(obj2);
43792 if (arg3 == NULL) SWIG_fail;
43793 temp3 = true;
43794 }
43795 if (obj3) {
43796 {
43797 arg4 = wxString_in_helper(obj3);
43798 if (arg4 == NULL) SWIG_fail;
43799 temp4 = true;
43800 }
43801 }
43802 {
43803 PyThreadState* __tstate = wxPyBeginAllowThreads();
43804 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43805 wxPyEndAllowThreads(__tstate);
43806 if (PyErr_Occurred()) SWIG_fail;
43807 }
43808 {
43809 resultobj = wxPyMake_wxObject(result, (bool)0);
43810 }
43811 {
43812 if (temp3)
43813 delete arg3;
43814 }
43815 {
43816 if (temp4)
43817 delete arg4;
43818 }
43819 return resultobj;
43820 fail:
43821 {
43822 if (temp3)
43823 delete arg3;
43824 }
43825 {
43826 if (temp4)
43827 delete arg4;
43828 }
43829 return NULL;
43830 }
43831
43832
43833 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43834 PyObject *resultobj = 0;
43835 wxMenu *arg1 = (wxMenu *) 0 ;
43836 int arg2 ;
43837 wxString *arg3 = 0 ;
43838 wxMenu *arg4 = (wxMenu *) 0 ;
43839 wxString const &arg5_defvalue = wxPyEmptyString ;
43840 wxString *arg5 = (wxString *) &arg5_defvalue ;
43841 wxMenuItem *result = 0 ;
43842 void *argp1 = 0 ;
43843 int res1 = 0 ;
43844 int val2 ;
43845 int ecode2 = 0 ;
43846 bool temp3 = false ;
43847 void *argp4 = 0 ;
43848 int res4 = 0 ;
43849 bool temp5 = false ;
43850 PyObject * obj0 = 0 ;
43851 PyObject * obj1 = 0 ;
43852 PyObject * obj2 = 0 ;
43853 PyObject * obj3 = 0 ;
43854 PyObject * obj4 = 0 ;
43855 char * kwnames[] = {
43856 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43857 };
43858
43859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43861 if (!SWIG_IsOK(res1)) {
43862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43863 }
43864 arg1 = reinterpret_cast< wxMenu * >(argp1);
43865 ecode2 = SWIG_AsVal_int(obj1, &val2);
43866 if (!SWIG_IsOK(ecode2)) {
43867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43868 }
43869 arg2 = static_cast< int >(val2);
43870 {
43871 arg3 = wxString_in_helper(obj2);
43872 if (arg3 == NULL) SWIG_fail;
43873 temp3 = true;
43874 }
43875 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43876 if (!SWIG_IsOK(res4)) {
43877 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43878 }
43879 arg4 = reinterpret_cast< wxMenu * >(argp4);
43880 if (obj4) {
43881 {
43882 arg5 = wxString_in_helper(obj4);
43883 if (arg5 == NULL) SWIG_fail;
43884 temp5 = true;
43885 }
43886 }
43887 {
43888 PyThreadState* __tstate = wxPyBeginAllowThreads();
43889 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43890 wxPyEndAllowThreads(__tstate);
43891 if (PyErr_Occurred()) SWIG_fail;
43892 }
43893 {
43894 resultobj = wxPyMake_wxObject(result, (bool)0);
43895 }
43896 {
43897 if (temp3)
43898 delete arg3;
43899 }
43900 {
43901 if (temp5)
43902 delete arg5;
43903 }
43904 return resultobj;
43905 fail:
43906 {
43907 if (temp3)
43908 delete arg3;
43909 }
43910 {
43911 if (temp5)
43912 delete arg5;
43913 }
43914 return NULL;
43915 }
43916
43917
43918 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43919 PyObject *resultobj = 0;
43920 wxMenu *arg1 = (wxMenu *) 0 ;
43921 int arg2 ;
43922 wxMenuItem *result = 0 ;
43923 void *argp1 = 0 ;
43924 int res1 = 0 ;
43925 int val2 ;
43926 int ecode2 = 0 ;
43927 PyObject * obj0 = 0 ;
43928 PyObject * obj1 = 0 ;
43929 char * kwnames[] = {
43930 (char *) "self",(char *) "id", NULL
43931 };
43932
43933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43935 if (!SWIG_IsOK(res1)) {
43936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43937 }
43938 arg1 = reinterpret_cast< wxMenu * >(argp1);
43939 ecode2 = SWIG_AsVal_int(obj1, &val2);
43940 if (!SWIG_IsOK(ecode2)) {
43941 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43942 }
43943 arg2 = static_cast< int >(val2);
43944 {
43945 PyThreadState* __tstate = wxPyBeginAllowThreads();
43946 result = (wxMenuItem *)(arg1)->Remove(arg2);
43947 wxPyEndAllowThreads(__tstate);
43948 if (PyErr_Occurred()) SWIG_fail;
43949 }
43950 {
43951 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43952 }
43953 return resultobj;
43954 fail:
43955 return NULL;
43956 }
43957
43958
43959 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43960 PyObject *resultobj = 0;
43961 wxMenu *arg1 = (wxMenu *) 0 ;
43962 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43963 wxMenuItem *result = 0 ;
43964 void *argp1 = 0 ;
43965 int res1 = 0 ;
43966 void *argp2 = 0 ;
43967 int res2 = 0 ;
43968 PyObject * obj0 = 0 ;
43969 PyObject * obj1 = 0 ;
43970 char * kwnames[] = {
43971 (char *) "self",(char *) "item", NULL
43972 };
43973
43974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43976 if (!SWIG_IsOK(res1)) {
43977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43978 }
43979 arg1 = reinterpret_cast< wxMenu * >(argp1);
43980 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43981 if (!SWIG_IsOK(res2)) {
43982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43983 }
43984 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43985 {
43986 PyThreadState* __tstate = wxPyBeginAllowThreads();
43987 result = (wxMenuItem *)(arg1)->Remove(arg2);
43988 wxPyEndAllowThreads(__tstate);
43989 if (PyErr_Occurred()) SWIG_fail;
43990 }
43991 {
43992 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43993 }
43994 return resultobj;
43995 fail:
43996 return NULL;
43997 }
43998
43999
44000 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44001 PyObject *resultobj = 0;
44002 wxMenu *arg1 = (wxMenu *) 0 ;
44003 int arg2 ;
44004 bool result;
44005 void *argp1 = 0 ;
44006 int res1 = 0 ;
44007 int val2 ;
44008 int ecode2 = 0 ;
44009 PyObject * obj0 = 0 ;
44010 PyObject * obj1 = 0 ;
44011 char * kwnames[] = {
44012 (char *) "self",(char *) "id", NULL
44013 };
44014
44015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44017 if (!SWIG_IsOK(res1)) {
44018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
44019 }
44020 arg1 = reinterpret_cast< wxMenu * >(argp1);
44021 ecode2 = SWIG_AsVal_int(obj1, &val2);
44022 if (!SWIG_IsOK(ecode2)) {
44023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
44024 }
44025 arg2 = static_cast< int >(val2);
44026 {
44027 PyThreadState* __tstate = wxPyBeginAllowThreads();
44028 result = (bool)(arg1)->Delete(arg2);
44029 wxPyEndAllowThreads(__tstate);
44030 if (PyErr_Occurred()) SWIG_fail;
44031 }
44032 {
44033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44034 }
44035 return resultobj;
44036 fail:
44037 return NULL;
44038 }
44039
44040
44041 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44042 PyObject *resultobj = 0;
44043 wxMenu *arg1 = (wxMenu *) 0 ;
44044 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44045 bool result;
44046 void *argp1 = 0 ;
44047 int res1 = 0 ;
44048 void *argp2 = 0 ;
44049 int res2 = 0 ;
44050 PyObject * obj0 = 0 ;
44051 PyObject * obj1 = 0 ;
44052 char * kwnames[] = {
44053 (char *) "self",(char *) "item", NULL
44054 };
44055
44056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
44057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44058 if (!SWIG_IsOK(res1)) {
44059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44060 }
44061 arg1 = reinterpret_cast< wxMenu * >(argp1);
44062 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44063 if (!SWIG_IsOK(res2)) {
44064 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44065 }
44066 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44067 {
44068 PyThreadState* __tstate = wxPyBeginAllowThreads();
44069 result = (bool)(arg1)->Delete(arg2);
44070 wxPyEndAllowThreads(__tstate);
44071 if (PyErr_Occurred()) SWIG_fail;
44072 }
44073 {
44074 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44075 }
44076 return resultobj;
44077 fail:
44078 return NULL;
44079 }
44080
44081
44082 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44083 PyObject *resultobj = 0;
44084 wxMenu *arg1 = (wxMenu *) 0 ;
44085 void *argp1 = 0 ;
44086 int res1 = 0 ;
44087 PyObject *swig_obj[1] ;
44088
44089 if (!args) SWIG_fail;
44090 swig_obj[0] = args;
44091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44092 if (!SWIG_IsOK(res1)) {
44093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
44094 }
44095 arg1 = reinterpret_cast< wxMenu * >(argp1);
44096 {
44097 PyThreadState* __tstate = wxPyBeginAllowThreads();
44098 wxMenu_Destroy(arg1);
44099 wxPyEndAllowThreads(__tstate);
44100 if (PyErr_Occurred()) SWIG_fail;
44101 }
44102 resultobj = SWIG_Py_Void();
44103 return resultobj;
44104 fail:
44105 return NULL;
44106 }
44107
44108
44109 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44110 PyObject *resultobj = 0;
44111 wxMenu *arg1 = (wxMenu *) 0 ;
44112 int arg2 ;
44113 bool result;
44114 void *argp1 = 0 ;
44115 int res1 = 0 ;
44116 int val2 ;
44117 int ecode2 = 0 ;
44118 PyObject * obj0 = 0 ;
44119 PyObject * obj1 = 0 ;
44120 char * kwnames[] = {
44121 (char *) "self",(char *) "id", NULL
44122 };
44123
44124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
44125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44126 if (!SWIG_IsOK(res1)) {
44127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
44128 }
44129 arg1 = reinterpret_cast< wxMenu * >(argp1);
44130 ecode2 = SWIG_AsVal_int(obj1, &val2);
44131 if (!SWIG_IsOK(ecode2)) {
44132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
44133 }
44134 arg2 = static_cast< int >(val2);
44135 {
44136 PyThreadState* __tstate = wxPyBeginAllowThreads();
44137 result = (bool)(arg1)->Destroy(arg2);
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 {
44142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44143 }
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj = 0;
44152 wxMenu *arg1 = (wxMenu *) 0 ;
44153 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
44154 bool result;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 void *argp2 = 0 ;
44158 int res2 = 0 ;
44159 PyObject * obj0 = 0 ;
44160 PyObject * obj1 = 0 ;
44161 char * kwnames[] = {
44162 (char *) "self",(char *) "item", NULL
44163 };
44164
44165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
44166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44167 if (!SWIG_IsOK(res1)) {
44168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
44169 }
44170 arg1 = reinterpret_cast< wxMenu * >(argp1);
44171 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
44172 if (!SWIG_IsOK(res2)) {
44173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
44174 }
44175 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
44176 {
44177 PyThreadState* __tstate = wxPyBeginAllowThreads();
44178 result = (bool)(arg1)->Destroy(arg2);
44179 wxPyEndAllowThreads(__tstate);
44180 if (PyErr_Occurred()) SWIG_fail;
44181 }
44182 {
44183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44184 }
44185 return resultobj;
44186 fail:
44187 return NULL;
44188 }
44189
44190
44191 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44192 PyObject *resultobj = 0;
44193 wxMenu *arg1 = (wxMenu *) 0 ;
44194 size_t result;
44195 void *argp1 = 0 ;
44196 int res1 = 0 ;
44197 PyObject *swig_obj[1] ;
44198
44199 if (!args) SWIG_fail;
44200 swig_obj[0] = args;
44201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44202 if (!SWIG_IsOK(res1)) {
44203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
44204 }
44205 arg1 = reinterpret_cast< wxMenu * >(argp1);
44206 {
44207 PyThreadState* __tstate = wxPyBeginAllowThreads();
44208 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
44209 wxPyEndAllowThreads(__tstate);
44210 if (PyErr_Occurred()) SWIG_fail;
44211 }
44212 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44213 return resultobj;
44214 fail:
44215 return NULL;
44216 }
44217
44218
44219 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44220 PyObject *resultobj = 0;
44221 wxMenu *arg1 = (wxMenu *) 0 ;
44222 PyObject *result = 0 ;
44223 void *argp1 = 0 ;
44224 int res1 = 0 ;
44225 PyObject *swig_obj[1] ;
44226
44227 if (!args) SWIG_fail;
44228 swig_obj[0] = args;
44229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44230 if (!SWIG_IsOK(res1)) {
44231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
44232 }
44233 arg1 = reinterpret_cast< wxMenu * >(argp1);
44234 {
44235 PyThreadState* __tstate = wxPyBeginAllowThreads();
44236 result = (PyObject *)wxMenu_GetMenuItems(arg1);
44237 wxPyEndAllowThreads(__tstate);
44238 if (PyErr_Occurred()) SWIG_fail;
44239 }
44240 resultobj = result;
44241 return resultobj;
44242 fail:
44243 return NULL;
44244 }
44245
44246
44247 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44248 PyObject *resultobj = 0;
44249 wxMenu *arg1 = (wxMenu *) 0 ;
44250 wxString *arg2 = 0 ;
44251 int result;
44252 void *argp1 = 0 ;
44253 int res1 = 0 ;
44254 bool temp2 = false ;
44255 PyObject * obj0 = 0 ;
44256 PyObject * obj1 = 0 ;
44257 char * kwnames[] = {
44258 (char *) "self",(char *) "item", NULL
44259 };
44260
44261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
44262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44263 if (!SWIG_IsOK(res1)) {
44264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
44265 }
44266 arg1 = reinterpret_cast< wxMenu * >(argp1);
44267 {
44268 arg2 = wxString_in_helper(obj1);
44269 if (arg2 == NULL) SWIG_fail;
44270 temp2 = true;
44271 }
44272 {
44273 PyThreadState* __tstate = wxPyBeginAllowThreads();
44274 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
44275 wxPyEndAllowThreads(__tstate);
44276 if (PyErr_Occurred()) SWIG_fail;
44277 }
44278 resultobj = SWIG_From_int(static_cast< int >(result));
44279 {
44280 if (temp2)
44281 delete arg2;
44282 }
44283 return resultobj;
44284 fail:
44285 {
44286 if (temp2)
44287 delete arg2;
44288 }
44289 return NULL;
44290 }
44291
44292
44293 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44294 PyObject *resultobj = 0;
44295 wxMenu *arg1 = (wxMenu *) 0 ;
44296 int arg2 ;
44297 wxMenuItem *result = 0 ;
44298 void *argp1 = 0 ;
44299 int res1 = 0 ;
44300 int val2 ;
44301 int ecode2 = 0 ;
44302 PyObject * obj0 = 0 ;
44303 PyObject * obj1 = 0 ;
44304 char * kwnames[] = {
44305 (char *) "self",(char *) "id", NULL
44306 };
44307
44308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44310 if (!SWIG_IsOK(res1)) {
44311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
44312 }
44313 arg1 = reinterpret_cast< wxMenu * >(argp1);
44314 ecode2 = SWIG_AsVal_int(obj1, &val2);
44315 if (!SWIG_IsOK(ecode2)) {
44316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
44317 }
44318 arg2 = static_cast< int >(val2);
44319 {
44320 PyThreadState* __tstate = wxPyBeginAllowThreads();
44321 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
44322 wxPyEndAllowThreads(__tstate);
44323 if (PyErr_Occurred()) SWIG_fail;
44324 }
44325 {
44326 resultobj = wxPyMake_wxObject(result, (bool)0);
44327 }
44328 return resultobj;
44329 fail:
44330 return NULL;
44331 }
44332
44333
44334 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44335 PyObject *resultobj = 0;
44336 wxMenu *arg1 = (wxMenu *) 0 ;
44337 size_t arg2 ;
44338 wxMenuItem *result = 0 ;
44339 void *argp1 = 0 ;
44340 int res1 = 0 ;
44341 size_t val2 ;
44342 int ecode2 = 0 ;
44343 PyObject * obj0 = 0 ;
44344 PyObject * obj1 = 0 ;
44345 char * kwnames[] = {
44346 (char *) "self",(char *) "position", NULL
44347 };
44348
44349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
44350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44351 if (!SWIG_IsOK(res1)) {
44352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
44353 }
44354 arg1 = reinterpret_cast< wxMenu * >(argp1);
44355 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44356 if (!SWIG_IsOK(ecode2)) {
44357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
44358 }
44359 arg2 = static_cast< size_t >(val2);
44360 {
44361 PyThreadState* __tstate = wxPyBeginAllowThreads();
44362 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
44363 wxPyEndAllowThreads(__tstate);
44364 if (PyErr_Occurred()) SWIG_fail;
44365 }
44366 {
44367 resultobj = wxPyMake_wxObject(result, (bool)0);
44368 }
44369 return resultobj;
44370 fail:
44371 return NULL;
44372 }
44373
44374
44375 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44376 PyObject *resultobj = 0;
44377 wxMenu *arg1 = (wxMenu *) 0 ;
44378 int arg2 ;
44379 bool arg3 ;
44380 void *argp1 = 0 ;
44381 int res1 = 0 ;
44382 int val2 ;
44383 int ecode2 = 0 ;
44384 bool val3 ;
44385 int ecode3 = 0 ;
44386 PyObject * obj0 = 0 ;
44387 PyObject * obj1 = 0 ;
44388 PyObject * obj2 = 0 ;
44389 char * kwnames[] = {
44390 (char *) "self",(char *) "id",(char *) "enable", NULL
44391 };
44392
44393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44395 if (!SWIG_IsOK(res1)) {
44396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
44397 }
44398 arg1 = reinterpret_cast< wxMenu * >(argp1);
44399 ecode2 = SWIG_AsVal_int(obj1, &val2);
44400 if (!SWIG_IsOK(ecode2)) {
44401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
44402 }
44403 arg2 = static_cast< int >(val2);
44404 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44405 if (!SWIG_IsOK(ecode3)) {
44406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
44407 }
44408 arg3 = static_cast< bool >(val3);
44409 {
44410 PyThreadState* __tstate = wxPyBeginAllowThreads();
44411 (arg1)->Enable(arg2,arg3);
44412 wxPyEndAllowThreads(__tstate);
44413 if (PyErr_Occurred()) SWIG_fail;
44414 }
44415 resultobj = SWIG_Py_Void();
44416 return resultobj;
44417 fail:
44418 return NULL;
44419 }
44420
44421
44422 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44423 PyObject *resultobj = 0;
44424 wxMenu *arg1 = (wxMenu *) 0 ;
44425 int arg2 ;
44426 bool result;
44427 void *argp1 = 0 ;
44428 int res1 = 0 ;
44429 int val2 ;
44430 int ecode2 = 0 ;
44431 PyObject * obj0 = 0 ;
44432 PyObject * obj1 = 0 ;
44433 char * kwnames[] = {
44434 (char *) "self",(char *) "id", NULL
44435 };
44436
44437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
44438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44439 if (!SWIG_IsOK(res1)) {
44440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
44441 }
44442 arg1 = reinterpret_cast< wxMenu * >(argp1);
44443 ecode2 = SWIG_AsVal_int(obj1, &val2);
44444 if (!SWIG_IsOK(ecode2)) {
44445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
44446 }
44447 arg2 = static_cast< int >(val2);
44448 {
44449 PyThreadState* __tstate = wxPyBeginAllowThreads();
44450 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
44451 wxPyEndAllowThreads(__tstate);
44452 if (PyErr_Occurred()) SWIG_fail;
44453 }
44454 {
44455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44456 }
44457 return resultobj;
44458 fail:
44459 return NULL;
44460 }
44461
44462
44463 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44464 PyObject *resultobj = 0;
44465 wxMenu *arg1 = (wxMenu *) 0 ;
44466 int arg2 ;
44467 bool arg3 ;
44468 void *argp1 = 0 ;
44469 int res1 = 0 ;
44470 int val2 ;
44471 int ecode2 = 0 ;
44472 bool val3 ;
44473 int ecode3 = 0 ;
44474 PyObject * obj0 = 0 ;
44475 PyObject * obj1 = 0 ;
44476 PyObject * obj2 = 0 ;
44477 char * kwnames[] = {
44478 (char *) "self",(char *) "id",(char *) "check", NULL
44479 };
44480
44481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44483 if (!SWIG_IsOK(res1)) {
44484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
44485 }
44486 arg1 = reinterpret_cast< wxMenu * >(argp1);
44487 ecode2 = SWIG_AsVal_int(obj1, &val2);
44488 if (!SWIG_IsOK(ecode2)) {
44489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
44490 }
44491 arg2 = static_cast< int >(val2);
44492 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44493 if (!SWIG_IsOK(ecode3)) {
44494 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
44495 }
44496 arg3 = static_cast< bool >(val3);
44497 {
44498 PyThreadState* __tstate = wxPyBeginAllowThreads();
44499 (arg1)->Check(arg2,arg3);
44500 wxPyEndAllowThreads(__tstate);
44501 if (PyErr_Occurred()) SWIG_fail;
44502 }
44503 resultobj = SWIG_Py_Void();
44504 return resultobj;
44505 fail:
44506 return NULL;
44507 }
44508
44509
44510 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44511 PyObject *resultobj = 0;
44512 wxMenu *arg1 = (wxMenu *) 0 ;
44513 int arg2 ;
44514 bool result;
44515 void *argp1 = 0 ;
44516 int res1 = 0 ;
44517 int val2 ;
44518 int ecode2 = 0 ;
44519 PyObject * obj0 = 0 ;
44520 PyObject * obj1 = 0 ;
44521 char * kwnames[] = {
44522 (char *) "self",(char *) "id", NULL
44523 };
44524
44525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
44526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44527 if (!SWIG_IsOK(res1)) {
44528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
44529 }
44530 arg1 = reinterpret_cast< wxMenu * >(argp1);
44531 ecode2 = SWIG_AsVal_int(obj1, &val2);
44532 if (!SWIG_IsOK(ecode2)) {
44533 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
44534 }
44535 arg2 = static_cast< int >(val2);
44536 {
44537 PyThreadState* __tstate = wxPyBeginAllowThreads();
44538 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
44539 wxPyEndAllowThreads(__tstate);
44540 if (PyErr_Occurred()) SWIG_fail;
44541 }
44542 {
44543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44544 }
44545 return resultobj;
44546 fail:
44547 return NULL;
44548 }
44549
44550
44551 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44552 PyObject *resultobj = 0;
44553 wxMenu *arg1 = (wxMenu *) 0 ;
44554 int arg2 ;
44555 wxString *arg3 = 0 ;
44556 void *argp1 = 0 ;
44557 int res1 = 0 ;
44558 int val2 ;
44559 int ecode2 = 0 ;
44560 bool temp3 = false ;
44561 PyObject * obj0 = 0 ;
44562 PyObject * obj1 = 0 ;
44563 PyObject * obj2 = 0 ;
44564 char * kwnames[] = {
44565 (char *) "self",(char *) "id",(char *) "label", NULL
44566 };
44567
44568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44570 if (!SWIG_IsOK(res1)) {
44571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
44572 }
44573 arg1 = reinterpret_cast< wxMenu * >(argp1);
44574 ecode2 = SWIG_AsVal_int(obj1, &val2);
44575 if (!SWIG_IsOK(ecode2)) {
44576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
44577 }
44578 arg2 = static_cast< int >(val2);
44579 {
44580 arg3 = wxString_in_helper(obj2);
44581 if (arg3 == NULL) SWIG_fail;
44582 temp3 = true;
44583 }
44584 {
44585 PyThreadState* __tstate = wxPyBeginAllowThreads();
44586 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
44587 wxPyEndAllowThreads(__tstate);
44588 if (PyErr_Occurred()) SWIG_fail;
44589 }
44590 resultobj = SWIG_Py_Void();
44591 {
44592 if (temp3)
44593 delete arg3;
44594 }
44595 return resultobj;
44596 fail:
44597 {
44598 if (temp3)
44599 delete arg3;
44600 }
44601 return NULL;
44602 }
44603
44604
44605 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44606 PyObject *resultobj = 0;
44607 wxMenu *arg1 = (wxMenu *) 0 ;
44608 int arg2 ;
44609 wxString result;
44610 void *argp1 = 0 ;
44611 int res1 = 0 ;
44612 int val2 ;
44613 int ecode2 = 0 ;
44614 PyObject * obj0 = 0 ;
44615 PyObject * obj1 = 0 ;
44616 char * kwnames[] = {
44617 (char *) "self",(char *) "id", NULL
44618 };
44619
44620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
44621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44622 if (!SWIG_IsOK(res1)) {
44623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
44624 }
44625 arg1 = reinterpret_cast< wxMenu * >(argp1);
44626 ecode2 = SWIG_AsVal_int(obj1, &val2);
44627 if (!SWIG_IsOK(ecode2)) {
44628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
44629 }
44630 arg2 = static_cast< int >(val2);
44631 {
44632 PyThreadState* __tstate = wxPyBeginAllowThreads();
44633 result = ((wxMenu const *)arg1)->GetLabel(arg2);
44634 wxPyEndAllowThreads(__tstate);
44635 if (PyErr_Occurred()) SWIG_fail;
44636 }
44637 {
44638 #if wxUSE_UNICODE
44639 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44640 #else
44641 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44642 #endif
44643 }
44644 return resultobj;
44645 fail:
44646 return NULL;
44647 }
44648
44649
44650 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44651 PyObject *resultobj = 0;
44652 wxMenu *arg1 = (wxMenu *) 0 ;
44653 int arg2 ;
44654 wxString *arg3 = 0 ;
44655 void *argp1 = 0 ;
44656 int res1 = 0 ;
44657 int val2 ;
44658 int ecode2 = 0 ;
44659 bool temp3 = false ;
44660 PyObject * obj0 = 0 ;
44661 PyObject * obj1 = 0 ;
44662 PyObject * obj2 = 0 ;
44663 char * kwnames[] = {
44664 (char *) "self",(char *) "id",(char *) "helpString", NULL
44665 };
44666
44667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44669 if (!SWIG_IsOK(res1)) {
44670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
44671 }
44672 arg1 = reinterpret_cast< wxMenu * >(argp1);
44673 ecode2 = SWIG_AsVal_int(obj1, &val2);
44674 if (!SWIG_IsOK(ecode2)) {
44675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44676 }
44677 arg2 = static_cast< int >(val2);
44678 {
44679 arg3 = wxString_in_helper(obj2);
44680 if (arg3 == NULL) SWIG_fail;
44681 temp3 = true;
44682 }
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44686 wxPyEndAllowThreads(__tstate);
44687 if (PyErr_Occurred()) SWIG_fail;
44688 }
44689 resultobj = SWIG_Py_Void();
44690 {
44691 if (temp3)
44692 delete arg3;
44693 }
44694 return resultobj;
44695 fail:
44696 {
44697 if (temp3)
44698 delete arg3;
44699 }
44700 return NULL;
44701 }
44702
44703
44704 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44705 PyObject *resultobj = 0;
44706 wxMenu *arg1 = (wxMenu *) 0 ;
44707 int arg2 ;
44708 wxString result;
44709 void *argp1 = 0 ;
44710 int res1 = 0 ;
44711 int val2 ;
44712 int ecode2 = 0 ;
44713 PyObject * obj0 = 0 ;
44714 PyObject * obj1 = 0 ;
44715 char * kwnames[] = {
44716 (char *) "self",(char *) "id", NULL
44717 };
44718
44719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44721 if (!SWIG_IsOK(res1)) {
44722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44723 }
44724 arg1 = reinterpret_cast< wxMenu * >(argp1);
44725 ecode2 = SWIG_AsVal_int(obj1, &val2);
44726 if (!SWIG_IsOK(ecode2)) {
44727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44728 }
44729 arg2 = static_cast< int >(val2);
44730 {
44731 PyThreadState* __tstate = wxPyBeginAllowThreads();
44732 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44733 wxPyEndAllowThreads(__tstate);
44734 if (PyErr_Occurred()) SWIG_fail;
44735 }
44736 {
44737 #if wxUSE_UNICODE
44738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44739 #else
44740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44741 #endif
44742 }
44743 return resultobj;
44744 fail:
44745 return NULL;
44746 }
44747
44748
44749 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44750 PyObject *resultobj = 0;
44751 wxMenu *arg1 = (wxMenu *) 0 ;
44752 wxString *arg2 = 0 ;
44753 void *argp1 = 0 ;
44754 int res1 = 0 ;
44755 bool temp2 = false ;
44756 PyObject * obj0 = 0 ;
44757 PyObject * obj1 = 0 ;
44758 char * kwnames[] = {
44759 (char *) "self",(char *) "title", NULL
44760 };
44761
44762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44764 if (!SWIG_IsOK(res1)) {
44765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44766 }
44767 arg1 = reinterpret_cast< wxMenu * >(argp1);
44768 {
44769 arg2 = wxString_in_helper(obj1);
44770 if (arg2 == NULL) SWIG_fail;
44771 temp2 = true;
44772 }
44773 {
44774 PyThreadState* __tstate = wxPyBeginAllowThreads();
44775 (arg1)->SetTitle((wxString const &)*arg2);
44776 wxPyEndAllowThreads(__tstate);
44777 if (PyErr_Occurred()) SWIG_fail;
44778 }
44779 resultobj = SWIG_Py_Void();
44780 {
44781 if (temp2)
44782 delete arg2;
44783 }
44784 return resultobj;
44785 fail:
44786 {
44787 if (temp2)
44788 delete arg2;
44789 }
44790 return NULL;
44791 }
44792
44793
44794 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44795 PyObject *resultobj = 0;
44796 wxMenu *arg1 = (wxMenu *) 0 ;
44797 wxString result;
44798 void *argp1 = 0 ;
44799 int res1 = 0 ;
44800 PyObject *swig_obj[1] ;
44801
44802 if (!args) SWIG_fail;
44803 swig_obj[0] = args;
44804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44805 if (!SWIG_IsOK(res1)) {
44806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44807 }
44808 arg1 = reinterpret_cast< wxMenu * >(argp1);
44809 {
44810 PyThreadState* __tstate = wxPyBeginAllowThreads();
44811 result = ((wxMenu const *)arg1)->GetTitle();
44812 wxPyEndAllowThreads(__tstate);
44813 if (PyErr_Occurred()) SWIG_fail;
44814 }
44815 {
44816 #if wxUSE_UNICODE
44817 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44818 #else
44819 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44820 #endif
44821 }
44822 return resultobj;
44823 fail:
44824 return NULL;
44825 }
44826
44827
44828 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44829 PyObject *resultobj = 0;
44830 wxMenu *arg1 = (wxMenu *) 0 ;
44831 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44832 void *argp1 = 0 ;
44833 int res1 = 0 ;
44834 void *argp2 = 0 ;
44835 int res2 = 0 ;
44836 PyObject * obj0 = 0 ;
44837 PyObject * obj1 = 0 ;
44838 char * kwnames[] = {
44839 (char *) "self",(char *) "handler", NULL
44840 };
44841
44842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44844 if (!SWIG_IsOK(res1)) {
44845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44846 }
44847 arg1 = reinterpret_cast< wxMenu * >(argp1);
44848 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44849 if (!SWIG_IsOK(res2)) {
44850 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44851 }
44852 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44853 {
44854 PyThreadState* __tstate = wxPyBeginAllowThreads();
44855 (arg1)->SetEventHandler(arg2);
44856 wxPyEndAllowThreads(__tstate);
44857 if (PyErr_Occurred()) SWIG_fail;
44858 }
44859 resultobj = SWIG_Py_Void();
44860 return resultobj;
44861 fail:
44862 return NULL;
44863 }
44864
44865
44866 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44867 PyObject *resultobj = 0;
44868 wxMenu *arg1 = (wxMenu *) 0 ;
44869 wxEvtHandler *result = 0 ;
44870 void *argp1 = 0 ;
44871 int res1 = 0 ;
44872 PyObject *swig_obj[1] ;
44873
44874 if (!args) SWIG_fail;
44875 swig_obj[0] = args;
44876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44877 if (!SWIG_IsOK(res1)) {
44878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44879 }
44880 arg1 = reinterpret_cast< wxMenu * >(argp1);
44881 {
44882 PyThreadState* __tstate = wxPyBeginAllowThreads();
44883 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44884 wxPyEndAllowThreads(__tstate);
44885 if (PyErr_Occurred()) SWIG_fail;
44886 }
44887 {
44888 resultobj = wxPyMake_wxObject(result, 0);
44889 }
44890 return resultobj;
44891 fail:
44892 return NULL;
44893 }
44894
44895
44896 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44897 PyObject *resultobj = 0;
44898 wxMenu *arg1 = (wxMenu *) 0 ;
44899 wxWindow *arg2 = (wxWindow *) 0 ;
44900 void *argp1 = 0 ;
44901 int res1 = 0 ;
44902 void *argp2 = 0 ;
44903 int res2 = 0 ;
44904 PyObject * obj0 = 0 ;
44905 PyObject * obj1 = 0 ;
44906 char * kwnames[] = {
44907 (char *) "self",(char *) "win", NULL
44908 };
44909
44910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44912 if (!SWIG_IsOK(res1)) {
44913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44914 }
44915 arg1 = reinterpret_cast< wxMenu * >(argp1);
44916 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44917 if (!SWIG_IsOK(res2)) {
44918 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44919 }
44920 arg2 = reinterpret_cast< wxWindow * >(argp2);
44921 {
44922 PyThreadState* __tstate = wxPyBeginAllowThreads();
44923 (arg1)->SetInvokingWindow(arg2);
44924 wxPyEndAllowThreads(__tstate);
44925 if (PyErr_Occurred()) SWIG_fail;
44926 }
44927 resultobj = SWIG_Py_Void();
44928 return resultobj;
44929 fail:
44930 return NULL;
44931 }
44932
44933
44934 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44935 PyObject *resultobj = 0;
44936 wxMenu *arg1 = (wxMenu *) 0 ;
44937 wxWindow *result = 0 ;
44938 void *argp1 = 0 ;
44939 int res1 = 0 ;
44940 PyObject *swig_obj[1] ;
44941
44942 if (!args) SWIG_fail;
44943 swig_obj[0] = args;
44944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44945 if (!SWIG_IsOK(res1)) {
44946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44947 }
44948 arg1 = reinterpret_cast< wxMenu * >(argp1);
44949 {
44950 PyThreadState* __tstate = wxPyBeginAllowThreads();
44951 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44952 wxPyEndAllowThreads(__tstate);
44953 if (PyErr_Occurred()) SWIG_fail;
44954 }
44955 {
44956 resultobj = wxPyMake_wxObject(result, 0);
44957 }
44958 return resultobj;
44959 fail:
44960 return NULL;
44961 }
44962
44963
44964 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44965 PyObject *resultobj = 0;
44966 wxMenu *arg1 = (wxMenu *) 0 ;
44967 long result;
44968 void *argp1 = 0 ;
44969 int res1 = 0 ;
44970 PyObject *swig_obj[1] ;
44971
44972 if (!args) SWIG_fail;
44973 swig_obj[0] = args;
44974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44975 if (!SWIG_IsOK(res1)) {
44976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44977 }
44978 arg1 = reinterpret_cast< wxMenu * >(argp1);
44979 {
44980 PyThreadState* __tstate = wxPyBeginAllowThreads();
44981 result = (long)((wxMenu const *)arg1)->GetStyle();
44982 wxPyEndAllowThreads(__tstate);
44983 if (PyErr_Occurred()) SWIG_fail;
44984 }
44985 resultobj = SWIG_From_long(static_cast< long >(result));
44986 return resultobj;
44987 fail:
44988 return NULL;
44989 }
44990
44991
44992 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44993 PyObject *resultobj = 0;
44994 wxMenu *arg1 = (wxMenu *) 0 ;
44995 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44996 void *argp1 = 0 ;
44997 int res1 = 0 ;
44998 void *argp2 = 0 ;
44999 int res2 = 0 ;
45000 PyObject * obj0 = 0 ;
45001 PyObject * obj1 = 0 ;
45002 char * kwnames[] = {
45003 (char *) "self",(char *) "source", NULL
45004 };
45005
45006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
45007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45008 if (!SWIG_IsOK(res1)) {
45009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
45010 }
45011 arg1 = reinterpret_cast< wxMenu * >(argp1);
45012 if (obj1) {
45013 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
45014 if (!SWIG_IsOK(res2)) {
45015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
45016 }
45017 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
45018 }
45019 {
45020 PyThreadState* __tstate = wxPyBeginAllowThreads();
45021 (arg1)->UpdateUI(arg2);
45022 wxPyEndAllowThreads(__tstate);
45023 if (PyErr_Occurred()) SWIG_fail;
45024 }
45025 resultobj = SWIG_Py_Void();
45026 return resultobj;
45027 fail:
45028 return NULL;
45029 }
45030
45031
45032 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45033 PyObject *resultobj = 0;
45034 wxMenu *arg1 = (wxMenu *) 0 ;
45035 wxMenuBar *result = 0 ;
45036 void *argp1 = 0 ;
45037 int res1 = 0 ;
45038 PyObject *swig_obj[1] ;
45039
45040 if (!args) SWIG_fail;
45041 swig_obj[0] = args;
45042 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45043 if (!SWIG_IsOK(res1)) {
45044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
45045 }
45046 arg1 = reinterpret_cast< wxMenu * >(argp1);
45047 {
45048 PyThreadState* __tstate = wxPyBeginAllowThreads();
45049 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
45050 wxPyEndAllowThreads(__tstate);
45051 if (PyErr_Occurred()) SWIG_fail;
45052 }
45053 {
45054 resultobj = wxPyMake_wxObject(result, (bool)0);
45055 }
45056 return resultobj;
45057 fail:
45058 return NULL;
45059 }
45060
45061
45062 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45063 PyObject *resultobj = 0;
45064 wxMenu *arg1 = (wxMenu *) 0 ;
45065 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
45066 void *argp1 = 0 ;
45067 int res1 = 0 ;
45068 void *argp2 = 0 ;
45069 int res2 = 0 ;
45070 PyObject * obj0 = 0 ;
45071 PyObject * obj1 = 0 ;
45072 char * kwnames[] = {
45073 (char *) "self",(char *) "menubar", NULL
45074 };
45075
45076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45078 if (!SWIG_IsOK(res1)) {
45079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
45080 }
45081 arg1 = reinterpret_cast< wxMenu * >(argp1);
45082 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
45083 if (!SWIG_IsOK(res2)) {
45084 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
45085 }
45086 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
45087 {
45088 PyThreadState* __tstate = wxPyBeginAllowThreads();
45089 (arg1)->Attach(arg2);
45090 wxPyEndAllowThreads(__tstate);
45091 if (PyErr_Occurred()) SWIG_fail;
45092 }
45093 resultobj = SWIG_Py_Void();
45094 return resultobj;
45095 fail:
45096 return NULL;
45097 }
45098
45099
45100 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45101 PyObject *resultobj = 0;
45102 wxMenu *arg1 = (wxMenu *) 0 ;
45103 void *argp1 = 0 ;
45104 int res1 = 0 ;
45105 PyObject *swig_obj[1] ;
45106
45107 if (!args) SWIG_fail;
45108 swig_obj[0] = args;
45109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45110 if (!SWIG_IsOK(res1)) {
45111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
45112 }
45113 arg1 = reinterpret_cast< wxMenu * >(argp1);
45114 {
45115 PyThreadState* __tstate = wxPyBeginAllowThreads();
45116 (arg1)->Detach();
45117 wxPyEndAllowThreads(__tstate);
45118 if (PyErr_Occurred()) SWIG_fail;
45119 }
45120 resultobj = SWIG_Py_Void();
45121 return resultobj;
45122 fail:
45123 return NULL;
45124 }
45125
45126
45127 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45128 PyObject *resultobj = 0;
45129 wxMenu *arg1 = (wxMenu *) 0 ;
45130 bool result;
45131 void *argp1 = 0 ;
45132 int res1 = 0 ;
45133 PyObject *swig_obj[1] ;
45134
45135 if (!args) SWIG_fail;
45136 swig_obj[0] = args;
45137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45138 if (!SWIG_IsOK(res1)) {
45139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
45140 }
45141 arg1 = reinterpret_cast< wxMenu * >(argp1);
45142 {
45143 PyThreadState* __tstate = wxPyBeginAllowThreads();
45144 result = (bool)((wxMenu const *)arg1)->IsAttached();
45145 wxPyEndAllowThreads(__tstate);
45146 if (PyErr_Occurred()) SWIG_fail;
45147 }
45148 {
45149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45150 }
45151 return resultobj;
45152 fail:
45153 return NULL;
45154 }
45155
45156
45157 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45158 PyObject *resultobj = 0;
45159 wxMenu *arg1 = (wxMenu *) 0 ;
45160 wxMenu *arg2 = (wxMenu *) 0 ;
45161 void *argp1 = 0 ;
45162 int res1 = 0 ;
45163 void *argp2 = 0 ;
45164 int res2 = 0 ;
45165 PyObject * obj0 = 0 ;
45166 PyObject * obj1 = 0 ;
45167 char * kwnames[] = {
45168 (char *) "self",(char *) "parent", NULL
45169 };
45170
45171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
45172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45173 if (!SWIG_IsOK(res1)) {
45174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
45175 }
45176 arg1 = reinterpret_cast< wxMenu * >(argp1);
45177 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45178 if (!SWIG_IsOK(res2)) {
45179 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
45180 }
45181 arg2 = reinterpret_cast< wxMenu * >(argp2);
45182 {
45183 PyThreadState* __tstate = wxPyBeginAllowThreads();
45184 (arg1)->SetParent(arg2);
45185 wxPyEndAllowThreads(__tstate);
45186 if (PyErr_Occurred()) SWIG_fail;
45187 }
45188 resultobj = SWIG_Py_Void();
45189 return resultobj;
45190 fail:
45191 return NULL;
45192 }
45193
45194
45195 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45196 PyObject *resultobj = 0;
45197 wxMenu *arg1 = (wxMenu *) 0 ;
45198 wxMenu *result = 0 ;
45199 void *argp1 = 0 ;
45200 int res1 = 0 ;
45201 PyObject *swig_obj[1] ;
45202
45203 if (!args) SWIG_fail;
45204 swig_obj[0] = args;
45205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45206 if (!SWIG_IsOK(res1)) {
45207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
45208 }
45209 arg1 = reinterpret_cast< wxMenu * >(argp1);
45210 {
45211 PyThreadState* __tstate = wxPyBeginAllowThreads();
45212 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
45213 wxPyEndAllowThreads(__tstate);
45214 if (PyErr_Occurred()) SWIG_fail;
45215 }
45216 {
45217 resultobj = wxPyMake_wxObject(result, 0);
45218 }
45219 return resultobj;
45220 fail:
45221 return NULL;
45222 }
45223
45224
45225 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45226 PyObject *obj;
45227 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45228 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
45229 return SWIG_Py_Void();
45230 }
45231
45232 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45233 return SWIG_Python_InitShadowInstance(args);
45234 }
45235
45236 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45237 PyObject *resultobj = 0;
45238 long arg1 = (long) 0 ;
45239 wxMenuBar *result = 0 ;
45240 long val1 ;
45241 int ecode1 = 0 ;
45242 PyObject * obj0 = 0 ;
45243 char * kwnames[] = {
45244 (char *) "style", NULL
45245 };
45246
45247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
45248 if (obj0) {
45249 ecode1 = SWIG_AsVal_long(obj0, &val1);
45250 if (!SWIG_IsOK(ecode1)) {
45251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
45252 }
45253 arg1 = static_cast< long >(val1);
45254 }
45255 {
45256 if (!wxPyCheckForApp()) SWIG_fail;
45257 PyThreadState* __tstate = wxPyBeginAllowThreads();
45258 result = (wxMenuBar *)new wxMenuBar(arg1);
45259 wxPyEndAllowThreads(__tstate);
45260 if (PyErr_Occurred()) SWIG_fail;
45261 }
45262 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
45263 return resultobj;
45264 fail:
45265 return NULL;
45266 }
45267
45268
45269 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45270 PyObject *resultobj = 0;
45271 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45272 wxMenu *arg2 = (wxMenu *) 0 ;
45273 wxString *arg3 = 0 ;
45274 bool result;
45275 void *argp1 = 0 ;
45276 int res1 = 0 ;
45277 void *argp2 = 0 ;
45278 int res2 = 0 ;
45279 bool temp3 = false ;
45280 PyObject * obj0 = 0 ;
45281 PyObject * obj1 = 0 ;
45282 PyObject * obj2 = 0 ;
45283 char * kwnames[] = {
45284 (char *) "self",(char *) "menu",(char *) "title", NULL
45285 };
45286
45287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45289 if (!SWIG_IsOK(res1)) {
45290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45291 }
45292 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45294 if (!SWIG_IsOK(res2)) {
45295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
45296 }
45297 arg2 = reinterpret_cast< wxMenu * >(argp2);
45298 {
45299 arg3 = wxString_in_helper(obj2);
45300 if (arg3 == NULL) SWIG_fail;
45301 temp3 = true;
45302 }
45303 {
45304 PyThreadState* __tstate = wxPyBeginAllowThreads();
45305 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
45306 wxPyEndAllowThreads(__tstate);
45307 if (PyErr_Occurred()) SWIG_fail;
45308 }
45309 {
45310 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45311 }
45312 {
45313 if (temp3)
45314 delete arg3;
45315 }
45316 return resultobj;
45317 fail:
45318 {
45319 if (temp3)
45320 delete arg3;
45321 }
45322 return NULL;
45323 }
45324
45325
45326 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45327 PyObject *resultobj = 0;
45328 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45329 size_t arg2 ;
45330 wxMenu *arg3 = (wxMenu *) 0 ;
45331 wxString *arg4 = 0 ;
45332 bool result;
45333 void *argp1 = 0 ;
45334 int res1 = 0 ;
45335 size_t val2 ;
45336 int ecode2 = 0 ;
45337 void *argp3 = 0 ;
45338 int res3 = 0 ;
45339 bool temp4 = false ;
45340 PyObject * obj0 = 0 ;
45341 PyObject * obj1 = 0 ;
45342 PyObject * obj2 = 0 ;
45343 PyObject * obj3 = 0 ;
45344 char * kwnames[] = {
45345 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45346 };
45347
45348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45350 if (!SWIG_IsOK(res1)) {
45351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45352 }
45353 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45354 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45355 if (!SWIG_IsOK(ecode2)) {
45356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
45357 }
45358 arg2 = static_cast< size_t >(val2);
45359 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45360 if (!SWIG_IsOK(res3)) {
45361 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
45362 }
45363 arg3 = reinterpret_cast< wxMenu * >(argp3);
45364 {
45365 arg4 = wxString_in_helper(obj3);
45366 if (arg4 == NULL) SWIG_fail;
45367 temp4 = true;
45368 }
45369 {
45370 PyThreadState* __tstate = wxPyBeginAllowThreads();
45371 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
45372 wxPyEndAllowThreads(__tstate);
45373 if (PyErr_Occurred()) SWIG_fail;
45374 }
45375 {
45376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45377 }
45378 {
45379 if (temp4)
45380 delete arg4;
45381 }
45382 return resultobj;
45383 fail:
45384 {
45385 if (temp4)
45386 delete arg4;
45387 }
45388 return NULL;
45389 }
45390
45391
45392 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45393 PyObject *resultobj = 0;
45394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45395 size_t result;
45396 void *argp1 = 0 ;
45397 int res1 = 0 ;
45398 PyObject *swig_obj[1] ;
45399
45400 if (!args) SWIG_fail;
45401 swig_obj[0] = args;
45402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45403 if (!SWIG_IsOK(res1)) {
45404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45405 }
45406 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45407 {
45408 PyThreadState* __tstate = wxPyBeginAllowThreads();
45409 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
45410 wxPyEndAllowThreads(__tstate);
45411 if (PyErr_Occurred()) SWIG_fail;
45412 }
45413 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
45414 return resultobj;
45415 fail:
45416 return NULL;
45417 }
45418
45419
45420 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45421 PyObject *resultobj = 0;
45422 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45423 size_t arg2 ;
45424 wxMenu *result = 0 ;
45425 void *argp1 = 0 ;
45426 int res1 = 0 ;
45427 size_t val2 ;
45428 int ecode2 = 0 ;
45429 PyObject * obj0 = 0 ;
45430 PyObject * obj1 = 0 ;
45431 char * kwnames[] = {
45432 (char *) "self",(char *) "pos", NULL
45433 };
45434
45435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45437 if (!SWIG_IsOK(res1)) {
45438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45439 }
45440 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45441 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45442 if (!SWIG_IsOK(ecode2)) {
45443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
45444 }
45445 arg2 = static_cast< size_t >(val2);
45446 {
45447 PyThreadState* __tstate = wxPyBeginAllowThreads();
45448 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
45449 wxPyEndAllowThreads(__tstate);
45450 if (PyErr_Occurred()) SWIG_fail;
45451 }
45452 {
45453 resultobj = wxPyMake_wxObject(result, 0);
45454 }
45455 return resultobj;
45456 fail:
45457 return NULL;
45458 }
45459
45460
45461 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45462 PyObject *resultobj = 0;
45463 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45464 size_t arg2 ;
45465 wxMenu *arg3 = (wxMenu *) 0 ;
45466 wxString *arg4 = 0 ;
45467 wxMenu *result = 0 ;
45468 void *argp1 = 0 ;
45469 int res1 = 0 ;
45470 size_t val2 ;
45471 int ecode2 = 0 ;
45472 void *argp3 = 0 ;
45473 int res3 = 0 ;
45474 bool temp4 = false ;
45475 PyObject * obj0 = 0 ;
45476 PyObject * obj1 = 0 ;
45477 PyObject * obj2 = 0 ;
45478 PyObject * obj3 = 0 ;
45479 char * kwnames[] = {
45480 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
45481 };
45482
45483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
45484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45485 if (!SWIG_IsOK(res1)) {
45486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45487 }
45488 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45489 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45490 if (!SWIG_IsOK(ecode2)) {
45491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
45492 }
45493 arg2 = static_cast< size_t >(val2);
45494 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
45495 if (!SWIG_IsOK(res3)) {
45496 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
45497 }
45498 arg3 = reinterpret_cast< wxMenu * >(argp3);
45499 {
45500 arg4 = wxString_in_helper(obj3);
45501 if (arg4 == NULL) SWIG_fail;
45502 temp4 = true;
45503 }
45504 {
45505 PyThreadState* __tstate = wxPyBeginAllowThreads();
45506 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
45507 wxPyEndAllowThreads(__tstate);
45508 if (PyErr_Occurred()) SWIG_fail;
45509 }
45510 {
45511 resultobj = wxPyMake_wxObject(result, 0);
45512 }
45513 {
45514 if (temp4)
45515 delete arg4;
45516 }
45517 return resultobj;
45518 fail:
45519 {
45520 if (temp4)
45521 delete arg4;
45522 }
45523 return NULL;
45524 }
45525
45526
45527 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45528 PyObject *resultobj = 0;
45529 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45530 size_t arg2 ;
45531 wxMenu *result = 0 ;
45532 void *argp1 = 0 ;
45533 int res1 = 0 ;
45534 size_t val2 ;
45535 int ecode2 = 0 ;
45536 PyObject * obj0 = 0 ;
45537 PyObject * obj1 = 0 ;
45538 char * kwnames[] = {
45539 (char *) "self",(char *) "pos", NULL
45540 };
45541
45542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
45543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45544 if (!SWIG_IsOK(res1)) {
45545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45546 }
45547 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45548 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45549 if (!SWIG_IsOK(ecode2)) {
45550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
45551 }
45552 arg2 = static_cast< size_t >(val2);
45553 {
45554 PyThreadState* __tstate = wxPyBeginAllowThreads();
45555 result = (wxMenu *)(arg1)->Remove(arg2);
45556 wxPyEndAllowThreads(__tstate);
45557 if (PyErr_Occurred()) SWIG_fail;
45558 }
45559 {
45560 resultobj = wxPyMake_wxObject(result, 0);
45561 }
45562 return resultobj;
45563 fail:
45564 return NULL;
45565 }
45566
45567
45568 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45569 PyObject *resultobj = 0;
45570 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45571 size_t arg2 ;
45572 bool arg3 ;
45573 void *argp1 = 0 ;
45574 int res1 = 0 ;
45575 size_t val2 ;
45576 int ecode2 = 0 ;
45577 bool val3 ;
45578 int ecode3 = 0 ;
45579 PyObject * obj0 = 0 ;
45580 PyObject * obj1 = 0 ;
45581 PyObject * obj2 = 0 ;
45582 char * kwnames[] = {
45583 (char *) "self",(char *) "pos",(char *) "enable", NULL
45584 };
45585
45586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45588 if (!SWIG_IsOK(res1)) {
45589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45590 }
45591 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45592 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45593 if (!SWIG_IsOK(ecode2)) {
45594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
45595 }
45596 arg2 = static_cast< size_t >(val2);
45597 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45598 if (!SWIG_IsOK(ecode3)) {
45599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
45600 }
45601 arg3 = static_cast< bool >(val3);
45602 {
45603 PyThreadState* __tstate = wxPyBeginAllowThreads();
45604 (arg1)->EnableTop(arg2,arg3);
45605 wxPyEndAllowThreads(__tstate);
45606 if (PyErr_Occurred()) SWIG_fail;
45607 }
45608 resultobj = SWIG_Py_Void();
45609 return resultobj;
45610 fail:
45611 return NULL;
45612 }
45613
45614
45615 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45616 PyObject *resultobj = 0;
45617 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45618 size_t arg2 ;
45619 bool result;
45620 void *argp1 = 0 ;
45621 int res1 = 0 ;
45622 size_t val2 ;
45623 int ecode2 = 0 ;
45624 PyObject * obj0 = 0 ;
45625 PyObject * obj1 = 0 ;
45626 char * kwnames[] = {
45627 (char *) "self",(char *) "pos", NULL
45628 };
45629
45630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
45631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45632 if (!SWIG_IsOK(res1)) {
45633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45634 }
45635 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45636 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45637 if (!SWIG_IsOK(ecode2)) {
45638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
45639 }
45640 arg2 = static_cast< size_t >(val2);
45641 {
45642 PyThreadState* __tstate = wxPyBeginAllowThreads();
45643 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
45644 wxPyEndAllowThreads(__tstate);
45645 if (PyErr_Occurred()) SWIG_fail;
45646 }
45647 {
45648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45649 }
45650 return resultobj;
45651 fail:
45652 return NULL;
45653 }
45654
45655
45656 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45657 PyObject *resultobj = 0;
45658 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45659 size_t arg2 ;
45660 wxString *arg3 = 0 ;
45661 void *argp1 = 0 ;
45662 int res1 = 0 ;
45663 size_t val2 ;
45664 int ecode2 = 0 ;
45665 bool temp3 = false ;
45666 PyObject * obj0 = 0 ;
45667 PyObject * obj1 = 0 ;
45668 PyObject * obj2 = 0 ;
45669 char * kwnames[] = {
45670 (char *) "self",(char *) "pos",(char *) "label", NULL
45671 };
45672
45673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45675 if (!SWIG_IsOK(res1)) {
45676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45677 }
45678 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45679 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45680 if (!SWIG_IsOK(ecode2)) {
45681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45682 }
45683 arg2 = static_cast< size_t >(val2);
45684 {
45685 arg3 = wxString_in_helper(obj2);
45686 if (arg3 == NULL) SWIG_fail;
45687 temp3 = true;
45688 }
45689 {
45690 PyThreadState* __tstate = wxPyBeginAllowThreads();
45691 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45692 wxPyEndAllowThreads(__tstate);
45693 if (PyErr_Occurred()) SWIG_fail;
45694 }
45695 resultobj = SWIG_Py_Void();
45696 {
45697 if (temp3)
45698 delete arg3;
45699 }
45700 return resultobj;
45701 fail:
45702 {
45703 if (temp3)
45704 delete arg3;
45705 }
45706 return NULL;
45707 }
45708
45709
45710 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45711 PyObject *resultobj = 0;
45712 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45713 size_t arg2 ;
45714 wxString result;
45715 void *argp1 = 0 ;
45716 int res1 = 0 ;
45717 size_t val2 ;
45718 int ecode2 = 0 ;
45719 PyObject * obj0 = 0 ;
45720 PyObject * obj1 = 0 ;
45721 char * kwnames[] = {
45722 (char *) "self",(char *) "pos", NULL
45723 };
45724
45725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45727 if (!SWIG_IsOK(res1)) {
45728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45729 }
45730 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45731 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45732 if (!SWIG_IsOK(ecode2)) {
45733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45734 }
45735 arg2 = static_cast< size_t >(val2);
45736 {
45737 PyThreadState* __tstate = wxPyBeginAllowThreads();
45738 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45739 wxPyEndAllowThreads(__tstate);
45740 if (PyErr_Occurred()) SWIG_fail;
45741 }
45742 {
45743 #if wxUSE_UNICODE
45744 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45745 #else
45746 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45747 #endif
45748 }
45749 return resultobj;
45750 fail:
45751 return NULL;
45752 }
45753
45754
45755 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45756 PyObject *resultobj = 0;
45757 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45758 wxString *arg2 = 0 ;
45759 wxString *arg3 = 0 ;
45760 int result;
45761 void *argp1 = 0 ;
45762 int res1 = 0 ;
45763 bool temp2 = false ;
45764 bool temp3 = false ;
45765 PyObject * obj0 = 0 ;
45766 PyObject * obj1 = 0 ;
45767 PyObject * obj2 = 0 ;
45768 char * kwnames[] = {
45769 (char *) "self",(char *) "menu",(char *) "item", NULL
45770 };
45771
45772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45774 if (!SWIG_IsOK(res1)) {
45775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45776 }
45777 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45778 {
45779 arg2 = wxString_in_helper(obj1);
45780 if (arg2 == NULL) SWIG_fail;
45781 temp2 = true;
45782 }
45783 {
45784 arg3 = wxString_in_helper(obj2);
45785 if (arg3 == NULL) SWIG_fail;
45786 temp3 = true;
45787 }
45788 {
45789 PyThreadState* __tstate = wxPyBeginAllowThreads();
45790 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45791 wxPyEndAllowThreads(__tstate);
45792 if (PyErr_Occurred()) SWIG_fail;
45793 }
45794 resultobj = SWIG_From_int(static_cast< int >(result));
45795 {
45796 if (temp2)
45797 delete arg2;
45798 }
45799 {
45800 if (temp3)
45801 delete arg3;
45802 }
45803 return resultobj;
45804 fail:
45805 {
45806 if (temp2)
45807 delete arg2;
45808 }
45809 {
45810 if (temp3)
45811 delete arg3;
45812 }
45813 return NULL;
45814 }
45815
45816
45817 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45818 PyObject *resultobj = 0;
45819 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45820 int arg2 ;
45821 wxMenuItem *result = 0 ;
45822 void *argp1 = 0 ;
45823 int res1 = 0 ;
45824 int val2 ;
45825 int ecode2 = 0 ;
45826 PyObject * obj0 = 0 ;
45827 PyObject * obj1 = 0 ;
45828 char * kwnames[] = {
45829 (char *) "self",(char *) "id", NULL
45830 };
45831
45832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45834 if (!SWIG_IsOK(res1)) {
45835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45836 }
45837 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45838 ecode2 = SWIG_AsVal_int(obj1, &val2);
45839 if (!SWIG_IsOK(ecode2)) {
45840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45841 }
45842 arg2 = static_cast< int >(val2);
45843 {
45844 PyThreadState* __tstate = wxPyBeginAllowThreads();
45845 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45846 wxPyEndAllowThreads(__tstate);
45847 if (PyErr_Occurred()) SWIG_fail;
45848 }
45849 {
45850 resultobj = wxPyMake_wxObject(result, (bool)0);
45851 }
45852 return resultobj;
45853 fail:
45854 return NULL;
45855 }
45856
45857
45858 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45859 PyObject *resultobj = 0;
45860 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45861 wxString *arg2 = 0 ;
45862 int result;
45863 void *argp1 = 0 ;
45864 int res1 = 0 ;
45865 bool temp2 = false ;
45866 PyObject * obj0 = 0 ;
45867 PyObject * obj1 = 0 ;
45868 char * kwnames[] = {
45869 (char *) "self",(char *) "title", NULL
45870 };
45871
45872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45874 if (!SWIG_IsOK(res1)) {
45875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45876 }
45877 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45878 {
45879 arg2 = wxString_in_helper(obj1);
45880 if (arg2 == NULL) SWIG_fail;
45881 temp2 = true;
45882 }
45883 {
45884 PyThreadState* __tstate = wxPyBeginAllowThreads();
45885 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45886 wxPyEndAllowThreads(__tstate);
45887 if (PyErr_Occurred()) SWIG_fail;
45888 }
45889 resultobj = SWIG_From_int(static_cast< int >(result));
45890 {
45891 if (temp2)
45892 delete arg2;
45893 }
45894 return resultobj;
45895 fail:
45896 {
45897 if (temp2)
45898 delete arg2;
45899 }
45900 return NULL;
45901 }
45902
45903
45904 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45905 PyObject *resultobj = 0;
45906 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45907 int arg2 ;
45908 bool arg3 ;
45909 void *argp1 = 0 ;
45910 int res1 = 0 ;
45911 int val2 ;
45912 int ecode2 = 0 ;
45913 bool val3 ;
45914 int ecode3 = 0 ;
45915 PyObject * obj0 = 0 ;
45916 PyObject * obj1 = 0 ;
45917 PyObject * obj2 = 0 ;
45918 char * kwnames[] = {
45919 (char *) "self",(char *) "id",(char *) "enable", NULL
45920 };
45921
45922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45924 if (!SWIG_IsOK(res1)) {
45925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45926 }
45927 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45928 ecode2 = SWIG_AsVal_int(obj1, &val2);
45929 if (!SWIG_IsOK(ecode2)) {
45930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45931 }
45932 arg2 = static_cast< int >(val2);
45933 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45934 if (!SWIG_IsOK(ecode3)) {
45935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45936 }
45937 arg3 = static_cast< bool >(val3);
45938 {
45939 PyThreadState* __tstate = wxPyBeginAllowThreads();
45940 (arg1)->Enable(arg2,arg3);
45941 wxPyEndAllowThreads(__tstate);
45942 if (PyErr_Occurred()) SWIG_fail;
45943 }
45944 resultobj = SWIG_Py_Void();
45945 return resultobj;
45946 fail:
45947 return NULL;
45948 }
45949
45950
45951 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45952 PyObject *resultobj = 0;
45953 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45954 int arg2 ;
45955 bool arg3 ;
45956 void *argp1 = 0 ;
45957 int res1 = 0 ;
45958 int val2 ;
45959 int ecode2 = 0 ;
45960 bool val3 ;
45961 int ecode3 = 0 ;
45962 PyObject * obj0 = 0 ;
45963 PyObject * obj1 = 0 ;
45964 PyObject * obj2 = 0 ;
45965 char * kwnames[] = {
45966 (char *) "self",(char *) "id",(char *) "check", NULL
45967 };
45968
45969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45971 if (!SWIG_IsOK(res1)) {
45972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45973 }
45974 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45975 ecode2 = SWIG_AsVal_int(obj1, &val2);
45976 if (!SWIG_IsOK(ecode2)) {
45977 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45978 }
45979 arg2 = static_cast< int >(val2);
45980 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45981 if (!SWIG_IsOK(ecode3)) {
45982 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45983 }
45984 arg3 = static_cast< bool >(val3);
45985 {
45986 PyThreadState* __tstate = wxPyBeginAllowThreads();
45987 (arg1)->Check(arg2,arg3);
45988 wxPyEndAllowThreads(__tstate);
45989 if (PyErr_Occurred()) SWIG_fail;
45990 }
45991 resultobj = SWIG_Py_Void();
45992 return resultobj;
45993 fail:
45994 return NULL;
45995 }
45996
45997
45998 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45999 PyObject *resultobj = 0;
46000 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46001 int arg2 ;
46002 bool result;
46003 void *argp1 = 0 ;
46004 int res1 = 0 ;
46005 int val2 ;
46006 int ecode2 = 0 ;
46007 PyObject * obj0 = 0 ;
46008 PyObject * obj1 = 0 ;
46009 char * kwnames[] = {
46010 (char *) "self",(char *) "id", NULL
46011 };
46012
46013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
46014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46015 if (!SWIG_IsOK(res1)) {
46016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46017 }
46018 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46019 ecode2 = SWIG_AsVal_int(obj1, &val2);
46020 if (!SWIG_IsOK(ecode2)) {
46021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
46022 }
46023 arg2 = static_cast< int >(val2);
46024 {
46025 PyThreadState* __tstate = wxPyBeginAllowThreads();
46026 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
46027 wxPyEndAllowThreads(__tstate);
46028 if (PyErr_Occurred()) SWIG_fail;
46029 }
46030 {
46031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46032 }
46033 return resultobj;
46034 fail:
46035 return NULL;
46036 }
46037
46038
46039 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46040 PyObject *resultobj = 0;
46041 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46042 int arg2 ;
46043 bool result;
46044 void *argp1 = 0 ;
46045 int res1 = 0 ;
46046 int val2 ;
46047 int ecode2 = 0 ;
46048 PyObject * obj0 = 0 ;
46049 PyObject * obj1 = 0 ;
46050 char * kwnames[] = {
46051 (char *) "self",(char *) "id", NULL
46052 };
46053
46054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
46055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46056 if (!SWIG_IsOK(res1)) {
46057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46058 }
46059 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46060 ecode2 = SWIG_AsVal_int(obj1, &val2);
46061 if (!SWIG_IsOK(ecode2)) {
46062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
46063 }
46064 arg2 = static_cast< int >(val2);
46065 {
46066 PyThreadState* __tstate = wxPyBeginAllowThreads();
46067 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
46068 wxPyEndAllowThreads(__tstate);
46069 if (PyErr_Occurred()) SWIG_fail;
46070 }
46071 {
46072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46073 }
46074 return resultobj;
46075 fail:
46076 return NULL;
46077 }
46078
46079
46080 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46081 PyObject *resultobj = 0;
46082 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46083 int arg2 ;
46084 wxString *arg3 = 0 ;
46085 void *argp1 = 0 ;
46086 int res1 = 0 ;
46087 int val2 ;
46088 int ecode2 = 0 ;
46089 bool temp3 = false ;
46090 PyObject * obj0 = 0 ;
46091 PyObject * obj1 = 0 ;
46092 PyObject * obj2 = 0 ;
46093 char * kwnames[] = {
46094 (char *) "self",(char *) "id",(char *) "label", NULL
46095 };
46096
46097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46099 if (!SWIG_IsOK(res1)) {
46100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46101 }
46102 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46103 ecode2 = SWIG_AsVal_int(obj1, &val2);
46104 if (!SWIG_IsOK(ecode2)) {
46105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
46106 }
46107 arg2 = static_cast< int >(val2);
46108 {
46109 arg3 = wxString_in_helper(obj2);
46110 if (arg3 == NULL) SWIG_fail;
46111 temp3 = true;
46112 }
46113 {
46114 PyThreadState* __tstate = wxPyBeginAllowThreads();
46115 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
46116 wxPyEndAllowThreads(__tstate);
46117 if (PyErr_Occurred()) SWIG_fail;
46118 }
46119 resultobj = SWIG_Py_Void();
46120 {
46121 if (temp3)
46122 delete arg3;
46123 }
46124 return resultobj;
46125 fail:
46126 {
46127 if (temp3)
46128 delete arg3;
46129 }
46130 return NULL;
46131 }
46132
46133
46134 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46135 PyObject *resultobj = 0;
46136 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46137 int arg2 ;
46138 wxString result;
46139 void *argp1 = 0 ;
46140 int res1 = 0 ;
46141 int val2 ;
46142 int ecode2 = 0 ;
46143 PyObject * obj0 = 0 ;
46144 PyObject * obj1 = 0 ;
46145 char * kwnames[] = {
46146 (char *) "self",(char *) "id", NULL
46147 };
46148
46149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
46150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46151 if (!SWIG_IsOK(res1)) {
46152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46153 }
46154 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46155 ecode2 = SWIG_AsVal_int(obj1, &val2);
46156 if (!SWIG_IsOK(ecode2)) {
46157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
46158 }
46159 arg2 = static_cast< int >(val2);
46160 {
46161 PyThreadState* __tstate = wxPyBeginAllowThreads();
46162 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
46163 wxPyEndAllowThreads(__tstate);
46164 if (PyErr_Occurred()) SWIG_fail;
46165 }
46166 {
46167 #if wxUSE_UNICODE
46168 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46169 #else
46170 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46171 #endif
46172 }
46173 return resultobj;
46174 fail:
46175 return NULL;
46176 }
46177
46178
46179 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46180 PyObject *resultobj = 0;
46181 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46182 int arg2 ;
46183 wxString *arg3 = 0 ;
46184 void *argp1 = 0 ;
46185 int res1 = 0 ;
46186 int val2 ;
46187 int ecode2 = 0 ;
46188 bool temp3 = false ;
46189 PyObject * obj0 = 0 ;
46190 PyObject * obj1 = 0 ;
46191 PyObject * obj2 = 0 ;
46192 char * kwnames[] = {
46193 (char *) "self",(char *) "id",(char *) "helpString", NULL
46194 };
46195
46196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46198 if (!SWIG_IsOK(res1)) {
46199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46200 }
46201 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46202 ecode2 = SWIG_AsVal_int(obj1, &val2);
46203 if (!SWIG_IsOK(ecode2)) {
46204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
46205 }
46206 arg2 = static_cast< int >(val2);
46207 {
46208 arg3 = wxString_in_helper(obj2);
46209 if (arg3 == NULL) SWIG_fail;
46210 temp3 = true;
46211 }
46212 {
46213 PyThreadState* __tstate = wxPyBeginAllowThreads();
46214 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
46215 wxPyEndAllowThreads(__tstate);
46216 if (PyErr_Occurred()) SWIG_fail;
46217 }
46218 resultobj = SWIG_Py_Void();
46219 {
46220 if (temp3)
46221 delete arg3;
46222 }
46223 return resultobj;
46224 fail:
46225 {
46226 if (temp3)
46227 delete arg3;
46228 }
46229 return NULL;
46230 }
46231
46232
46233 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46234 PyObject *resultobj = 0;
46235 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46236 int arg2 ;
46237 wxString result;
46238 void *argp1 = 0 ;
46239 int res1 = 0 ;
46240 int val2 ;
46241 int ecode2 = 0 ;
46242 PyObject * obj0 = 0 ;
46243 PyObject * obj1 = 0 ;
46244 char * kwnames[] = {
46245 (char *) "self",(char *) "id", NULL
46246 };
46247
46248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
46249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46250 if (!SWIG_IsOK(res1)) {
46251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46252 }
46253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46254 ecode2 = SWIG_AsVal_int(obj1, &val2);
46255 if (!SWIG_IsOK(ecode2)) {
46256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
46257 }
46258 arg2 = static_cast< int >(val2);
46259 {
46260 PyThreadState* __tstate = wxPyBeginAllowThreads();
46261 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
46262 wxPyEndAllowThreads(__tstate);
46263 if (PyErr_Occurred()) SWIG_fail;
46264 }
46265 {
46266 #if wxUSE_UNICODE
46267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46268 #else
46269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46270 #endif
46271 }
46272 return resultobj;
46273 fail:
46274 return NULL;
46275 }
46276
46277
46278 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46279 PyObject *resultobj = 0;
46280 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46281 wxFrame *result = 0 ;
46282 void *argp1 = 0 ;
46283 int res1 = 0 ;
46284 PyObject *swig_obj[1] ;
46285
46286 if (!args) SWIG_fail;
46287 swig_obj[0] = args;
46288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46289 if (!SWIG_IsOK(res1)) {
46290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46291 }
46292 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46293 {
46294 PyThreadState* __tstate = wxPyBeginAllowThreads();
46295 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
46296 wxPyEndAllowThreads(__tstate);
46297 if (PyErr_Occurred()) SWIG_fail;
46298 }
46299 {
46300 resultobj = wxPyMake_wxObject(result, (bool)0);
46301 }
46302 return resultobj;
46303 fail:
46304 return NULL;
46305 }
46306
46307
46308 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46309 PyObject *resultobj = 0;
46310 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46311 bool result;
46312 void *argp1 = 0 ;
46313 int res1 = 0 ;
46314 PyObject *swig_obj[1] ;
46315
46316 if (!args) SWIG_fail;
46317 swig_obj[0] = args;
46318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46319 if (!SWIG_IsOK(res1)) {
46320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
46321 }
46322 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46323 {
46324 PyThreadState* __tstate = wxPyBeginAllowThreads();
46325 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 {
46330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46331 }
46332 return resultobj;
46333 fail:
46334 return NULL;
46335 }
46336
46337
46338 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46339 PyObject *resultobj = 0;
46340 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46341 wxFrame *arg2 = (wxFrame *) 0 ;
46342 void *argp1 = 0 ;
46343 int res1 = 0 ;
46344 void *argp2 = 0 ;
46345 int res2 = 0 ;
46346 PyObject * obj0 = 0 ;
46347 PyObject * obj1 = 0 ;
46348 char * kwnames[] = {
46349 (char *) "self",(char *) "frame", NULL
46350 };
46351
46352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
46353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46354 if (!SWIG_IsOK(res1)) {
46355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46356 }
46357 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46358 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
46359 if (!SWIG_IsOK(res2)) {
46360 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
46361 }
46362 arg2 = reinterpret_cast< wxFrame * >(argp2);
46363 {
46364 PyThreadState* __tstate = wxPyBeginAllowThreads();
46365 (arg1)->Attach(arg2);
46366 wxPyEndAllowThreads(__tstate);
46367 if (PyErr_Occurred()) SWIG_fail;
46368 }
46369 resultobj = SWIG_Py_Void();
46370 return resultobj;
46371 fail:
46372 return NULL;
46373 }
46374
46375
46376 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46377 PyObject *resultobj = 0;
46378 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46379 void *argp1 = 0 ;
46380 int res1 = 0 ;
46381 PyObject *swig_obj[1] ;
46382
46383 if (!args) SWIG_fail;
46384 swig_obj[0] = args;
46385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46386 if (!SWIG_IsOK(res1)) {
46387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46388 }
46389 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46390 {
46391 PyThreadState* __tstate = wxPyBeginAllowThreads();
46392 (arg1)->Detach();
46393 wxPyEndAllowThreads(__tstate);
46394 if (PyErr_Occurred()) SWIG_fail;
46395 }
46396 resultobj = SWIG_Py_Void();
46397 return resultobj;
46398 fail:
46399 return NULL;
46400 }
46401
46402
46403 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46404 PyObject *resultobj = 0;
46405 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
46406 void *argp1 = 0 ;
46407 int res1 = 0 ;
46408 PyObject *swig_obj[1] ;
46409
46410 if (!args) SWIG_fail;
46411 swig_obj[0] = args;
46412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
46413 if (!SWIG_IsOK(res1)) {
46414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
46415 }
46416 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
46417 {
46418 PyThreadState* __tstate = wxPyBeginAllowThreads();
46419 (arg1)->UpdateMenus();
46420 wxPyEndAllowThreads(__tstate);
46421 if (PyErr_Occurred()) SWIG_fail;
46422 }
46423 resultobj = SWIG_Py_Void();
46424 return resultobj;
46425 fail:
46426 return NULL;
46427 }
46428
46429
46430 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46431 PyObject *resultobj = 0;
46432 bool arg1 ;
46433 bool val1 ;
46434 int ecode1 = 0 ;
46435 PyObject * obj0 = 0 ;
46436 char * kwnames[] = {
46437 (char *) "enable", NULL
46438 };
46439
46440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
46441 ecode1 = SWIG_AsVal_bool(obj0, &val1);
46442 if (!SWIG_IsOK(ecode1)) {
46443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
46444 }
46445 arg1 = static_cast< bool >(val1);
46446 {
46447 PyThreadState* __tstate = wxPyBeginAllowThreads();
46448 wxMenuBar_SetAutoWindowMenu(arg1);
46449 wxPyEndAllowThreads(__tstate);
46450 if (PyErr_Occurred()) SWIG_fail;
46451 }
46452 resultobj = SWIG_Py_Void();
46453 return resultobj;
46454 fail:
46455 return NULL;
46456 }
46457
46458
46459 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46460 PyObject *resultobj = 0;
46461 bool result;
46462
46463 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
46464 {
46465 PyThreadState* __tstate = wxPyBeginAllowThreads();
46466 result = (bool)wxMenuBar_GetAutoWindowMenu();
46467 wxPyEndAllowThreads(__tstate);
46468 if (PyErr_Occurred()) SWIG_fail;
46469 }
46470 {
46471 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46472 }
46473 return resultobj;
46474 fail:
46475 return NULL;
46476 }
46477
46478
46479 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46480 PyObject *obj;
46481 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46482 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
46483 return SWIG_Py_Void();
46484 }
46485
46486 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46487 return SWIG_Python_InitShadowInstance(args);
46488 }
46489
46490 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46491 PyObject *resultobj = 0;
46492 wxMenu *arg1 = (wxMenu *) NULL ;
46493 int arg2 = (int) wxID_SEPARATOR ;
46494 wxString const &arg3_defvalue = wxPyEmptyString ;
46495 wxString *arg3 = (wxString *) &arg3_defvalue ;
46496 wxString const &arg4_defvalue = wxPyEmptyString ;
46497 wxString *arg4 = (wxString *) &arg4_defvalue ;
46498 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
46499 wxMenu *arg6 = (wxMenu *) NULL ;
46500 wxMenuItem *result = 0 ;
46501 void *argp1 = 0 ;
46502 int res1 = 0 ;
46503 int val2 ;
46504 int ecode2 = 0 ;
46505 bool temp3 = false ;
46506 bool temp4 = false ;
46507 int val5 ;
46508 int ecode5 = 0 ;
46509 void *argp6 = 0 ;
46510 int res6 = 0 ;
46511 PyObject * obj0 = 0 ;
46512 PyObject * obj1 = 0 ;
46513 PyObject * obj2 = 0 ;
46514 PyObject * obj3 = 0 ;
46515 PyObject * obj4 = 0 ;
46516 PyObject * obj5 = 0 ;
46517 char * kwnames[] = {
46518 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
46519 };
46520
46521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46522 if (obj0) {
46523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
46524 if (!SWIG_IsOK(res1)) {
46525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
46526 }
46527 arg1 = reinterpret_cast< wxMenu * >(argp1);
46528 }
46529 if (obj1) {
46530 ecode2 = SWIG_AsVal_int(obj1, &val2);
46531 if (!SWIG_IsOK(ecode2)) {
46532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
46533 }
46534 arg2 = static_cast< int >(val2);
46535 }
46536 if (obj2) {
46537 {
46538 arg3 = wxString_in_helper(obj2);
46539 if (arg3 == NULL) SWIG_fail;
46540 temp3 = true;
46541 }
46542 }
46543 if (obj3) {
46544 {
46545 arg4 = wxString_in_helper(obj3);
46546 if (arg4 == NULL) SWIG_fail;
46547 temp4 = true;
46548 }
46549 }
46550 if (obj4) {
46551 ecode5 = SWIG_AsVal_int(obj4, &val5);
46552 if (!SWIG_IsOK(ecode5)) {
46553 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
46554 }
46555 arg5 = static_cast< wxItemKind >(val5);
46556 }
46557 if (obj5) {
46558 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
46559 if (!SWIG_IsOK(res6)) {
46560 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
46561 }
46562 arg6 = reinterpret_cast< wxMenu * >(argp6);
46563 }
46564 {
46565 PyThreadState* __tstate = wxPyBeginAllowThreads();
46566 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
46567 wxPyEndAllowThreads(__tstate);
46568 if (PyErr_Occurred()) SWIG_fail;
46569 }
46570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
46571 {
46572 if (temp3)
46573 delete arg3;
46574 }
46575 {
46576 if (temp4)
46577 delete arg4;
46578 }
46579 return resultobj;
46580 fail:
46581 {
46582 if (temp3)
46583 delete arg3;
46584 }
46585 {
46586 if (temp4)
46587 delete arg4;
46588 }
46589 return NULL;
46590 }
46591
46592
46593 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46594 PyObject *resultobj = 0;
46595 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46596 void *argp1 = 0 ;
46597 int res1 = 0 ;
46598 PyObject *swig_obj[1] ;
46599
46600 if (!args) SWIG_fail;
46601 swig_obj[0] = args;
46602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
46603 if (!SWIG_IsOK(res1)) {
46604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46605 }
46606 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46607 {
46608 PyThreadState* __tstate = wxPyBeginAllowThreads();
46609 delete arg1;
46610
46611 wxPyEndAllowThreads(__tstate);
46612 if (PyErr_Occurred()) SWIG_fail;
46613 }
46614 resultobj = SWIG_Py_Void();
46615 return resultobj;
46616 fail:
46617 return NULL;
46618 }
46619
46620
46621 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46622 PyObject *resultobj = 0;
46623 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46624 wxMenu *result = 0 ;
46625 void *argp1 = 0 ;
46626 int res1 = 0 ;
46627 PyObject *swig_obj[1] ;
46628
46629 if (!args) SWIG_fail;
46630 swig_obj[0] = args;
46631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46632 if (!SWIG_IsOK(res1)) {
46633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46634 }
46635 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46636 {
46637 PyThreadState* __tstate = wxPyBeginAllowThreads();
46638 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
46639 wxPyEndAllowThreads(__tstate);
46640 if (PyErr_Occurred()) SWIG_fail;
46641 }
46642 {
46643 resultobj = wxPyMake_wxObject(result, 0);
46644 }
46645 return resultobj;
46646 fail:
46647 return NULL;
46648 }
46649
46650
46651 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46652 PyObject *resultobj = 0;
46653 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46654 wxMenu *arg2 = (wxMenu *) 0 ;
46655 void *argp1 = 0 ;
46656 int res1 = 0 ;
46657 void *argp2 = 0 ;
46658 int res2 = 0 ;
46659 PyObject * obj0 = 0 ;
46660 PyObject * obj1 = 0 ;
46661 char * kwnames[] = {
46662 (char *) "self",(char *) "menu", NULL
46663 };
46664
46665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46667 if (!SWIG_IsOK(res1)) {
46668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46669 }
46670 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46672 if (!SWIG_IsOK(res2)) {
46673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46674 }
46675 arg2 = reinterpret_cast< wxMenu * >(argp2);
46676 {
46677 PyThreadState* __tstate = wxPyBeginAllowThreads();
46678 (arg1)->SetMenu(arg2);
46679 wxPyEndAllowThreads(__tstate);
46680 if (PyErr_Occurred()) SWIG_fail;
46681 }
46682 resultobj = SWIG_Py_Void();
46683 return resultobj;
46684 fail:
46685 return NULL;
46686 }
46687
46688
46689 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46690 PyObject *resultobj = 0;
46691 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46692 int arg2 ;
46693 void *argp1 = 0 ;
46694 int res1 = 0 ;
46695 int val2 ;
46696 int ecode2 = 0 ;
46697 PyObject * obj0 = 0 ;
46698 PyObject * obj1 = 0 ;
46699 char * kwnames[] = {
46700 (char *) "self",(char *) "id", NULL
46701 };
46702
46703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46705 if (!SWIG_IsOK(res1)) {
46706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46707 }
46708 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46709 ecode2 = SWIG_AsVal_int(obj1, &val2);
46710 if (!SWIG_IsOK(ecode2)) {
46711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46712 }
46713 arg2 = static_cast< int >(val2);
46714 {
46715 PyThreadState* __tstate = wxPyBeginAllowThreads();
46716 (arg1)->SetId(arg2);
46717 wxPyEndAllowThreads(__tstate);
46718 if (PyErr_Occurred()) SWIG_fail;
46719 }
46720 resultobj = SWIG_Py_Void();
46721 return resultobj;
46722 fail:
46723 return NULL;
46724 }
46725
46726
46727 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46728 PyObject *resultobj = 0;
46729 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46730 int result;
46731 void *argp1 = 0 ;
46732 int res1 = 0 ;
46733 PyObject *swig_obj[1] ;
46734
46735 if (!args) SWIG_fail;
46736 swig_obj[0] = args;
46737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46738 if (!SWIG_IsOK(res1)) {
46739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46740 }
46741 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46742 {
46743 PyThreadState* __tstate = wxPyBeginAllowThreads();
46744 result = (int)((wxMenuItem const *)arg1)->GetId();
46745 wxPyEndAllowThreads(__tstate);
46746 if (PyErr_Occurred()) SWIG_fail;
46747 }
46748 resultobj = SWIG_From_int(static_cast< int >(result));
46749 return resultobj;
46750 fail:
46751 return NULL;
46752 }
46753
46754
46755 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46756 PyObject *resultobj = 0;
46757 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46758 bool result;
46759 void *argp1 = 0 ;
46760 int res1 = 0 ;
46761 PyObject *swig_obj[1] ;
46762
46763 if (!args) SWIG_fail;
46764 swig_obj[0] = args;
46765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46766 if (!SWIG_IsOK(res1)) {
46767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46768 }
46769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46770 {
46771 PyThreadState* __tstate = wxPyBeginAllowThreads();
46772 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46773 wxPyEndAllowThreads(__tstate);
46774 if (PyErr_Occurred()) SWIG_fail;
46775 }
46776 {
46777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46778 }
46779 return resultobj;
46780 fail:
46781 return NULL;
46782 }
46783
46784
46785 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46786 PyObject *resultobj = 0;
46787 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46788 wxString *arg2 = 0 ;
46789 void *argp1 = 0 ;
46790 int res1 = 0 ;
46791 bool temp2 = false ;
46792 PyObject * obj0 = 0 ;
46793 PyObject * obj1 = 0 ;
46794 char * kwnames[] = {
46795 (char *) "self",(char *) "str", NULL
46796 };
46797
46798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46800 if (!SWIG_IsOK(res1)) {
46801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46802 }
46803 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46804 {
46805 arg2 = wxString_in_helper(obj1);
46806 if (arg2 == NULL) SWIG_fail;
46807 temp2 = true;
46808 }
46809 {
46810 PyThreadState* __tstate = wxPyBeginAllowThreads();
46811 (arg1)->SetText((wxString const &)*arg2);
46812 wxPyEndAllowThreads(__tstate);
46813 if (PyErr_Occurred()) SWIG_fail;
46814 }
46815 resultobj = SWIG_Py_Void();
46816 {
46817 if (temp2)
46818 delete arg2;
46819 }
46820 return resultobj;
46821 fail:
46822 {
46823 if (temp2)
46824 delete arg2;
46825 }
46826 return NULL;
46827 }
46828
46829
46830 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46831 PyObject *resultobj = 0;
46832 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46833 wxString result;
46834 void *argp1 = 0 ;
46835 int res1 = 0 ;
46836 PyObject *swig_obj[1] ;
46837
46838 if (!args) SWIG_fail;
46839 swig_obj[0] = args;
46840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46841 if (!SWIG_IsOK(res1)) {
46842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46843 }
46844 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46845 {
46846 PyThreadState* __tstate = wxPyBeginAllowThreads();
46847 result = ((wxMenuItem const *)arg1)->GetLabel();
46848 wxPyEndAllowThreads(__tstate);
46849 if (PyErr_Occurred()) SWIG_fail;
46850 }
46851 {
46852 #if wxUSE_UNICODE
46853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46854 #else
46855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46856 #endif
46857 }
46858 return resultobj;
46859 fail:
46860 return NULL;
46861 }
46862
46863
46864 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46865 PyObject *resultobj = 0;
46866 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46867 wxString *result = 0 ;
46868 void *argp1 = 0 ;
46869 int res1 = 0 ;
46870 PyObject *swig_obj[1] ;
46871
46872 if (!args) SWIG_fail;
46873 swig_obj[0] = args;
46874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46875 if (!SWIG_IsOK(res1)) {
46876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46877 }
46878 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46879 {
46880 PyThreadState* __tstate = wxPyBeginAllowThreads();
46881 {
46882 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46883 result = (wxString *) &_result_ref;
46884 }
46885 wxPyEndAllowThreads(__tstate);
46886 if (PyErr_Occurred()) SWIG_fail;
46887 }
46888 {
46889 #if wxUSE_UNICODE
46890 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46891 #else
46892 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46893 #endif
46894 }
46895 return resultobj;
46896 fail:
46897 return NULL;
46898 }
46899
46900
46901 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46902 PyObject *resultobj = 0;
46903 wxString *arg1 = 0 ;
46904 wxString result;
46905 bool temp1 = false ;
46906 PyObject * obj0 = 0 ;
46907 char * kwnames[] = {
46908 (char *) "text", NULL
46909 };
46910
46911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46912 {
46913 arg1 = wxString_in_helper(obj0);
46914 if (arg1 == NULL) SWIG_fail;
46915 temp1 = true;
46916 }
46917 {
46918 PyThreadState* __tstate = wxPyBeginAllowThreads();
46919 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46920 wxPyEndAllowThreads(__tstate);
46921 if (PyErr_Occurred()) SWIG_fail;
46922 }
46923 {
46924 #if wxUSE_UNICODE
46925 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46926 #else
46927 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46928 #endif
46929 }
46930 {
46931 if (temp1)
46932 delete arg1;
46933 }
46934 return resultobj;
46935 fail:
46936 {
46937 if (temp1)
46938 delete arg1;
46939 }
46940 return NULL;
46941 }
46942
46943
46944 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46945 PyObject *resultobj = 0;
46946 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46947 wxItemKind result;
46948 void *argp1 = 0 ;
46949 int res1 = 0 ;
46950 PyObject *swig_obj[1] ;
46951
46952 if (!args) SWIG_fail;
46953 swig_obj[0] = args;
46954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46955 if (!SWIG_IsOK(res1)) {
46956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46957 }
46958 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46959 {
46960 PyThreadState* __tstate = wxPyBeginAllowThreads();
46961 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46962 wxPyEndAllowThreads(__tstate);
46963 if (PyErr_Occurred()) SWIG_fail;
46964 }
46965 resultobj = SWIG_From_int(static_cast< int >(result));
46966 return resultobj;
46967 fail:
46968 return NULL;
46969 }
46970
46971
46972 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46973 PyObject *resultobj = 0;
46974 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46975 wxItemKind arg2 ;
46976 void *argp1 = 0 ;
46977 int res1 = 0 ;
46978 int val2 ;
46979 int ecode2 = 0 ;
46980 PyObject * obj0 = 0 ;
46981 PyObject * obj1 = 0 ;
46982 char * kwnames[] = {
46983 (char *) "self",(char *) "kind", NULL
46984 };
46985
46986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46988 if (!SWIG_IsOK(res1)) {
46989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46990 }
46991 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46992 ecode2 = SWIG_AsVal_int(obj1, &val2);
46993 if (!SWIG_IsOK(ecode2)) {
46994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46995 }
46996 arg2 = static_cast< wxItemKind >(val2);
46997 {
46998 PyThreadState* __tstate = wxPyBeginAllowThreads();
46999 (arg1)->SetKind(arg2);
47000 wxPyEndAllowThreads(__tstate);
47001 if (PyErr_Occurred()) SWIG_fail;
47002 }
47003 resultobj = SWIG_Py_Void();
47004 return resultobj;
47005 fail:
47006 return NULL;
47007 }
47008
47009
47010 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47011 PyObject *resultobj = 0;
47012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47013 bool arg2 ;
47014 void *argp1 = 0 ;
47015 int res1 = 0 ;
47016 bool val2 ;
47017 int ecode2 = 0 ;
47018 PyObject * obj0 = 0 ;
47019 PyObject * obj1 = 0 ;
47020 char * kwnames[] = {
47021 (char *) "self",(char *) "checkable", NULL
47022 };
47023
47024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
47025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47026 if (!SWIG_IsOK(res1)) {
47027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47028 }
47029 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47030 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47031 if (!SWIG_IsOK(ecode2)) {
47032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
47033 }
47034 arg2 = static_cast< bool >(val2);
47035 {
47036 PyThreadState* __tstate = wxPyBeginAllowThreads();
47037 (arg1)->SetCheckable(arg2);
47038 wxPyEndAllowThreads(__tstate);
47039 if (PyErr_Occurred()) SWIG_fail;
47040 }
47041 resultobj = SWIG_Py_Void();
47042 return resultobj;
47043 fail:
47044 return NULL;
47045 }
47046
47047
47048 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47049 PyObject *resultobj = 0;
47050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47051 bool result;
47052 void *argp1 = 0 ;
47053 int res1 = 0 ;
47054 PyObject *swig_obj[1] ;
47055
47056 if (!args) SWIG_fail;
47057 swig_obj[0] = args;
47058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47059 if (!SWIG_IsOK(res1)) {
47060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47061 }
47062 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47063 {
47064 PyThreadState* __tstate = wxPyBeginAllowThreads();
47065 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
47066 wxPyEndAllowThreads(__tstate);
47067 if (PyErr_Occurred()) SWIG_fail;
47068 }
47069 {
47070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47071 }
47072 return resultobj;
47073 fail:
47074 return NULL;
47075 }
47076
47077
47078 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47079 PyObject *resultobj = 0;
47080 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47081 bool result;
47082 void *argp1 = 0 ;
47083 int res1 = 0 ;
47084 PyObject *swig_obj[1] ;
47085
47086 if (!args) SWIG_fail;
47087 swig_obj[0] = args;
47088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47089 if (!SWIG_IsOK(res1)) {
47090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47091 }
47092 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47093 {
47094 PyThreadState* __tstate = wxPyBeginAllowThreads();
47095 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
47096 wxPyEndAllowThreads(__tstate);
47097 if (PyErr_Occurred()) SWIG_fail;
47098 }
47099 {
47100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47101 }
47102 return resultobj;
47103 fail:
47104 return NULL;
47105 }
47106
47107
47108 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47109 PyObject *resultobj = 0;
47110 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47111 wxMenu *arg2 = (wxMenu *) 0 ;
47112 void *argp1 = 0 ;
47113 int res1 = 0 ;
47114 void *argp2 = 0 ;
47115 int res2 = 0 ;
47116 PyObject * obj0 = 0 ;
47117 PyObject * obj1 = 0 ;
47118 char * kwnames[] = {
47119 (char *) "self",(char *) "menu", NULL
47120 };
47121
47122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
47123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47124 if (!SWIG_IsOK(res1)) {
47125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47126 }
47127 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47128 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
47129 if (!SWIG_IsOK(res2)) {
47130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
47131 }
47132 arg2 = reinterpret_cast< wxMenu * >(argp2);
47133 {
47134 PyThreadState* __tstate = wxPyBeginAllowThreads();
47135 (arg1)->SetSubMenu(arg2);
47136 wxPyEndAllowThreads(__tstate);
47137 if (PyErr_Occurred()) SWIG_fail;
47138 }
47139 resultobj = SWIG_Py_Void();
47140 return resultobj;
47141 fail:
47142 return NULL;
47143 }
47144
47145
47146 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47147 PyObject *resultobj = 0;
47148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47149 wxMenu *result = 0 ;
47150 void *argp1 = 0 ;
47151 int res1 = 0 ;
47152 PyObject *swig_obj[1] ;
47153
47154 if (!args) SWIG_fail;
47155 swig_obj[0] = args;
47156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47157 if (!SWIG_IsOK(res1)) {
47158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47159 }
47160 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47161 {
47162 PyThreadState* __tstate = wxPyBeginAllowThreads();
47163 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
47164 wxPyEndAllowThreads(__tstate);
47165 if (PyErr_Occurred()) SWIG_fail;
47166 }
47167 {
47168 resultobj = wxPyMake_wxObject(result, 0);
47169 }
47170 return resultobj;
47171 fail:
47172 return NULL;
47173 }
47174
47175
47176 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47177 PyObject *resultobj = 0;
47178 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47179 bool arg2 = (bool) true ;
47180 void *argp1 = 0 ;
47181 int res1 = 0 ;
47182 bool val2 ;
47183 int ecode2 = 0 ;
47184 PyObject * obj0 = 0 ;
47185 PyObject * obj1 = 0 ;
47186 char * kwnames[] = {
47187 (char *) "self",(char *) "enable", NULL
47188 };
47189
47190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
47191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47192 if (!SWIG_IsOK(res1)) {
47193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47194 }
47195 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47196 if (obj1) {
47197 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47198 if (!SWIG_IsOK(ecode2)) {
47199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
47200 }
47201 arg2 = static_cast< bool >(val2);
47202 }
47203 {
47204 PyThreadState* __tstate = wxPyBeginAllowThreads();
47205 (arg1)->Enable(arg2);
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 *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47217 PyObject *resultobj = 0;
47218 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47219 bool result;
47220 void *argp1 = 0 ;
47221 int res1 = 0 ;
47222 PyObject *swig_obj[1] ;
47223
47224 if (!args) SWIG_fail;
47225 swig_obj[0] = args;
47226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47227 if (!SWIG_IsOK(res1)) {
47228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47229 }
47230 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47231 {
47232 PyThreadState* __tstate = wxPyBeginAllowThreads();
47233 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
47234 wxPyEndAllowThreads(__tstate);
47235 if (PyErr_Occurred()) SWIG_fail;
47236 }
47237 {
47238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47239 }
47240 return resultobj;
47241 fail:
47242 return NULL;
47243 }
47244
47245
47246 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47247 PyObject *resultobj = 0;
47248 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47249 bool arg2 = (bool) true ;
47250 void *argp1 = 0 ;
47251 int res1 = 0 ;
47252 bool val2 ;
47253 int ecode2 = 0 ;
47254 PyObject * obj0 = 0 ;
47255 PyObject * obj1 = 0 ;
47256 char * kwnames[] = {
47257 (char *) "self",(char *) "check", NULL
47258 };
47259
47260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
47261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47262 if (!SWIG_IsOK(res1)) {
47263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47264 }
47265 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47266 if (obj1) {
47267 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47268 if (!SWIG_IsOK(ecode2)) {
47269 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
47270 }
47271 arg2 = static_cast< bool >(val2);
47272 }
47273 {
47274 PyThreadState* __tstate = wxPyBeginAllowThreads();
47275 (arg1)->Check(arg2);
47276 wxPyEndAllowThreads(__tstate);
47277 if (PyErr_Occurred()) SWIG_fail;
47278 }
47279 resultobj = SWIG_Py_Void();
47280 return resultobj;
47281 fail:
47282 return NULL;
47283 }
47284
47285
47286 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47287 PyObject *resultobj = 0;
47288 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47289 bool result;
47290 void *argp1 = 0 ;
47291 int res1 = 0 ;
47292 PyObject *swig_obj[1] ;
47293
47294 if (!args) SWIG_fail;
47295 swig_obj[0] = args;
47296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47297 if (!SWIG_IsOK(res1)) {
47298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47299 }
47300 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47301 {
47302 PyThreadState* __tstate = wxPyBeginAllowThreads();
47303 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
47304 wxPyEndAllowThreads(__tstate);
47305 if (PyErr_Occurred()) SWIG_fail;
47306 }
47307 {
47308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47309 }
47310 return resultobj;
47311 fail:
47312 return NULL;
47313 }
47314
47315
47316 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47317 PyObject *resultobj = 0;
47318 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47319 void *argp1 = 0 ;
47320 int res1 = 0 ;
47321 PyObject *swig_obj[1] ;
47322
47323 if (!args) SWIG_fail;
47324 swig_obj[0] = args;
47325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47326 if (!SWIG_IsOK(res1)) {
47327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47328 }
47329 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47330 {
47331 PyThreadState* __tstate = wxPyBeginAllowThreads();
47332 (arg1)->Toggle();
47333 wxPyEndAllowThreads(__tstate);
47334 if (PyErr_Occurred()) SWIG_fail;
47335 }
47336 resultobj = SWIG_Py_Void();
47337 return resultobj;
47338 fail:
47339 return NULL;
47340 }
47341
47342
47343 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47344 PyObject *resultobj = 0;
47345 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47346 wxString *arg2 = 0 ;
47347 void *argp1 = 0 ;
47348 int res1 = 0 ;
47349 bool temp2 = false ;
47350 PyObject * obj0 = 0 ;
47351 PyObject * obj1 = 0 ;
47352 char * kwnames[] = {
47353 (char *) "self",(char *) "str", NULL
47354 };
47355
47356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
47357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47358 if (!SWIG_IsOK(res1)) {
47359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47360 }
47361 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47362 {
47363 arg2 = wxString_in_helper(obj1);
47364 if (arg2 == NULL) SWIG_fail;
47365 temp2 = true;
47366 }
47367 {
47368 PyThreadState* __tstate = wxPyBeginAllowThreads();
47369 (arg1)->SetHelp((wxString const &)*arg2);
47370 wxPyEndAllowThreads(__tstate);
47371 if (PyErr_Occurred()) SWIG_fail;
47372 }
47373 resultobj = SWIG_Py_Void();
47374 {
47375 if (temp2)
47376 delete arg2;
47377 }
47378 return resultobj;
47379 fail:
47380 {
47381 if (temp2)
47382 delete arg2;
47383 }
47384 return NULL;
47385 }
47386
47387
47388 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47389 PyObject *resultobj = 0;
47390 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47391 wxString *result = 0 ;
47392 void *argp1 = 0 ;
47393 int res1 = 0 ;
47394 PyObject *swig_obj[1] ;
47395
47396 if (!args) SWIG_fail;
47397 swig_obj[0] = args;
47398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47399 if (!SWIG_IsOK(res1)) {
47400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47401 }
47402 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47403 {
47404 PyThreadState* __tstate = wxPyBeginAllowThreads();
47405 {
47406 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
47407 result = (wxString *) &_result_ref;
47408 }
47409 wxPyEndAllowThreads(__tstate);
47410 if (PyErr_Occurred()) SWIG_fail;
47411 }
47412 {
47413 #if wxUSE_UNICODE
47414 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
47415 #else
47416 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
47417 #endif
47418 }
47419 return resultobj;
47420 fail:
47421 return NULL;
47422 }
47423
47424
47425 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47426 PyObject *resultobj = 0;
47427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47428 wxAcceleratorEntry *result = 0 ;
47429 void *argp1 = 0 ;
47430 int res1 = 0 ;
47431 PyObject *swig_obj[1] ;
47432
47433 if (!args) SWIG_fail;
47434 swig_obj[0] = args;
47435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47436 if (!SWIG_IsOK(res1)) {
47437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47438 }
47439 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47440 {
47441 PyThreadState* __tstate = wxPyBeginAllowThreads();
47442 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
47443 wxPyEndAllowThreads(__tstate);
47444 if (PyErr_Occurred()) SWIG_fail;
47445 }
47446 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47447 return resultobj;
47448 fail:
47449 return NULL;
47450 }
47451
47452
47453 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47454 PyObject *resultobj = 0;
47455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47456 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
47457 void *argp1 = 0 ;
47458 int res1 = 0 ;
47459 void *argp2 = 0 ;
47460 int res2 = 0 ;
47461 PyObject * obj0 = 0 ;
47462 PyObject * obj1 = 0 ;
47463 char * kwnames[] = {
47464 (char *) "self",(char *) "accel", NULL
47465 };
47466
47467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
47468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47469 if (!SWIG_IsOK(res1)) {
47470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47471 }
47472 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47473 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
47474 if (!SWIG_IsOK(res2)) {
47475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
47476 }
47477 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
47478 {
47479 PyThreadState* __tstate = wxPyBeginAllowThreads();
47480 (arg1)->SetAccel(arg2);
47481 wxPyEndAllowThreads(__tstate);
47482 if (PyErr_Occurred()) SWIG_fail;
47483 }
47484 resultobj = SWIG_Py_Void();
47485 return resultobj;
47486 fail:
47487 return NULL;
47488 }
47489
47490
47491 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47492 PyObject *resultobj = 0;
47493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47494 wxBitmap *arg2 = 0 ;
47495 void *argp1 = 0 ;
47496 int res1 = 0 ;
47497 void *argp2 = 0 ;
47498 int res2 = 0 ;
47499 PyObject * obj0 = 0 ;
47500 PyObject * obj1 = 0 ;
47501 char * kwnames[] = {
47502 (char *) "self",(char *) "bitmap", NULL
47503 };
47504
47505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47507 if (!SWIG_IsOK(res1)) {
47508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47509 }
47510 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47511 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47512 if (!SWIG_IsOK(res2)) {
47513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47514 }
47515 if (!argp2) {
47516 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47517 }
47518 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47519 {
47520 PyThreadState* __tstate = wxPyBeginAllowThreads();
47521 (arg1)->SetBitmap((wxBitmap const &)*arg2);
47522 wxPyEndAllowThreads(__tstate);
47523 if (PyErr_Occurred()) SWIG_fail;
47524 }
47525 resultobj = SWIG_Py_Void();
47526 return resultobj;
47527 fail:
47528 return NULL;
47529 }
47530
47531
47532 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47533 PyObject *resultobj = 0;
47534 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47535 wxBitmap *result = 0 ;
47536 void *argp1 = 0 ;
47537 int res1 = 0 ;
47538 PyObject *swig_obj[1] ;
47539
47540 if (!args) SWIG_fail;
47541 swig_obj[0] = args;
47542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47543 if (!SWIG_IsOK(res1)) {
47544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47545 }
47546 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47547 {
47548 PyThreadState* __tstate = wxPyBeginAllowThreads();
47549 {
47550 wxBitmap const &_result_ref = (arg1)->GetBitmap();
47551 result = (wxBitmap *) &_result_ref;
47552 }
47553 wxPyEndAllowThreads(__tstate);
47554 if (PyErr_Occurred()) SWIG_fail;
47555 }
47556 {
47557 wxBitmap* resultptr = new wxBitmap(*result);
47558 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47559 }
47560 return resultobj;
47561 fail:
47562 return NULL;
47563 }
47564
47565
47566 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47567 PyObject *resultobj = 0;
47568 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47569 wxFont *arg2 = 0 ;
47570 void *argp1 = 0 ;
47571 int res1 = 0 ;
47572 void *argp2 = 0 ;
47573 int res2 = 0 ;
47574 PyObject * obj0 = 0 ;
47575 PyObject * obj1 = 0 ;
47576 char * kwnames[] = {
47577 (char *) "self",(char *) "font", NULL
47578 };
47579
47580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
47581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47582 if (!SWIG_IsOK(res1)) {
47583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47584 }
47585 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47586 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
47587 if (!SWIG_IsOK(res2)) {
47588 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47589 }
47590 if (!argp2) {
47591 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
47592 }
47593 arg2 = reinterpret_cast< wxFont * >(argp2);
47594 {
47595 PyThreadState* __tstate = wxPyBeginAllowThreads();
47596 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
47597 wxPyEndAllowThreads(__tstate);
47598 if (PyErr_Occurred()) SWIG_fail;
47599 }
47600 resultobj = SWIG_Py_Void();
47601 return resultobj;
47602 fail:
47603 return NULL;
47604 }
47605
47606
47607 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 PyObject *resultobj = 0;
47609 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47610 wxFont result;
47611 void *argp1 = 0 ;
47612 int res1 = 0 ;
47613 PyObject *swig_obj[1] ;
47614
47615 if (!args) SWIG_fail;
47616 swig_obj[0] = args;
47617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47618 if (!SWIG_IsOK(res1)) {
47619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47620 }
47621 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47622 {
47623 PyThreadState* __tstate = wxPyBeginAllowThreads();
47624 result = wxMenuItem_GetFont(arg1);
47625 wxPyEndAllowThreads(__tstate);
47626 if (PyErr_Occurred()) SWIG_fail;
47627 }
47628 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
47629 return resultobj;
47630 fail:
47631 return NULL;
47632 }
47633
47634
47635 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47636 PyObject *resultobj = 0;
47637 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47638 wxColour *arg2 = 0 ;
47639 void *argp1 = 0 ;
47640 int res1 = 0 ;
47641 wxColour temp2 ;
47642 PyObject * obj0 = 0 ;
47643 PyObject * obj1 = 0 ;
47644 char * kwnames[] = {
47645 (char *) "self",(char *) "colText", NULL
47646 };
47647
47648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
47649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47650 if (!SWIG_IsOK(res1)) {
47651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47652 }
47653 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47654 {
47655 arg2 = &temp2;
47656 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47657 }
47658 {
47659 PyThreadState* __tstate = wxPyBeginAllowThreads();
47660 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
47661 wxPyEndAllowThreads(__tstate);
47662 if (PyErr_Occurred()) SWIG_fail;
47663 }
47664 resultobj = SWIG_Py_Void();
47665 return resultobj;
47666 fail:
47667 return NULL;
47668 }
47669
47670
47671 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47672 PyObject *resultobj = 0;
47673 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47674 wxColour result;
47675 void *argp1 = 0 ;
47676 int res1 = 0 ;
47677 PyObject *swig_obj[1] ;
47678
47679 if (!args) SWIG_fail;
47680 swig_obj[0] = args;
47681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47682 if (!SWIG_IsOK(res1)) {
47683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47684 }
47685 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47686 {
47687 PyThreadState* __tstate = wxPyBeginAllowThreads();
47688 result = wxMenuItem_GetTextColour(arg1);
47689 wxPyEndAllowThreads(__tstate);
47690 if (PyErr_Occurred()) SWIG_fail;
47691 }
47692 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47693 return resultobj;
47694 fail:
47695 return NULL;
47696 }
47697
47698
47699 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47700 PyObject *resultobj = 0;
47701 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47702 wxColour *arg2 = 0 ;
47703 void *argp1 = 0 ;
47704 int res1 = 0 ;
47705 wxColour temp2 ;
47706 PyObject * obj0 = 0 ;
47707 PyObject * obj1 = 0 ;
47708 char * kwnames[] = {
47709 (char *) "self",(char *) "colBack", NULL
47710 };
47711
47712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47714 if (!SWIG_IsOK(res1)) {
47715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47716 }
47717 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47718 {
47719 arg2 = &temp2;
47720 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47721 }
47722 {
47723 PyThreadState* __tstate = wxPyBeginAllowThreads();
47724 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47725 wxPyEndAllowThreads(__tstate);
47726 if (PyErr_Occurred()) SWIG_fail;
47727 }
47728 resultobj = SWIG_Py_Void();
47729 return resultobj;
47730 fail:
47731 return NULL;
47732 }
47733
47734
47735 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47736 PyObject *resultobj = 0;
47737 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47738 wxColour result;
47739 void *argp1 = 0 ;
47740 int res1 = 0 ;
47741 PyObject *swig_obj[1] ;
47742
47743 if (!args) SWIG_fail;
47744 swig_obj[0] = args;
47745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47746 if (!SWIG_IsOK(res1)) {
47747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47748 }
47749 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47750 {
47751 PyThreadState* __tstate = wxPyBeginAllowThreads();
47752 result = wxMenuItem_GetBackgroundColour(arg1);
47753 wxPyEndAllowThreads(__tstate);
47754 if (PyErr_Occurred()) SWIG_fail;
47755 }
47756 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47757 return resultobj;
47758 fail:
47759 return NULL;
47760 }
47761
47762
47763 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47764 PyObject *resultobj = 0;
47765 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47766 wxBitmap *arg2 = 0 ;
47767 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47768 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47769 void *argp1 = 0 ;
47770 int res1 = 0 ;
47771 void *argp2 = 0 ;
47772 int res2 = 0 ;
47773 void *argp3 = 0 ;
47774 int res3 = 0 ;
47775 PyObject * obj0 = 0 ;
47776 PyObject * obj1 = 0 ;
47777 PyObject * obj2 = 0 ;
47778 char * kwnames[] = {
47779 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47780 };
47781
47782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47784 if (!SWIG_IsOK(res1)) {
47785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47786 }
47787 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47789 if (!SWIG_IsOK(res2)) {
47790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47791 }
47792 if (!argp2) {
47793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47794 }
47795 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47796 if (obj2) {
47797 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47798 if (!SWIG_IsOK(res3)) {
47799 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47800 }
47801 if (!argp3) {
47802 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47803 }
47804 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47805 }
47806 {
47807 PyThreadState* __tstate = wxPyBeginAllowThreads();
47808 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47809 wxPyEndAllowThreads(__tstate);
47810 if (PyErr_Occurred()) SWIG_fail;
47811 }
47812 resultobj = SWIG_Py_Void();
47813 return resultobj;
47814 fail:
47815 return NULL;
47816 }
47817
47818
47819 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47820 PyObject *resultobj = 0;
47821 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47822 wxBitmap *arg2 = 0 ;
47823 void *argp1 = 0 ;
47824 int res1 = 0 ;
47825 void *argp2 = 0 ;
47826 int res2 = 0 ;
47827 PyObject * obj0 = 0 ;
47828 PyObject * obj1 = 0 ;
47829 char * kwnames[] = {
47830 (char *) "self",(char *) "bmpDisabled", NULL
47831 };
47832
47833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47835 if (!SWIG_IsOK(res1)) {
47836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47837 }
47838 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47839 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47840 if (!SWIG_IsOK(res2)) {
47841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47842 }
47843 if (!argp2) {
47844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47845 }
47846 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47847 {
47848 PyThreadState* __tstate = wxPyBeginAllowThreads();
47849 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47850 wxPyEndAllowThreads(__tstate);
47851 if (PyErr_Occurred()) SWIG_fail;
47852 }
47853 resultobj = SWIG_Py_Void();
47854 return resultobj;
47855 fail:
47856 return NULL;
47857 }
47858
47859
47860 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47861 PyObject *resultobj = 0;
47862 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47863 wxBitmap *result = 0 ;
47864 void *argp1 = 0 ;
47865 int res1 = 0 ;
47866 PyObject *swig_obj[1] ;
47867
47868 if (!args) SWIG_fail;
47869 swig_obj[0] = args;
47870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47871 if (!SWIG_IsOK(res1)) {
47872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47873 }
47874 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47875 {
47876 PyThreadState* __tstate = wxPyBeginAllowThreads();
47877 {
47878 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47879 result = (wxBitmap *) &_result_ref;
47880 }
47881 wxPyEndAllowThreads(__tstate);
47882 if (PyErr_Occurred()) SWIG_fail;
47883 }
47884 {
47885 wxBitmap* resultptr = new wxBitmap(*result);
47886 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47887 }
47888 return resultobj;
47889 fail:
47890 return NULL;
47891 }
47892
47893
47894 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47895 PyObject *resultobj = 0;
47896 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47897 int arg2 ;
47898 void *argp1 = 0 ;
47899 int res1 = 0 ;
47900 int val2 ;
47901 int ecode2 = 0 ;
47902 PyObject * obj0 = 0 ;
47903 PyObject * obj1 = 0 ;
47904 char * kwnames[] = {
47905 (char *) "self",(char *) "nWidth", NULL
47906 };
47907
47908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47910 if (!SWIG_IsOK(res1)) {
47911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47912 }
47913 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47914 ecode2 = SWIG_AsVal_int(obj1, &val2);
47915 if (!SWIG_IsOK(ecode2)) {
47916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47917 }
47918 arg2 = static_cast< int >(val2);
47919 {
47920 PyThreadState* __tstate = wxPyBeginAllowThreads();
47921 wxMenuItem_SetMarginWidth(arg1,arg2);
47922 wxPyEndAllowThreads(__tstate);
47923 if (PyErr_Occurred()) SWIG_fail;
47924 }
47925 resultobj = SWIG_Py_Void();
47926 return resultobj;
47927 fail:
47928 return NULL;
47929 }
47930
47931
47932 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47933 PyObject *resultobj = 0;
47934 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47935 int result;
47936 void *argp1 = 0 ;
47937 int res1 = 0 ;
47938 PyObject *swig_obj[1] ;
47939
47940 if (!args) SWIG_fail;
47941 swig_obj[0] = args;
47942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47943 if (!SWIG_IsOK(res1)) {
47944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47945 }
47946 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47947 {
47948 PyThreadState* __tstate = wxPyBeginAllowThreads();
47949 result = (int)wxMenuItem_GetMarginWidth(arg1);
47950 wxPyEndAllowThreads(__tstate);
47951 if (PyErr_Occurred()) SWIG_fail;
47952 }
47953 resultobj = SWIG_From_int(static_cast< int >(result));
47954 return resultobj;
47955 fail:
47956 return NULL;
47957 }
47958
47959
47960 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47961 PyObject *resultobj = 0;
47962 int result;
47963
47964 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47965 {
47966 PyThreadState* __tstate = wxPyBeginAllowThreads();
47967 result = (int)wxMenuItem_GetDefaultMarginWidth();
47968 wxPyEndAllowThreads(__tstate);
47969 if (PyErr_Occurred()) SWIG_fail;
47970 }
47971 resultobj = SWIG_From_int(static_cast< int >(result));
47972 return resultobj;
47973 fail:
47974 return NULL;
47975 }
47976
47977
47978 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47979 PyObject *resultobj = 0;
47980 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47981 bool result;
47982 void *argp1 = 0 ;
47983 int res1 = 0 ;
47984 PyObject *swig_obj[1] ;
47985
47986 if (!args) SWIG_fail;
47987 swig_obj[0] = args;
47988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47989 if (!SWIG_IsOK(res1)) {
47990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47991 }
47992 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47993 {
47994 PyThreadState* __tstate = wxPyBeginAllowThreads();
47995 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47996 wxPyEndAllowThreads(__tstate);
47997 if (PyErr_Occurred()) SWIG_fail;
47998 }
47999 {
48000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48001 }
48002 return resultobj;
48003 fail:
48004 return NULL;
48005 }
48006
48007
48008 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48009 PyObject *resultobj = 0;
48010 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48011 bool arg2 = (bool) true ;
48012 void *argp1 = 0 ;
48013 int res1 = 0 ;
48014 bool val2 ;
48015 int ecode2 = 0 ;
48016 PyObject * obj0 = 0 ;
48017 PyObject * obj1 = 0 ;
48018 char * kwnames[] = {
48019 (char *) "self",(char *) "ownerDrawn", NULL
48020 };
48021
48022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
48023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48024 if (!SWIG_IsOK(res1)) {
48025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48026 }
48027 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48028 if (obj1) {
48029 ecode2 = SWIG_AsVal_bool(obj1, &val2);
48030 if (!SWIG_IsOK(ecode2)) {
48031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
48032 }
48033 arg2 = static_cast< bool >(val2);
48034 }
48035 {
48036 PyThreadState* __tstate = wxPyBeginAllowThreads();
48037 wxMenuItem_SetOwnerDrawn(arg1,arg2);
48038 wxPyEndAllowThreads(__tstate);
48039 if (PyErr_Occurred()) SWIG_fail;
48040 }
48041 resultobj = SWIG_Py_Void();
48042 return resultobj;
48043 fail:
48044 return NULL;
48045 }
48046
48047
48048 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48049 PyObject *resultobj = 0;
48050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
48051 void *argp1 = 0 ;
48052 int res1 = 0 ;
48053 PyObject *swig_obj[1] ;
48054
48055 if (!args) SWIG_fail;
48056 swig_obj[0] = args;
48057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
48058 if (!SWIG_IsOK(res1)) {
48059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
48060 }
48061 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
48062 {
48063 PyThreadState* __tstate = wxPyBeginAllowThreads();
48064 wxMenuItem_ResetOwnerDrawn(arg1);
48065 wxPyEndAllowThreads(__tstate);
48066 if (PyErr_Occurred()) SWIG_fail;
48067 }
48068 resultobj = SWIG_Py_Void();
48069 return resultobj;
48070 fail:
48071 return NULL;
48072 }
48073
48074
48075 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48076 PyObject *obj;
48077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48078 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
48079 return SWIG_Py_Void();
48080 }
48081
48082 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48083 return SWIG_Python_InitShadowInstance(args);
48084 }
48085
48086 SWIGINTERN int ControlNameStr_set(PyObject *) {
48087 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
48088 return 1;
48089 }
48090
48091
48092 SWIGINTERN PyObject *ControlNameStr_get(void) {
48093 PyObject *pyobj = 0;
48094
48095 {
48096 #if wxUSE_UNICODE
48097 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48098 #else
48099 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
48100 #endif
48101 }
48102 return pyobj;
48103 }
48104
48105
48106 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48107 PyObject *resultobj = 0;
48108 wxWindow *arg1 = (wxWindow *) 0 ;
48109 int arg2 = (int) -1 ;
48110 wxPoint const &arg3_defvalue = wxDefaultPosition ;
48111 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
48112 wxSize const &arg4_defvalue = wxDefaultSize ;
48113 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
48114 long arg5 = (long) 0 ;
48115 wxValidator const &arg6_defvalue = wxDefaultValidator ;
48116 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
48117 wxString const &arg7_defvalue = wxPyControlNameStr ;
48118 wxString *arg7 = (wxString *) &arg7_defvalue ;
48119 wxControl *result = 0 ;
48120 void *argp1 = 0 ;
48121 int res1 = 0 ;
48122 int val2 ;
48123 int ecode2 = 0 ;
48124 wxPoint temp3 ;
48125 wxSize temp4 ;
48126 long val5 ;
48127 int ecode5 = 0 ;
48128 void *argp6 = 0 ;
48129 int res6 = 0 ;
48130 bool temp7 = false ;
48131 PyObject * obj0 = 0 ;
48132 PyObject * obj1 = 0 ;
48133 PyObject * obj2 = 0 ;
48134 PyObject * obj3 = 0 ;
48135 PyObject * obj4 = 0 ;
48136 PyObject * obj5 = 0 ;
48137 PyObject * obj6 = 0 ;
48138 char * kwnames[] = {
48139 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48140 };
48141
48142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
48143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48144 if (!SWIG_IsOK(res1)) {
48145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
48146 }
48147 arg1 = reinterpret_cast< wxWindow * >(argp1);
48148 if (obj1) {
48149 ecode2 = SWIG_AsVal_int(obj1, &val2);
48150 if (!SWIG_IsOK(ecode2)) {
48151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
48152 }
48153 arg2 = static_cast< int >(val2);
48154 }
48155 if (obj2) {
48156 {
48157 arg3 = &temp3;
48158 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
48159 }
48160 }
48161 if (obj3) {
48162 {
48163 arg4 = &temp4;
48164 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
48165 }
48166 }
48167 if (obj4) {
48168 ecode5 = SWIG_AsVal_long(obj4, &val5);
48169 if (!SWIG_IsOK(ecode5)) {
48170 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
48171 }
48172 arg5 = static_cast< long >(val5);
48173 }
48174 if (obj5) {
48175 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
48176 if (!SWIG_IsOK(res6)) {
48177 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48178 }
48179 if (!argp6) {
48180 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
48181 }
48182 arg6 = reinterpret_cast< wxValidator * >(argp6);
48183 }
48184 if (obj6) {
48185 {
48186 arg7 = wxString_in_helper(obj6);
48187 if (arg7 == NULL) SWIG_fail;
48188 temp7 = true;
48189 }
48190 }
48191 {
48192 if (!wxPyCheckForApp()) SWIG_fail;
48193 PyThreadState* __tstate = wxPyBeginAllowThreads();
48194 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
48195 wxPyEndAllowThreads(__tstate);
48196 if (PyErr_Occurred()) SWIG_fail;
48197 }
48198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
48199 {
48200 if (temp7)
48201 delete arg7;
48202 }
48203 return resultobj;
48204 fail:
48205 {
48206 if (temp7)
48207 delete arg7;
48208 }
48209 return NULL;
48210 }
48211
48212
48213 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48214 PyObject *resultobj = 0;
48215 wxControl *result = 0 ;
48216
48217 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
48218 {
48219 if (!wxPyCheckForApp()) SWIG_fail;
48220 PyThreadState* __tstate = wxPyBeginAllowThreads();
48221 result = (wxControl *)new wxControl();
48222 wxPyEndAllowThreads(__tstate);
48223 if (PyErr_Occurred()) SWIG_fail;
48224 }
48225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
48226 return resultobj;
48227 fail:
48228 return NULL;
48229 }
48230
48231
48232 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48233 PyObject *resultobj = 0;
48234 wxControl *arg1 = (wxControl *) 0 ;
48235 wxWindow *arg2 = (wxWindow *) 0 ;
48236 int arg3 = (int) -1 ;
48237 wxPoint const &arg4_defvalue = wxDefaultPosition ;
48238 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
48239 wxSize const &arg5_defvalue = wxDefaultSize ;
48240 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
48241 long arg6 = (long) 0 ;
48242 wxValidator const &arg7_defvalue = wxDefaultValidator ;
48243 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
48244 wxString const &arg8_defvalue = wxPyControlNameStr ;
48245 wxString *arg8 = (wxString *) &arg8_defvalue ;
48246 bool result;
48247 void *argp1 = 0 ;
48248 int res1 = 0 ;
48249 void *argp2 = 0 ;
48250 int res2 = 0 ;
48251 int val3 ;
48252 int ecode3 = 0 ;
48253 wxPoint temp4 ;
48254 wxSize temp5 ;
48255 long val6 ;
48256 int ecode6 = 0 ;
48257 void *argp7 = 0 ;
48258 int res7 = 0 ;
48259 bool temp8 = false ;
48260 PyObject * obj0 = 0 ;
48261 PyObject * obj1 = 0 ;
48262 PyObject * obj2 = 0 ;
48263 PyObject * obj3 = 0 ;
48264 PyObject * obj4 = 0 ;
48265 PyObject * obj5 = 0 ;
48266 PyObject * obj6 = 0 ;
48267 PyObject * obj7 = 0 ;
48268 char * kwnames[] = {
48269 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
48270 };
48271
48272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
48273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48274 if (!SWIG_IsOK(res1)) {
48275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
48276 }
48277 arg1 = reinterpret_cast< wxControl * >(argp1);
48278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
48279 if (!SWIG_IsOK(res2)) {
48280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
48281 }
48282 arg2 = reinterpret_cast< wxWindow * >(argp2);
48283 if (obj2) {
48284 ecode3 = SWIG_AsVal_int(obj2, &val3);
48285 if (!SWIG_IsOK(ecode3)) {
48286 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
48287 }
48288 arg3 = static_cast< int >(val3);
48289 }
48290 if (obj3) {
48291 {
48292 arg4 = &temp4;
48293 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
48294 }
48295 }
48296 if (obj4) {
48297 {
48298 arg5 = &temp5;
48299 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
48300 }
48301 }
48302 if (obj5) {
48303 ecode6 = SWIG_AsVal_long(obj5, &val6);
48304 if (!SWIG_IsOK(ecode6)) {
48305 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
48306 }
48307 arg6 = static_cast< long >(val6);
48308 }
48309 if (obj6) {
48310 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
48311 if (!SWIG_IsOK(res7)) {
48312 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48313 }
48314 if (!argp7) {
48315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
48316 }
48317 arg7 = reinterpret_cast< wxValidator * >(argp7);
48318 }
48319 if (obj7) {
48320 {
48321 arg8 = wxString_in_helper(obj7);
48322 if (arg8 == NULL) SWIG_fail;
48323 temp8 = true;
48324 }
48325 }
48326 {
48327 PyThreadState* __tstate = wxPyBeginAllowThreads();
48328 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
48329 wxPyEndAllowThreads(__tstate);
48330 if (PyErr_Occurred()) SWIG_fail;
48331 }
48332 {
48333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48334 }
48335 {
48336 if (temp8)
48337 delete arg8;
48338 }
48339 return resultobj;
48340 fail:
48341 {
48342 if (temp8)
48343 delete arg8;
48344 }
48345 return NULL;
48346 }
48347
48348
48349 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48350 PyObject *resultobj = 0;
48351 wxControl *arg1 = (wxControl *) 0 ;
48352 int result;
48353 void *argp1 = 0 ;
48354 int res1 = 0 ;
48355 PyObject *swig_obj[1] ;
48356
48357 if (!args) SWIG_fail;
48358 swig_obj[0] = args;
48359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48360 if (!SWIG_IsOK(res1)) {
48361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
48362 }
48363 arg1 = reinterpret_cast< wxControl * >(argp1);
48364 {
48365 PyThreadState* __tstate = wxPyBeginAllowThreads();
48366 result = (int)((wxControl const *)arg1)->GetAlignment();
48367 wxPyEndAllowThreads(__tstate);
48368 if (PyErr_Occurred()) SWIG_fail;
48369 }
48370 resultobj = SWIG_From_int(static_cast< int >(result));
48371 return resultobj;
48372 fail:
48373 return NULL;
48374 }
48375
48376
48377 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48378 PyObject *resultobj = 0;
48379 wxControl *arg1 = (wxControl *) 0 ;
48380 wxString result;
48381 void *argp1 = 0 ;
48382 int res1 = 0 ;
48383 PyObject *swig_obj[1] ;
48384
48385 if (!args) SWIG_fail;
48386 swig_obj[0] = args;
48387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48388 if (!SWIG_IsOK(res1)) {
48389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
48390 }
48391 arg1 = reinterpret_cast< wxControl * >(argp1);
48392 {
48393 PyThreadState* __tstate = wxPyBeginAllowThreads();
48394 result = ((wxControl const *)arg1)->GetLabelText();
48395 wxPyEndAllowThreads(__tstate);
48396 if (PyErr_Occurred()) SWIG_fail;
48397 }
48398 {
48399 #if wxUSE_UNICODE
48400 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48401 #else
48402 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48403 #endif
48404 }
48405 return resultobj;
48406 fail:
48407 return NULL;
48408 }
48409
48410
48411 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48412 PyObject *resultobj = 0;
48413 wxControl *arg1 = (wxControl *) 0 ;
48414 wxCommandEvent *arg2 = 0 ;
48415 void *argp1 = 0 ;
48416 int res1 = 0 ;
48417 void *argp2 = 0 ;
48418 int res2 = 0 ;
48419 PyObject * obj0 = 0 ;
48420 PyObject * obj1 = 0 ;
48421 char * kwnames[] = {
48422 (char *) "self",(char *) "event", NULL
48423 };
48424
48425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
48426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
48427 if (!SWIG_IsOK(res1)) {
48428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
48429 }
48430 arg1 = reinterpret_cast< wxControl * >(argp1);
48431 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
48432 if (!SWIG_IsOK(res2)) {
48433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48434 }
48435 if (!argp2) {
48436 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
48437 }
48438 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
48439 {
48440 PyThreadState* __tstate = wxPyBeginAllowThreads();
48441 (arg1)->Command(*arg2);
48442 wxPyEndAllowThreads(__tstate);
48443 if (PyErr_Occurred()) SWIG_fail;
48444 }
48445 resultobj = SWIG_Py_Void();
48446 return resultobj;
48447 fail:
48448 return NULL;
48449 }
48450
48451
48452 SWIGINTERN PyObject *_wrap_Control_RemoveMnemonics(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48453 PyObject *resultobj = 0;
48454 wxString *arg1 = 0 ;
48455 wxString result;
48456 bool temp1 = false ;
48457 PyObject * obj0 = 0 ;
48458 char * kwnames[] = {
48459 (char *) "str", NULL
48460 };
48461
48462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_RemoveMnemonics",kwnames,&obj0)) SWIG_fail;
48463 {
48464 arg1 = wxString_in_helper(obj0);
48465 if (arg1 == NULL) SWIG_fail;
48466 temp1 = true;
48467 }
48468 {
48469 PyThreadState* __tstate = wxPyBeginAllowThreads();
48470 result = wxControl::RemoveMnemonics((wxString const &)*arg1);
48471 wxPyEndAllowThreads(__tstate);
48472 if (PyErr_Occurred()) SWIG_fail;
48473 }
48474 {
48475 #if wxUSE_UNICODE
48476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48477 #else
48478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48479 #endif
48480 }
48481 {
48482 if (temp1)
48483 delete arg1;
48484 }
48485 return resultobj;
48486 fail:
48487 {
48488 if (temp1)
48489 delete arg1;
48490 }
48491 return NULL;
48492 }
48493
48494
48495 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48496 PyObject *resultobj = 0;
48497 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
48498 SwigValueWrapper<wxVisualAttributes > result;
48499 int val1 ;
48500 int ecode1 = 0 ;
48501 PyObject * obj0 = 0 ;
48502 char * kwnames[] = {
48503 (char *) "variant", NULL
48504 };
48505
48506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
48507 if (obj0) {
48508 ecode1 = SWIG_AsVal_int(obj0, &val1);
48509 if (!SWIG_IsOK(ecode1)) {
48510 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
48511 }
48512 arg1 = static_cast< wxWindowVariant >(val1);
48513 }
48514 {
48515 if (!wxPyCheckForApp()) SWIG_fail;
48516 PyThreadState* __tstate = wxPyBeginAllowThreads();
48517 result = wxControl::GetClassDefaultAttributes(arg1);
48518 wxPyEndAllowThreads(__tstate);
48519 if (PyErr_Occurred()) SWIG_fail;
48520 }
48521 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
48522 return resultobj;
48523 fail:
48524 return NULL;
48525 }
48526
48527
48528 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48529 PyObject *obj;
48530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48531 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
48532 return SWIG_Py_Void();
48533 }
48534
48535 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48536 return SWIG_Python_InitShadowInstance(args);
48537 }
48538
48539 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48540 PyObject *resultobj = 0;
48541 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48542 wxString *arg2 = 0 ;
48543 PyObject *arg3 = (PyObject *) NULL ;
48544 int result;
48545 void *argp1 = 0 ;
48546 int res1 = 0 ;
48547 bool temp2 = false ;
48548 PyObject * obj0 = 0 ;
48549 PyObject * obj1 = 0 ;
48550 PyObject * obj2 = 0 ;
48551 char * kwnames[] = {
48552 (char *) "self",(char *) "item",(char *) "clientData", NULL
48553 };
48554
48555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48557 if (!SWIG_IsOK(res1)) {
48558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48559 }
48560 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48561 {
48562 arg2 = wxString_in_helper(obj1);
48563 if (arg2 == NULL) SWIG_fail;
48564 temp2 = true;
48565 }
48566 if (obj2) {
48567 arg3 = obj2;
48568 }
48569 {
48570 PyThreadState* __tstate = wxPyBeginAllowThreads();
48571 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
48572 wxPyEndAllowThreads(__tstate);
48573 if (PyErr_Occurred()) SWIG_fail;
48574 }
48575 resultobj = SWIG_From_int(static_cast< int >(result));
48576 {
48577 if (temp2)
48578 delete arg2;
48579 }
48580 return resultobj;
48581 fail:
48582 {
48583 if (temp2)
48584 delete arg2;
48585 }
48586 return NULL;
48587 }
48588
48589
48590 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48591 PyObject *resultobj = 0;
48592 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48593 wxArrayString *arg2 = 0 ;
48594 void *argp1 = 0 ;
48595 int res1 = 0 ;
48596 bool temp2 = false ;
48597 PyObject * obj0 = 0 ;
48598 PyObject * obj1 = 0 ;
48599 char * kwnames[] = {
48600 (char *) "self",(char *) "strings", NULL
48601 };
48602
48603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
48604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48605 if (!SWIG_IsOK(res1)) {
48606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48607 }
48608 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48609 {
48610 if (! PySequence_Check(obj1)) {
48611 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
48612 SWIG_fail;
48613 }
48614 arg2 = new wxArrayString;
48615 temp2 = true;
48616 int i, len=PySequence_Length(obj1);
48617 for (i=0; i<len; i++) {
48618 PyObject* item = PySequence_GetItem(obj1, i);
48619 wxString* s = wxString_in_helper(item);
48620 if (PyErr_Occurred()) SWIG_fail;
48621 arg2->Add(*s);
48622 delete s;
48623 Py_DECREF(item);
48624 }
48625 }
48626 {
48627 PyThreadState* __tstate = wxPyBeginAllowThreads();
48628 (arg1)->Append((wxArrayString const &)*arg2);
48629 wxPyEndAllowThreads(__tstate);
48630 if (PyErr_Occurred()) SWIG_fail;
48631 }
48632 resultobj = SWIG_Py_Void();
48633 {
48634 if (temp2) delete arg2;
48635 }
48636 return resultobj;
48637 fail:
48638 {
48639 if (temp2) delete arg2;
48640 }
48641 return NULL;
48642 }
48643
48644
48645 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48646 PyObject *resultobj = 0;
48647 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48648 wxString *arg2 = 0 ;
48649 int arg3 ;
48650 PyObject *arg4 = (PyObject *) NULL ;
48651 int result;
48652 void *argp1 = 0 ;
48653 int res1 = 0 ;
48654 bool temp2 = false ;
48655 int val3 ;
48656 int ecode3 = 0 ;
48657 PyObject * obj0 = 0 ;
48658 PyObject * obj1 = 0 ;
48659 PyObject * obj2 = 0 ;
48660 PyObject * obj3 = 0 ;
48661 char * kwnames[] = {
48662 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
48663 };
48664
48665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48667 if (!SWIG_IsOK(res1)) {
48668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48669 }
48670 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48671 {
48672 arg2 = wxString_in_helper(obj1);
48673 if (arg2 == NULL) SWIG_fail;
48674 temp2 = true;
48675 }
48676 ecode3 = SWIG_AsVal_int(obj2, &val3);
48677 if (!SWIG_IsOK(ecode3)) {
48678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
48679 }
48680 arg3 = static_cast< int >(val3);
48681 if (obj3) {
48682 arg4 = obj3;
48683 }
48684 {
48685 PyThreadState* __tstate = wxPyBeginAllowThreads();
48686 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
48687 wxPyEndAllowThreads(__tstate);
48688 if (PyErr_Occurred()) SWIG_fail;
48689 }
48690 resultobj = SWIG_From_int(static_cast< int >(result));
48691 {
48692 if (temp2)
48693 delete arg2;
48694 }
48695 return resultobj;
48696 fail:
48697 {
48698 if (temp2)
48699 delete arg2;
48700 }
48701 return NULL;
48702 }
48703
48704
48705 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48706 PyObject *resultobj = 0;
48707 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48708 void *argp1 = 0 ;
48709 int res1 = 0 ;
48710 PyObject *swig_obj[1] ;
48711
48712 if (!args) SWIG_fail;
48713 swig_obj[0] = args;
48714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48715 if (!SWIG_IsOK(res1)) {
48716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48717 }
48718 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48719 {
48720 PyThreadState* __tstate = wxPyBeginAllowThreads();
48721 (arg1)->Clear();
48722 wxPyEndAllowThreads(__tstate);
48723 if (PyErr_Occurred()) SWIG_fail;
48724 }
48725 resultobj = SWIG_Py_Void();
48726 return resultobj;
48727 fail:
48728 return NULL;
48729 }
48730
48731
48732 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48733 PyObject *resultobj = 0;
48734 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48735 int arg2 ;
48736 void *argp1 = 0 ;
48737 int res1 = 0 ;
48738 int val2 ;
48739 int ecode2 = 0 ;
48740 PyObject * obj0 = 0 ;
48741 PyObject * obj1 = 0 ;
48742 char * kwnames[] = {
48743 (char *) "self",(char *) "n", NULL
48744 };
48745
48746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48748 if (!SWIG_IsOK(res1)) {
48749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48750 }
48751 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48752 ecode2 = SWIG_AsVal_int(obj1, &val2);
48753 if (!SWIG_IsOK(ecode2)) {
48754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48755 }
48756 arg2 = static_cast< int >(val2);
48757 {
48758 PyThreadState* __tstate = wxPyBeginAllowThreads();
48759 (arg1)->Delete(arg2);
48760 wxPyEndAllowThreads(__tstate);
48761 if (PyErr_Occurred()) SWIG_fail;
48762 }
48763 resultobj = SWIG_Py_Void();
48764 return resultobj;
48765 fail:
48766 return NULL;
48767 }
48768
48769
48770 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48771 PyObject *resultobj = 0;
48772 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48773 int arg2 ;
48774 PyObject *result = 0 ;
48775 void *argp1 = 0 ;
48776 int res1 = 0 ;
48777 int val2 ;
48778 int ecode2 = 0 ;
48779 PyObject * obj0 = 0 ;
48780 PyObject * obj1 = 0 ;
48781 char * kwnames[] = {
48782 (char *) "self",(char *) "n", NULL
48783 };
48784
48785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48787 if (!SWIG_IsOK(res1)) {
48788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48789 }
48790 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48791 ecode2 = SWIG_AsVal_int(obj1, &val2);
48792 if (!SWIG_IsOK(ecode2)) {
48793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48794 }
48795 arg2 = static_cast< int >(val2);
48796 {
48797 PyThreadState* __tstate = wxPyBeginAllowThreads();
48798 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48799 wxPyEndAllowThreads(__tstate);
48800 if (PyErr_Occurred()) SWIG_fail;
48801 }
48802 resultobj = result;
48803 return resultobj;
48804 fail:
48805 return NULL;
48806 }
48807
48808
48809 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48810 PyObject *resultobj = 0;
48811 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48812 int arg2 ;
48813 PyObject *arg3 = (PyObject *) 0 ;
48814 void *argp1 = 0 ;
48815 int res1 = 0 ;
48816 int val2 ;
48817 int ecode2 = 0 ;
48818 PyObject * obj0 = 0 ;
48819 PyObject * obj1 = 0 ;
48820 PyObject * obj2 = 0 ;
48821 char * kwnames[] = {
48822 (char *) "self",(char *) "n",(char *) "clientData", NULL
48823 };
48824
48825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48827 if (!SWIG_IsOK(res1)) {
48828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48829 }
48830 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48831 ecode2 = SWIG_AsVal_int(obj1, &val2);
48832 if (!SWIG_IsOK(ecode2)) {
48833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48834 }
48835 arg2 = static_cast< int >(val2);
48836 arg3 = obj2;
48837 {
48838 PyThreadState* __tstate = wxPyBeginAllowThreads();
48839 wxItemContainer_SetClientData(arg1,arg2,arg3);
48840 wxPyEndAllowThreads(__tstate);
48841 if (PyErr_Occurred()) SWIG_fail;
48842 }
48843 resultobj = SWIG_Py_Void();
48844 return resultobj;
48845 fail:
48846 return NULL;
48847 }
48848
48849
48850 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48851 PyObject *resultobj = 0;
48852 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48853 int result;
48854 void *argp1 = 0 ;
48855 int res1 = 0 ;
48856 PyObject *swig_obj[1] ;
48857
48858 if (!args) SWIG_fail;
48859 swig_obj[0] = args;
48860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48861 if (!SWIG_IsOK(res1)) {
48862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48863 }
48864 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48865 {
48866 PyThreadState* __tstate = wxPyBeginAllowThreads();
48867 result = (int)((wxItemContainer const *)arg1)->GetCount();
48868 wxPyEndAllowThreads(__tstate);
48869 if (PyErr_Occurred()) SWIG_fail;
48870 }
48871 resultobj = SWIG_From_int(static_cast< int >(result));
48872 return resultobj;
48873 fail:
48874 return NULL;
48875 }
48876
48877
48878 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48879 PyObject *resultobj = 0;
48880 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48881 bool result;
48882 void *argp1 = 0 ;
48883 int res1 = 0 ;
48884 PyObject *swig_obj[1] ;
48885
48886 if (!args) SWIG_fail;
48887 swig_obj[0] = args;
48888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48889 if (!SWIG_IsOK(res1)) {
48890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48891 }
48892 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48893 {
48894 PyThreadState* __tstate = wxPyBeginAllowThreads();
48895 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48896 wxPyEndAllowThreads(__tstate);
48897 if (PyErr_Occurred()) SWIG_fail;
48898 }
48899 {
48900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48901 }
48902 return resultobj;
48903 fail:
48904 return NULL;
48905 }
48906
48907
48908 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48909 PyObject *resultobj = 0;
48910 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48911 int arg2 ;
48912 wxString result;
48913 void *argp1 = 0 ;
48914 int res1 = 0 ;
48915 int val2 ;
48916 int ecode2 = 0 ;
48917 PyObject * obj0 = 0 ;
48918 PyObject * obj1 = 0 ;
48919 char * kwnames[] = {
48920 (char *) "self",(char *) "n", NULL
48921 };
48922
48923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48925 if (!SWIG_IsOK(res1)) {
48926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48927 }
48928 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48929 ecode2 = SWIG_AsVal_int(obj1, &val2);
48930 if (!SWIG_IsOK(ecode2)) {
48931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48932 }
48933 arg2 = static_cast< int >(val2);
48934 {
48935 PyThreadState* __tstate = wxPyBeginAllowThreads();
48936 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48937 wxPyEndAllowThreads(__tstate);
48938 if (PyErr_Occurred()) SWIG_fail;
48939 }
48940 {
48941 #if wxUSE_UNICODE
48942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48943 #else
48944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48945 #endif
48946 }
48947 return resultobj;
48948 fail:
48949 return NULL;
48950 }
48951
48952
48953 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48954 PyObject *resultobj = 0;
48955 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48956 wxArrayString result;
48957 void *argp1 = 0 ;
48958 int res1 = 0 ;
48959 PyObject *swig_obj[1] ;
48960
48961 if (!args) SWIG_fail;
48962 swig_obj[0] = args;
48963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48964 if (!SWIG_IsOK(res1)) {
48965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48966 }
48967 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48968 {
48969 PyThreadState* __tstate = wxPyBeginAllowThreads();
48970 result = ((wxItemContainer const *)arg1)->GetStrings();
48971 wxPyEndAllowThreads(__tstate);
48972 if (PyErr_Occurred()) SWIG_fail;
48973 }
48974 {
48975 resultobj = wxArrayString2PyList_helper(result);
48976 }
48977 return resultobj;
48978 fail:
48979 return NULL;
48980 }
48981
48982
48983 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48984 PyObject *resultobj = 0;
48985 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48986 int arg2 ;
48987 wxString *arg3 = 0 ;
48988 void *argp1 = 0 ;
48989 int res1 = 0 ;
48990 int val2 ;
48991 int ecode2 = 0 ;
48992 bool temp3 = false ;
48993 PyObject * obj0 = 0 ;
48994 PyObject * obj1 = 0 ;
48995 PyObject * obj2 = 0 ;
48996 char * kwnames[] = {
48997 (char *) "self",(char *) "n",(char *) "s", NULL
48998 };
48999
49000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49002 if (!SWIG_IsOK(res1)) {
49003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49004 }
49005 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49006 ecode2 = SWIG_AsVal_int(obj1, &val2);
49007 if (!SWIG_IsOK(ecode2)) {
49008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
49009 }
49010 arg2 = static_cast< int >(val2);
49011 {
49012 arg3 = wxString_in_helper(obj2);
49013 if (arg3 == NULL) SWIG_fail;
49014 temp3 = true;
49015 }
49016 {
49017 PyThreadState* __tstate = wxPyBeginAllowThreads();
49018 (arg1)->SetString(arg2,(wxString const &)*arg3);
49019 wxPyEndAllowThreads(__tstate);
49020 if (PyErr_Occurred()) SWIG_fail;
49021 }
49022 resultobj = SWIG_Py_Void();
49023 {
49024 if (temp3)
49025 delete arg3;
49026 }
49027 return resultobj;
49028 fail:
49029 {
49030 if (temp3)
49031 delete arg3;
49032 }
49033 return NULL;
49034 }
49035
49036
49037 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49038 PyObject *resultobj = 0;
49039 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49040 wxString *arg2 = 0 ;
49041 int result;
49042 void *argp1 = 0 ;
49043 int res1 = 0 ;
49044 bool temp2 = false ;
49045 PyObject * obj0 = 0 ;
49046 PyObject * obj1 = 0 ;
49047 char * kwnames[] = {
49048 (char *) "self",(char *) "s", NULL
49049 };
49050
49051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
49052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49053 if (!SWIG_IsOK(res1)) {
49054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49055 }
49056 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49057 {
49058 arg2 = wxString_in_helper(obj1);
49059 if (arg2 == NULL) SWIG_fail;
49060 temp2 = true;
49061 }
49062 {
49063 PyThreadState* __tstate = wxPyBeginAllowThreads();
49064 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
49065 wxPyEndAllowThreads(__tstate);
49066 if (PyErr_Occurred()) SWIG_fail;
49067 }
49068 resultobj = SWIG_From_int(static_cast< int >(result));
49069 {
49070 if (temp2)
49071 delete arg2;
49072 }
49073 return resultobj;
49074 fail:
49075 {
49076 if (temp2)
49077 delete arg2;
49078 }
49079 return NULL;
49080 }
49081
49082
49083 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49084 PyObject *resultobj = 0;
49085 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49086 int arg2 ;
49087 void *argp1 = 0 ;
49088 int res1 = 0 ;
49089 int val2 ;
49090 int ecode2 = 0 ;
49091 PyObject * obj0 = 0 ;
49092 PyObject * obj1 = 0 ;
49093 char * kwnames[] = {
49094 (char *) "self",(char *) "n", NULL
49095 };
49096
49097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49099 if (!SWIG_IsOK(res1)) {
49100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49101 }
49102 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49103 ecode2 = SWIG_AsVal_int(obj1, &val2);
49104 if (!SWIG_IsOK(ecode2)) {
49105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
49106 }
49107 arg2 = static_cast< int >(val2);
49108 {
49109 PyThreadState* __tstate = wxPyBeginAllowThreads();
49110 (arg1)->SetSelection(arg2);
49111 wxPyEndAllowThreads(__tstate);
49112 if (PyErr_Occurred()) SWIG_fail;
49113 }
49114 resultobj = SWIG_Py_Void();
49115 return resultobj;
49116 fail:
49117 return NULL;
49118 }
49119
49120
49121 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49122 PyObject *resultobj = 0;
49123 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49124 int result;
49125 void *argp1 = 0 ;
49126 int res1 = 0 ;
49127 PyObject *swig_obj[1] ;
49128
49129 if (!args) SWIG_fail;
49130 swig_obj[0] = args;
49131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49132 if (!SWIG_IsOK(res1)) {
49133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49134 }
49135 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49136 {
49137 PyThreadState* __tstate = wxPyBeginAllowThreads();
49138 result = (int)((wxItemContainer const *)arg1)->GetSelection();
49139 wxPyEndAllowThreads(__tstate);
49140 if (PyErr_Occurred()) SWIG_fail;
49141 }
49142 resultobj = SWIG_From_int(static_cast< int >(result));
49143 return resultobj;
49144 fail:
49145 return NULL;
49146 }
49147
49148
49149 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49150 PyObject *resultobj = 0;
49151 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49152 wxString *arg2 = 0 ;
49153 bool result;
49154 void *argp1 = 0 ;
49155 int res1 = 0 ;
49156 bool temp2 = false ;
49157 PyObject * obj0 = 0 ;
49158 PyObject * obj1 = 0 ;
49159 char * kwnames[] = {
49160 (char *) "self",(char *) "s", NULL
49161 };
49162
49163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
49164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49165 if (!SWIG_IsOK(res1)) {
49166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49167 }
49168 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49169 {
49170 arg2 = wxString_in_helper(obj1);
49171 if (arg2 == NULL) SWIG_fail;
49172 temp2 = true;
49173 }
49174 {
49175 PyThreadState* __tstate = wxPyBeginAllowThreads();
49176 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
49177 wxPyEndAllowThreads(__tstate);
49178 if (PyErr_Occurred()) SWIG_fail;
49179 }
49180 {
49181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49182 }
49183 {
49184 if (temp2)
49185 delete arg2;
49186 }
49187 return resultobj;
49188 fail:
49189 {
49190 if (temp2)
49191 delete arg2;
49192 }
49193 return NULL;
49194 }
49195
49196
49197 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49198 PyObject *resultobj = 0;
49199 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49200 wxString result;
49201 void *argp1 = 0 ;
49202 int res1 = 0 ;
49203 PyObject *swig_obj[1] ;
49204
49205 if (!args) SWIG_fail;
49206 swig_obj[0] = args;
49207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49208 if (!SWIG_IsOK(res1)) {
49209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
49210 }
49211 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49212 {
49213 PyThreadState* __tstate = wxPyBeginAllowThreads();
49214 result = ((wxItemContainer const *)arg1)->GetStringSelection();
49215 wxPyEndAllowThreads(__tstate);
49216 if (PyErr_Occurred()) SWIG_fail;
49217 }
49218 {
49219 #if wxUSE_UNICODE
49220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
49221 #else
49222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
49223 #endif
49224 }
49225 return resultobj;
49226 fail:
49227 return NULL;
49228 }
49229
49230
49231 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49232 PyObject *resultobj = 0;
49233 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
49234 int arg2 ;
49235 void *argp1 = 0 ;
49236 int res1 = 0 ;
49237 int val2 ;
49238 int ecode2 = 0 ;
49239 PyObject * obj0 = 0 ;
49240 PyObject * obj1 = 0 ;
49241 char * kwnames[] = {
49242 (char *) "self",(char *) "n", NULL
49243 };
49244
49245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
49246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
49247 if (!SWIG_IsOK(res1)) {
49248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
49249 }
49250 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
49251 ecode2 = SWIG_AsVal_int(obj1, &val2);
49252 if (!SWIG_IsOK(ecode2)) {
49253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
49254 }
49255 arg2 = static_cast< int >(val2);
49256 {
49257 PyThreadState* __tstate = wxPyBeginAllowThreads();
49258 (arg1)->Select(arg2);
49259 wxPyEndAllowThreads(__tstate);
49260 if (PyErr_Occurred()) SWIG_fail;
49261 }
49262 resultobj = SWIG_Py_Void();
49263 return resultobj;
49264 fail:
49265 return NULL;
49266 }
49267
49268
49269 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49270 PyObject *obj;
49271 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49272 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
49273 return SWIG_Py_Void();
49274 }
49275
49276 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49277 PyObject *obj;
49278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49279 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
49280 return SWIG_Py_Void();
49281 }
49282
49283 SWIGINTERN PyObject *_wrap_new_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49284 PyObject *resultobj = 0;
49285 int arg1 = (int) 0 ;
49286 wxSizerFlags *result = 0 ;
49287 int val1 ;
49288 int ecode1 = 0 ;
49289 PyObject * obj0 = 0 ;
49290 char * kwnames[] = {
49291 (char *) "proportion", NULL
49292 };
49293
49294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_SizerFlags",kwnames,&obj0)) SWIG_fail;
49295 if (obj0) {
49296 ecode1 = SWIG_AsVal_int(obj0, &val1);
49297 if (!SWIG_IsOK(ecode1)) {
49298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerFlags" "', expected argument " "1"" of type '" "int""'");
49299 }
49300 arg1 = static_cast< int >(val1);
49301 }
49302 {
49303 PyThreadState* __tstate = wxPyBeginAllowThreads();
49304 result = (wxSizerFlags *)new wxSizerFlags(arg1);
49305 wxPyEndAllowThreads(__tstate);
49306 if (PyErr_Occurred()) SWIG_fail;
49307 }
49308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_NEW | 0 );
49309 return resultobj;
49310 fail:
49311 return NULL;
49312 }
49313
49314
49315 SWIGINTERN PyObject *_wrap_delete_SizerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49316 PyObject *resultobj = 0;
49317 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49318 void *argp1 = 0 ;
49319 int res1 = 0 ;
49320 PyObject *swig_obj[1] ;
49321
49322 if (!args) SWIG_fail;
49323 swig_obj[0] = args;
49324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, SWIG_POINTER_DISOWN | 0 );
49325 if (!SWIG_IsOK(res1)) {
49326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerFlags" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49327 }
49328 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49329 {
49330 PyThreadState* __tstate = wxPyBeginAllowThreads();
49331 delete arg1;
49332
49333 wxPyEndAllowThreads(__tstate);
49334 if (PyErr_Occurred()) SWIG_fail;
49335 }
49336 resultobj = SWIG_Py_Void();
49337 return resultobj;
49338 fail:
49339 return NULL;
49340 }
49341
49342
49343 SWIGINTERN PyObject *_wrap_SizerFlags_Proportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49344 PyObject *resultobj = 0;
49345 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49346 int arg2 ;
49347 wxSizerFlags *result = 0 ;
49348 void *argp1 = 0 ;
49349 int res1 = 0 ;
49350 int val2 ;
49351 int ecode2 = 0 ;
49352 PyObject * obj0 = 0 ;
49353 PyObject * obj1 = 0 ;
49354 char * kwnames[] = {
49355 (char *) "self",(char *) "proportion", NULL
49356 };
49357
49358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Proportion",kwnames,&obj0,&obj1)) SWIG_fail;
49359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49360 if (!SWIG_IsOK(res1)) {
49361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Proportion" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49362 }
49363 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49364 ecode2 = SWIG_AsVal_int(obj1, &val2);
49365 if (!SWIG_IsOK(ecode2)) {
49366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Proportion" "', expected argument " "2"" of type '" "int""'");
49367 }
49368 arg2 = static_cast< int >(val2);
49369 {
49370 PyThreadState* __tstate = wxPyBeginAllowThreads();
49371 {
49372 wxSizerFlags &_result_ref = (arg1)->Proportion(arg2);
49373 result = (wxSizerFlags *) &_result_ref;
49374 }
49375 wxPyEndAllowThreads(__tstate);
49376 if (PyErr_Occurred()) SWIG_fail;
49377 }
49378 {
49379 resultobj = obj0; Py_INCREF(resultobj);
49380 }
49381 return resultobj;
49382 fail:
49383 return NULL;
49384 }
49385
49386
49387 SWIGINTERN PyObject *_wrap_SizerFlags_Align(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49388 PyObject *resultobj = 0;
49389 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49390 int arg2 ;
49391 wxSizerFlags *result = 0 ;
49392 void *argp1 = 0 ;
49393 int res1 = 0 ;
49394 int val2 ;
49395 int ecode2 = 0 ;
49396 PyObject * obj0 = 0 ;
49397 PyObject * obj1 = 0 ;
49398 char * kwnames[] = {
49399 (char *) "self",(char *) "alignment", NULL
49400 };
49401
49402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerFlags_Align",kwnames,&obj0,&obj1)) SWIG_fail;
49403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49404 if (!SWIG_IsOK(res1)) {
49405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Align" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49406 }
49407 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49408 ecode2 = SWIG_AsVal_int(obj1, &val2);
49409 if (!SWIG_IsOK(ecode2)) {
49410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Align" "', expected argument " "2"" of type '" "int""'");
49411 }
49412 arg2 = static_cast< int >(val2);
49413 {
49414 PyThreadState* __tstate = wxPyBeginAllowThreads();
49415 {
49416 wxSizerFlags &_result_ref = (arg1)->Align(arg2);
49417 result = (wxSizerFlags *) &_result_ref;
49418 }
49419 wxPyEndAllowThreads(__tstate);
49420 if (PyErr_Occurred()) SWIG_fail;
49421 }
49422 {
49423 resultobj = obj0; Py_INCREF(resultobj);
49424 }
49425 return resultobj;
49426 fail:
49427 return NULL;
49428 }
49429
49430
49431 SWIGINTERN PyObject *_wrap_SizerFlags_Expand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49432 PyObject *resultobj = 0;
49433 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49434 wxSizerFlags *result = 0 ;
49435 void *argp1 = 0 ;
49436 int res1 = 0 ;
49437 PyObject *swig_obj[1] ;
49438
49439 if (!args) SWIG_fail;
49440 swig_obj[0] = args;
49441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49442 if (!SWIG_IsOK(res1)) {
49443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Expand" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49444 }
49445 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49446 {
49447 PyThreadState* __tstate = wxPyBeginAllowThreads();
49448 {
49449 wxSizerFlags &_result_ref = (arg1)->Expand();
49450 result = (wxSizerFlags *) &_result_ref;
49451 }
49452 wxPyEndAllowThreads(__tstate);
49453 if (PyErr_Occurred()) SWIG_fail;
49454 }
49455 {
49456 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49457 }
49458 return resultobj;
49459 fail:
49460 return NULL;
49461 }
49462
49463
49464 SWIGINTERN PyObject *_wrap_SizerFlags_Centre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49465 PyObject *resultobj = 0;
49466 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49467 wxSizerFlags *result = 0 ;
49468 void *argp1 = 0 ;
49469 int res1 = 0 ;
49470 PyObject *swig_obj[1] ;
49471
49472 if (!args) SWIG_fail;
49473 swig_obj[0] = args;
49474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49475 if (!SWIG_IsOK(res1)) {
49476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Centre" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49477 }
49478 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49479 {
49480 PyThreadState* __tstate = wxPyBeginAllowThreads();
49481 {
49482 wxSizerFlags &_result_ref = (arg1)->Centre();
49483 result = (wxSizerFlags *) &_result_ref;
49484 }
49485 wxPyEndAllowThreads(__tstate);
49486 if (PyErr_Occurred()) SWIG_fail;
49487 }
49488 {
49489 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49490 }
49491 return resultobj;
49492 fail:
49493 return NULL;
49494 }
49495
49496
49497 SWIGINTERN PyObject *_wrap_SizerFlags_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49498 PyObject *resultobj = 0;
49499 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49500 wxSizerFlags *result = 0 ;
49501 void *argp1 = 0 ;
49502 int res1 = 0 ;
49503 PyObject *swig_obj[1] ;
49504
49505 if (!args) SWIG_fail;
49506 swig_obj[0] = args;
49507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49508 if (!SWIG_IsOK(res1)) {
49509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Center" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49510 }
49511 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49512 {
49513 PyThreadState* __tstate = wxPyBeginAllowThreads();
49514 {
49515 wxSizerFlags &_result_ref = (arg1)->Center();
49516 result = (wxSizerFlags *) &_result_ref;
49517 }
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 {
49522 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49523 }
49524 return resultobj;
49525 fail:
49526 return NULL;
49527 }
49528
49529
49530 SWIGINTERN PyObject *_wrap_SizerFlags_Left(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49531 PyObject *resultobj = 0;
49532 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49533 wxSizerFlags *result = 0 ;
49534 void *argp1 = 0 ;
49535 int res1 = 0 ;
49536 PyObject *swig_obj[1] ;
49537
49538 if (!args) SWIG_fail;
49539 swig_obj[0] = args;
49540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49541 if (!SWIG_IsOK(res1)) {
49542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Left" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49543 }
49544 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49545 {
49546 PyThreadState* __tstate = wxPyBeginAllowThreads();
49547 {
49548 wxSizerFlags &_result_ref = (arg1)->Left();
49549 result = (wxSizerFlags *) &_result_ref;
49550 }
49551 wxPyEndAllowThreads(__tstate);
49552 if (PyErr_Occurred()) SWIG_fail;
49553 }
49554 {
49555 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49556 }
49557 return resultobj;
49558 fail:
49559 return NULL;
49560 }
49561
49562
49563 SWIGINTERN PyObject *_wrap_SizerFlags_Right(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49564 PyObject *resultobj = 0;
49565 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49566 wxSizerFlags *result = 0 ;
49567 void *argp1 = 0 ;
49568 int res1 = 0 ;
49569 PyObject *swig_obj[1] ;
49570
49571 if (!args) SWIG_fail;
49572 swig_obj[0] = args;
49573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49574 if (!SWIG_IsOK(res1)) {
49575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Right" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49576 }
49577 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49578 {
49579 PyThreadState* __tstate = wxPyBeginAllowThreads();
49580 {
49581 wxSizerFlags &_result_ref = (arg1)->Right();
49582 result = (wxSizerFlags *) &_result_ref;
49583 }
49584 wxPyEndAllowThreads(__tstate);
49585 if (PyErr_Occurred()) SWIG_fail;
49586 }
49587 {
49588 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49589 }
49590 return resultobj;
49591 fail:
49592 return NULL;
49593 }
49594
49595
49596 SWIGINTERN PyObject *_wrap_SizerFlags_Top(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49597 PyObject *resultobj = 0;
49598 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49599 wxSizerFlags *result = 0 ;
49600 void *argp1 = 0 ;
49601 int res1 = 0 ;
49602 PyObject *swig_obj[1] ;
49603
49604 if (!args) SWIG_fail;
49605 swig_obj[0] = args;
49606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49607 if (!SWIG_IsOK(res1)) {
49608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Top" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49609 }
49610 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49611 {
49612 PyThreadState* __tstate = wxPyBeginAllowThreads();
49613 {
49614 wxSizerFlags &_result_ref = (arg1)->Top();
49615 result = (wxSizerFlags *) &_result_ref;
49616 }
49617 wxPyEndAllowThreads(__tstate);
49618 if (PyErr_Occurred()) SWIG_fail;
49619 }
49620 {
49621 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49622 }
49623 return resultobj;
49624 fail:
49625 return NULL;
49626 }
49627
49628
49629 SWIGINTERN PyObject *_wrap_SizerFlags_Bottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49630 PyObject *resultobj = 0;
49631 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49632 wxSizerFlags *result = 0 ;
49633 void *argp1 = 0 ;
49634 int res1 = 0 ;
49635 PyObject *swig_obj[1] ;
49636
49637 if (!args) SWIG_fail;
49638 swig_obj[0] = args;
49639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49640 if (!SWIG_IsOK(res1)) {
49641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Bottom" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49642 }
49643 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49644 {
49645 PyThreadState* __tstate = wxPyBeginAllowThreads();
49646 {
49647 wxSizerFlags &_result_ref = (arg1)->Bottom();
49648 result = (wxSizerFlags *) &_result_ref;
49649 }
49650 wxPyEndAllowThreads(__tstate);
49651 if (PyErr_Occurred()) SWIG_fail;
49652 }
49653 {
49654 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49655 }
49656 return resultobj;
49657 fail:
49658 return NULL;
49659 }
49660
49661
49662 SWIGINTERN PyObject *_wrap_SizerFlags_Shaped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49663 PyObject *resultobj = 0;
49664 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49665 wxSizerFlags *result = 0 ;
49666 void *argp1 = 0 ;
49667 int res1 = 0 ;
49668 PyObject *swig_obj[1] ;
49669
49670 if (!args) SWIG_fail;
49671 swig_obj[0] = args;
49672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49673 if (!SWIG_IsOK(res1)) {
49674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Shaped" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49675 }
49676 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49677 {
49678 PyThreadState* __tstate = wxPyBeginAllowThreads();
49679 {
49680 wxSizerFlags &_result_ref = (arg1)->Shaped();
49681 result = (wxSizerFlags *) &_result_ref;
49682 }
49683 wxPyEndAllowThreads(__tstate);
49684 if (PyErr_Occurred()) SWIG_fail;
49685 }
49686 {
49687 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49688 }
49689 return resultobj;
49690 fail:
49691 return NULL;
49692 }
49693
49694
49695 SWIGINTERN PyObject *_wrap_SizerFlags_FixedMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49696 PyObject *resultobj = 0;
49697 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49698 wxSizerFlags *result = 0 ;
49699 void *argp1 = 0 ;
49700 int res1 = 0 ;
49701 PyObject *swig_obj[1] ;
49702
49703 if (!args) SWIG_fail;
49704 swig_obj[0] = args;
49705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49706 if (!SWIG_IsOK(res1)) {
49707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_FixedMinSize" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49708 }
49709 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49710 {
49711 PyThreadState* __tstate = wxPyBeginAllowThreads();
49712 {
49713 wxSizerFlags &_result_ref = (arg1)->FixedMinSize();
49714 result = (wxSizerFlags *) &_result_ref;
49715 }
49716 wxPyEndAllowThreads(__tstate);
49717 if (PyErr_Occurred()) SWIG_fail;
49718 }
49719 {
49720 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49721 }
49722 return resultobj;
49723 fail:
49724 return NULL;
49725 }
49726
49727
49728 SWIGINTERN PyObject *_wrap_SizerFlags_Border(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49729 PyObject *resultobj = 0;
49730 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49731 int arg2 = (int) wxALL ;
49732 int arg3 = (int) -1 ;
49733 wxSizerFlags *result = 0 ;
49734 void *argp1 = 0 ;
49735 int res1 = 0 ;
49736 int val2 ;
49737 int ecode2 = 0 ;
49738 int val3 ;
49739 int ecode3 = 0 ;
49740 PyObject * obj0 = 0 ;
49741 PyObject * obj1 = 0 ;
49742 PyObject * obj2 = 0 ;
49743 char * kwnames[] = {
49744 (char *) "self",(char *) "direction",(char *) "borderInPixels", NULL
49745 };
49746
49747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:SizerFlags_Border",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49749 if (!SWIG_IsOK(res1)) {
49750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_Border" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49751 }
49752 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49753 if (obj1) {
49754 ecode2 = SWIG_AsVal_int(obj1, &val2);
49755 if (!SWIG_IsOK(ecode2)) {
49756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_Border" "', expected argument " "2"" of type '" "int""'");
49757 }
49758 arg2 = static_cast< int >(val2);
49759 }
49760 if (obj2) {
49761 ecode3 = SWIG_AsVal_int(obj2, &val3);
49762 if (!SWIG_IsOK(ecode3)) {
49763 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerFlags_Border" "', expected argument " "3"" of type '" "int""'");
49764 }
49765 arg3 = static_cast< int >(val3);
49766 }
49767 {
49768 PyThreadState* __tstate = wxPyBeginAllowThreads();
49769 {
49770 wxSizerFlags &_result_ref = wxSizerFlags_Border(arg1,arg2,arg3);
49771 result = (wxSizerFlags *) &_result_ref;
49772 }
49773 wxPyEndAllowThreads(__tstate);
49774 if (PyErr_Occurred()) SWIG_fail;
49775 }
49776 {
49777 resultobj = obj0; Py_INCREF(resultobj);
49778 }
49779 return resultobj;
49780 fail:
49781 return NULL;
49782 }
49783
49784
49785 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49786 PyObject *resultobj = 0;
49787 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49788 int arg2 = (int) wxALL ;
49789 wxSizerFlags *result = 0 ;
49790 void *argp1 = 0 ;
49791 int res1 = 0 ;
49792 int val2 ;
49793 int ecode2 = 0 ;
49794 PyObject * obj0 = 0 ;
49795 PyObject * obj1 = 0 ;
49796 char * kwnames[] = {
49797 (char *) "self",(char *) "direction", NULL
49798 };
49799
49800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_DoubleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49802 if (!SWIG_IsOK(res1)) {
49803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49804 }
49805 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49806 if (obj1) {
49807 ecode2 = SWIG_AsVal_int(obj1, &val2);
49808 if (!SWIG_IsOK(ecode2)) {
49809 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_DoubleBorder" "', expected argument " "2"" of type '" "int""'");
49810 }
49811 arg2 = static_cast< int >(val2);
49812 }
49813 {
49814 PyThreadState* __tstate = wxPyBeginAllowThreads();
49815 {
49816 wxSizerFlags &_result_ref = (arg1)->DoubleBorder(arg2);
49817 result = (wxSizerFlags *) &_result_ref;
49818 }
49819 wxPyEndAllowThreads(__tstate);
49820 if (PyErr_Occurred()) SWIG_fail;
49821 }
49822 {
49823 resultobj = obj0; Py_INCREF(resultobj);
49824 }
49825 return resultobj;
49826 fail:
49827 return NULL;
49828 }
49829
49830
49831 SWIGINTERN PyObject *_wrap_SizerFlags_TripleBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49832 PyObject *resultobj = 0;
49833 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49834 int arg2 = (int) wxALL ;
49835 wxSizerFlags *result = 0 ;
49836 void *argp1 = 0 ;
49837 int res1 = 0 ;
49838 int val2 ;
49839 int ecode2 = 0 ;
49840 PyObject * obj0 = 0 ;
49841 PyObject * obj1 = 0 ;
49842 char * kwnames[] = {
49843 (char *) "self",(char *) "direction", NULL
49844 };
49845
49846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:SizerFlags_TripleBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49848 if (!SWIG_IsOK(res1)) {
49849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_TripleBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49850 }
49851 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49852 if (obj1) {
49853 ecode2 = SWIG_AsVal_int(obj1, &val2);
49854 if (!SWIG_IsOK(ecode2)) {
49855 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerFlags_TripleBorder" "', expected argument " "2"" of type '" "int""'");
49856 }
49857 arg2 = static_cast< int >(val2);
49858 }
49859 {
49860 PyThreadState* __tstate = wxPyBeginAllowThreads();
49861 {
49862 wxSizerFlags &_result_ref = (arg1)->TripleBorder(arg2);
49863 result = (wxSizerFlags *) &_result_ref;
49864 }
49865 wxPyEndAllowThreads(__tstate);
49866 if (PyErr_Occurred()) SWIG_fail;
49867 }
49868 {
49869 resultobj = obj0; Py_INCREF(resultobj);
49870 }
49871 return resultobj;
49872 fail:
49873 return NULL;
49874 }
49875
49876
49877 SWIGINTERN PyObject *_wrap_SizerFlags_HorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49878 PyObject *resultobj = 0;
49879 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49880 wxSizerFlags *result = 0 ;
49881 void *argp1 = 0 ;
49882 int res1 = 0 ;
49883 PyObject *swig_obj[1] ;
49884
49885 if (!args) SWIG_fail;
49886 swig_obj[0] = args;
49887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49888 if (!SWIG_IsOK(res1)) {
49889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_HorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49890 }
49891 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49892 {
49893 PyThreadState* __tstate = wxPyBeginAllowThreads();
49894 {
49895 wxSizerFlags &_result_ref = (arg1)->HorzBorder();
49896 result = (wxSizerFlags *) &_result_ref;
49897 }
49898 wxPyEndAllowThreads(__tstate);
49899 if (PyErr_Occurred()) SWIG_fail;
49900 }
49901 {
49902 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49903 }
49904 return resultobj;
49905 fail:
49906 return NULL;
49907 }
49908
49909
49910 SWIGINTERN PyObject *_wrap_SizerFlags_DoubleHorzBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49911 PyObject *resultobj = 0;
49912 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49913 wxSizerFlags *result = 0 ;
49914 void *argp1 = 0 ;
49915 int res1 = 0 ;
49916 PyObject *swig_obj[1] ;
49917
49918 if (!args) SWIG_fail;
49919 swig_obj[0] = args;
49920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49921 if (!SWIG_IsOK(res1)) {
49922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_DoubleHorzBorder" "', expected argument " "1"" of type '" "wxSizerFlags *""'");
49923 }
49924 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49925 {
49926 PyThreadState* __tstate = wxPyBeginAllowThreads();
49927 {
49928 wxSizerFlags &_result_ref = (arg1)->DoubleHorzBorder();
49929 result = (wxSizerFlags *) &_result_ref;
49930 }
49931 wxPyEndAllowThreads(__tstate);
49932 if (PyErr_Occurred()) SWIG_fail;
49933 }
49934 {
49935 resultobj = swig_obj[0]; Py_INCREF(resultobj);
49936 }
49937 return resultobj;
49938 fail:
49939 return NULL;
49940 }
49941
49942
49943 SWIGINTERN PyObject *_wrap_SizerFlags_GetDefaultBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49944 PyObject *resultobj = 0;
49945 int result;
49946
49947 if (!SWIG_Python_UnpackTuple(args,"SizerFlags_GetDefaultBorder",0,0,0)) SWIG_fail;
49948 {
49949 PyThreadState* __tstate = wxPyBeginAllowThreads();
49950 result = (int)wxSizerFlags::GetDefaultBorder();
49951 wxPyEndAllowThreads(__tstate);
49952 if (PyErr_Occurred()) SWIG_fail;
49953 }
49954 resultobj = SWIG_From_int(static_cast< int >(result));
49955 return resultobj;
49956 fail:
49957 return NULL;
49958 }
49959
49960
49961 SWIGINTERN PyObject *_wrap_SizerFlags_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49962 PyObject *resultobj = 0;
49963 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49964 int result;
49965 void *argp1 = 0 ;
49966 int res1 = 0 ;
49967 PyObject *swig_obj[1] ;
49968
49969 if (!args) SWIG_fail;
49970 swig_obj[0] = args;
49971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
49972 if (!SWIG_IsOK(res1)) {
49973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetProportion" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
49974 }
49975 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
49976 {
49977 PyThreadState* __tstate = wxPyBeginAllowThreads();
49978 result = (int)((wxSizerFlags const *)arg1)->GetProportion();
49979 wxPyEndAllowThreads(__tstate);
49980 if (PyErr_Occurred()) SWIG_fail;
49981 }
49982 resultobj = SWIG_From_int(static_cast< int >(result));
49983 return resultobj;
49984 fail:
49985 return NULL;
49986 }
49987
49988
49989 SWIGINTERN PyObject *_wrap_SizerFlags_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49990 PyObject *resultobj = 0;
49991 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
49992 int result;
49993 void *argp1 = 0 ;
49994 int res1 = 0 ;
49995 PyObject *swig_obj[1] ;
49996
49997 if (!args) SWIG_fail;
49998 swig_obj[0] = args;
49999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50000 if (!SWIG_IsOK(res1)) {
50001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetFlags" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50002 }
50003 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50004 {
50005 PyThreadState* __tstate = wxPyBeginAllowThreads();
50006 result = (int)((wxSizerFlags const *)arg1)->GetFlags();
50007 wxPyEndAllowThreads(__tstate);
50008 if (PyErr_Occurred()) SWIG_fail;
50009 }
50010 resultobj = SWIG_From_int(static_cast< int >(result));
50011 return resultobj;
50012 fail:
50013 return NULL;
50014 }
50015
50016
50017 SWIGINTERN PyObject *_wrap_SizerFlags_GetBorderInPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50018 PyObject *resultobj = 0;
50019 wxSizerFlags *arg1 = (wxSizerFlags *) 0 ;
50020 int result;
50021 void *argp1 = 0 ;
50022 int res1 = 0 ;
50023 PyObject *swig_obj[1] ;
50024
50025 if (!args) SWIG_fail;
50026 swig_obj[0] = args;
50027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerFlags, 0 | 0 );
50028 if (!SWIG_IsOK(res1)) {
50029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerFlags_GetBorderInPixels" "', expected argument " "1"" of type '" "wxSizerFlags const *""'");
50030 }
50031 arg1 = reinterpret_cast< wxSizerFlags * >(argp1);
50032 {
50033 PyThreadState* __tstate = wxPyBeginAllowThreads();
50034 result = (int)((wxSizerFlags const *)arg1)->GetBorderInPixels();
50035 wxPyEndAllowThreads(__tstate);
50036 if (PyErr_Occurred()) SWIG_fail;
50037 }
50038 resultobj = SWIG_From_int(static_cast< int >(result));
50039 return resultobj;
50040 fail:
50041 return NULL;
50042 }
50043
50044
50045 SWIGINTERN PyObject *SizerFlags_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50046 PyObject *obj;
50047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50048 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerFlags, SWIG_NewClientData(obj));
50049 return SWIG_Py_Void();
50050 }
50051
50052 SWIGINTERN PyObject *SizerFlags_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50053 return SWIG_Python_InitShadowInstance(args);
50054 }
50055
50056 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50057 PyObject *resultobj = 0;
50058 wxSizerItem *result = 0 ;
50059
50060 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
50061 {
50062 PyThreadState* __tstate = wxPyBeginAllowThreads();
50063 result = (wxSizerItem *)new wxSizerItem();
50064 wxPyEndAllowThreads(__tstate);
50065 if (PyErr_Occurred()) SWIG_fail;
50066 }
50067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
50068 return resultobj;
50069 fail:
50070 return NULL;
50071 }
50072
50073
50074 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50075 PyObject *resultobj = 0;
50076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50077 void *argp1 = 0 ;
50078 int res1 = 0 ;
50079 PyObject *swig_obj[1] ;
50080
50081 if (!args) SWIG_fail;
50082 swig_obj[0] = args;
50083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50084 if (!SWIG_IsOK(res1)) {
50085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50086 }
50087 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50088 {
50089 PyThreadState* __tstate = wxPyBeginAllowThreads();
50090 delete arg1;
50091
50092 wxPyEndAllowThreads(__tstate);
50093 if (PyErr_Occurred()) SWIG_fail;
50094 }
50095 resultobj = SWIG_Py_Void();
50096 return resultobj;
50097 fail:
50098 return NULL;
50099 }
50100
50101
50102 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50103 PyObject *resultobj = 0;
50104 wxWindow *arg1 = (wxWindow *) 0 ;
50105 int arg2 ;
50106 int arg3 ;
50107 int arg4 ;
50108 PyObject *arg5 = (PyObject *) NULL ;
50109 wxSizerItem *result = 0 ;
50110 void *argp1 = 0 ;
50111 int res1 = 0 ;
50112 int val2 ;
50113 int ecode2 = 0 ;
50114 int val3 ;
50115 int ecode3 = 0 ;
50116 int val4 ;
50117 int ecode4 = 0 ;
50118 PyObject * obj0 = 0 ;
50119 PyObject * obj1 = 0 ;
50120 PyObject * obj2 = 0 ;
50121 PyObject * obj3 = 0 ;
50122 PyObject * obj4 = 0 ;
50123 char * kwnames[] = {
50124 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50125 };
50126
50127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
50129 if (!SWIG_IsOK(res1)) {
50130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
50131 }
50132 arg1 = reinterpret_cast< wxWindow * >(argp1);
50133 ecode2 = SWIG_AsVal_int(obj1, &val2);
50134 if (!SWIG_IsOK(ecode2)) {
50135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
50136 }
50137 arg2 = static_cast< int >(val2);
50138 ecode3 = SWIG_AsVal_int(obj2, &val3);
50139 if (!SWIG_IsOK(ecode3)) {
50140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
50141 }
50142 arg3 = static_cast< int >(val3);
50143 ecode4 = SWIG_AsVal_int(obj3, &val4);
50144 if (!SWIG_IsOK(ecode4)) {
50145 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
50146 }
50147 arg4 = static_cast< int >(val4);
50148 if (obj4) {
50149 arg5 = obj4;
50150 }
50151 {
50152 PyThreadState* __tstate = wxPyBeginAllowThreads();
50153 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50154 wxPyEndAllowThreads(__tstate);
50155 if (PyErr_Occurred()) SWIG_fail;
50156 }
50157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50158 return resultobj;
50159 fail:
50160 return NULL;
50161 }
50162
50163
50164 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50165 PyObject *resultobj = 0;
50166 int arg1 ;
50167 int arg2 ;
50168 int arg3 ;
50169 int arg4 ;
50170 int arg5 ;
50171 PyObject *arg6 = (PyObject *) NULL ;
50172 wxSizerItem *result = 0 ;
50173 int val1 ;
50174 int ecode1 = 0 ;
50175 int val2 ;
50176 int ecode2 = 0 ;
50177 int val3 ;
50178 int ecode3 = 0 ;
50179 int val4 ;
50180 int ecode4 = 0 ;
50181 int val5 ;
50182 int ecode5 = 0 ;
50183 PyObject * obj0 = 0 ;
50184 PyObject * obj1 = 0 ;
50185 PyObject * obj2 = 0 ;
50186 PyObject * obj3 = 0 ;
50187 PyObject * obj4 = 0 ;
50188 PyObject * obj5 = 0 ;
50189 char * kwnames[] = {
50190 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50191 };
50192
50193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50194 ecode1 = SWIG_AsVal_int(obj0, &val1);
50195 if (!SWIG_IsOK(ecode1)) {
50196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
50197 }
50198 arg1 = static_cast< int >(val1);
50199 ecode2 = SWIG_AsVal_int(obj1, &val2);
50200 if (!SWIG_IsOK(ecode2)) {
50201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
50202 }
50203 arg2 = static_cast< int >(val2);
50204 ecode3 = SWIG_AsVal_int(obj2, &val3);
50205 if (!SWIG_IsOK(ecode3)) {
50206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
50207 }
50208 arg3 = static_cast< int >(val3);
50209 ecode4 = SWIG_AsVal_int(obj3, &val4);
50210 if (!SWIG_IsOK(ecode4)) {
50211 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
50212 }
50213 arg4 = static_cast< int >(val4);
50214 ecode5 = SWIG_AsVal_int(obj4, &val5);
50215 if (!SWIG_IsOK(ecode5)) {
50216 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
50217 }
50218 arg5 = static_cast< int >(val5);
50219 if (obj5) {
50220 arg6 = obj5;
50221 }
50222 {
50223 PyThreadState* __tstate = wxPyBeginAllowThreads();
50224 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
50225 wxPyEndAllowThreads(__tstate);
50226 if (PyErr_Occurred()) SWIG_fail;
50227 }
50228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50229 return resultobj;
50230 fail:
50231 return NULL;
50232 }
50233
50234
50235 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50236 PyObject *resultobj = 0;
50237 wxSizer *arg1 = (wxSizer *) 0 ;
50238 int arg2 ;
50239 int arg3 ;
50240 int arg4 ;
50241 PyObject *arg5 = (PyObject *) NULL ;
50242 wxSizerItem *result = 0 ;
50243 int res1 = 0 ;
50244 int val2 ;
50245 int ecode2 = 0 ;
50246 int val3 ;
50247 int ecode3 = 0 ;
50248 int val4 ;
50249 int ecode4 = 0 ;
50250 PyObject * obj0 = 0 ;
50251 PyObject * obj1 = 0 ;
50252 PyObject * obj2 = 0 ;
50253 PyObject * obj3 = 0 ;
50254 PyObject * obj4 = 0 ;
50255 char * kwnames[] = {
50256 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50257 };
50258
50259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50260 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
50261 if (!SWIG_IsOK(res1)) {
50262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50263 }
50264 ecode2 = SWIG_AsVal_int(obj1, &val2);
50265 if (!SWIG_IsOK(ecode2)) {
50266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
50267 }
50268 arg2 = static_cast< int >(val2);
50269 ecode3 = SWIG_AsVal_int(obj2, &val3);
50270 if (!SWIG_IsOK(ecode3)) {
50271 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
50272 }
50273 arg3 = static_cast< int >(val3);
50274 ecode4 = SWIG_AsVal_int(obj3, &val4);
50275 if (!SWIG_IsOK(ecode4)) {
50276 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
50277 }
50278 arg4 = static_cast< int >(val4);
50279 if (obj4) {
50280 arg5 = obj4;
50281 }
50282 {
50283 PyThreadState* __tstate = wxPyBeginAllowThreads();
50284 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
50285 wxPyEndAllowThreads(__tstate);
50286 if (PyErr_Occurred()) SWIG_fail;
50287 }
50288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
50289 return resultobj;
50290 fail:
50291 return NULL;
50292 }
50293
50294
50295 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50296 PyObject *resultobj = 0;
50297 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50298 void *argp1 = 0 ;
50299 int res1 = 0 ;
50300 PyObject *swig_obj[1] ;
50301
50302 if (!args) SWIG_fail;
50303 swig_obj[0] = args;
50304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50305 if (!SWIG_IsOK(res1)) {
50306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50307 }
50308 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50309 {
50310 PyThreadState* __tstate = wxPyBeginAllowThreads();
50311 (arg1)->DeleteWindows();
50312 wxPyEndAllowThreads(__tstate);
50313 if (PyErr_Occurred()) SWIG_fail;
50314 }
50315 resultobj = SWIG_Py_Void();
50316 return resultobj;
50317 fail:
50318 return NULL;
50319 }
50320
50321
50322 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50323 PyObject *resultobj = 0;
50324 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50325 void *argp1 = 0 ;
50326 int res1 = 0 ;
50327 PyObject *swig_obj[1] ;
50328
50329 if (!args) SWIG_fail;
50330 swig_obj[0] = args;
50331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50332 if (!SWIG_IsOK(res1)) {
50333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50334 }
50335 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50336 {
50337 PyThreadState* __tstate = wxPyBeginAllowThreads();
50338 (arg1)->DetachSizer();
50339 wxPyEndAllowThreads(__tstate);
50340 if (PyErr_Occurred()) SWIG_fail;
50341 }
50342 resultobj = SWIG_Py_Void();
50343 return resultobj;
50344 fail:
50345 return NULL;
50346 }
50347
50348
50349 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50350 PyObject *resultobj = 0;
50351 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50352 wxSize result;
50353 void *argp1 = 0 ;
50354 int res1 = 0 ;
50355 PyObject *swig_obj[1] ;
50356
50357 if (!args) SWIG_fail;
50358 swig_obj[0] = args;
50359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50360 if (!SWIG_IsOK(res1)) {
50361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50362 }
50363 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50364 {
50365 PyThreadState* __tstate = wxPyBeginAllowThreads();
50366 result = (arg1)->GetSize();
50367 wxPyEndAllowThreads(__tstate);
50368 if (PyErr_Occurred()) SWIG_fail;
50369 }
50370 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50371 return resultobj;
50372 fail:
50373 return NULL;
50374 }
50375
50376
50377 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50378 PyObject *resultobj = 0;
50379 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50380 wxSize result;
50381 void *argp1 = 0 ;
50382 int res1 = 0 ;
50383 PyObject *swig_obj[1] ;
50384
50385 if (!args) SWIG_fail;
50386 swig_obj[0] = args;
50387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50388 if (!SWIG_IsOK(res1)) {
50389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50390 }
50391 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50392 {
50393 PyThreadState* __tstate = wxPyBeginAllowThreads();
50394 result = (arg1)->CalcMin();
50395 wxPyEndAllowThreads(__tstate);
50396 if (PyErr_Occurred()) SWIG_fail;
50397 }
50398 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50399 return resultobj;
50400 fail:
50401 return NULL;
50402 }
50403
50404
50405 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50406 PyObject *resultobj = 0;
50407 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50408 wxPoint *arg2 = 0 ;
50409 wxSize *arg3 = 0 ;
50410 void *argp1 = 0 ;
50411 int res1 = 0 ;
50412 wxPoint temp2 ;
50413 wxSize temp3 ;
50414 PyObject * obj0 = 0 ;
50415 PyObject * obj1 = 0 ;
50416 PyObject * obj2 = 0 ;
50417 char * kwnames[] = {
50418 (char *) "self",(char *) "pos",(char *) "size", NULL
50419 };
50420
50421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50423 if (!SWIG_IsOK(res1)) {
50424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50425 }
50426 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50427 {
50428 arg2 = &temp2;
50429 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50430 }
50431 {
50432 arg3 = &temp3;
50433 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50434 }
50435 {
50436 PyThreadState* __tstate = wxPyBeginAllowThreads();
50437 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
50438 wxPyEndAllowThreads(__tstate);
50439 if (PyErr_Occurred()) SWIG_fail;
50440 }
50441 resultobj = SWIG_Py_Void();
50442 return resultobj;
50443 fail:
50444 return NULL;
50445 }
50446
50447
50448 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50449 PyObject *resultobj = 0;
50450 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50451 wxSize result;
50452 void *argp1 = 0 ;
50453 int res1 = 0 ;
50454 PyObject *swig_obj[1] ;
50455
50456 if (!args) SWIG_fail;
50457 swig_obj[0] = args;
50458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50459 if (!SWIG_IsOK(res1)) {
50460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50461 }
50462 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50463 {
50464 PyThreadState* __tstate = wxPyBeginAllowThreads();
50465 result = (arg1)->GetMinSize();
50466 wxPyEndAllowThreads(__tstate);
50467 if (PyErr_Occurred()) SWIG_fail;
50468 }
50469 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50470 return resultobj;
50471 fail:
50472 return NULL;
50473 }
50474
50475
50476 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50477 PyObject *resultobj = 0;
50478 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50479 wxSize result;
50480 void *argp1 = 0 ;
50481 int res1 = 0 ;
50482 PyObject *swig_obj[1] ;
50483
50484 if (!args) SWIG_fail;
50485 swig_obj[0] = args;
50486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50487 if (!SWIG_IsOK(res1)) {
50488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
50489 }
50490 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50491 {
50492 PyThreadState* __tstate = wxPyBeginAllowThreads();
50493 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
50494 wxPyEndAllowThreads(__tstate);
50495 if (PyErr_Occurred()) SWIG_fail;
50496 }
50497 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50498 return resultobj;
50499 fail:
50500 return NULL;
50501 }
50502
50503
50504 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50505 PyObject *resultobj = 0;
50506 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50507 int arg2 ;
50508 int arg3 ;
50509 void *argp1 = 0 ;
50510 int res1 = 0 ;
50511 int val2 ;
50512 int ecode2 = 0 ;
50513 int val3 ;
50514 int ecode3 = 0 ;
50515 PyObject * obj0 = 0 ;
50516 PyObject * obj1 = 0 ;
50517 PyObject * obj2 = 0 ;
50518 char * kwnames[] = {
50519 (char *) "self",(char *) "x",(char *) "y", NULL
50520 };
50521
50522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50524 if (!SWIG_IsOK(res1)) {
50525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50526 }
50527 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50528 ecode2 = SWIG_AsVal_int(obj1, &val2);
50529 if (!SWIG_IsOK(ecode2)) {
50530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
50531 }
50532 arg2 = static_cast< int >(val2);
50533 ecode3 = SWIG_AsVal_int(obj2, &val3);
50534 if (!SWIG_IsOK(ecode3)) {
50535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
50536 }
50537 arg3 = static_cast< int >(val3);
50538 {
50539 PyThreadState* __tstate = wxPyBeginAllowThreads();
50540 (arg1)->SetInitSize(arg2,arg3);
50541 wxPyEndAllowThreads(__tstate);
50542 if (PyErr_Occurred()) SWIG_fail;
50543 }
50544 resultobj = SWIG_Py_Void();
50545 return resultobj;
50546 fail:
50547 return NULL;
50548 }
50549
50550
50551 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50552 PyObject *resultobj = 0;
50553 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50554 int arg2 ;
50555 int arg3 ;
50556 void *argp1 = 0 ;
50557 int res1 = 0 ;
50558 int val2 ;
50559 int ecode2 = 0 ;
50560 int val3 ;
50561 int ecode3 = 0 ;
50562 PyObject * obj0 = 0 ;
50563 PyObject * obj1 = 0 ;
50564 PyObject * obj2 = 0 ;
50565 char * kwnames[] = {
50566 (char *) "self",(char *) "width",(char *) "height", NULL
50567 };
50568
50569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50571 if (!SWIG_IsOK(res1)) {
50572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50573 }
50574 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50575 ecode2 = SWIG_AsVal_int(obj1, &val2);
50576 if (!SWIG_IsOK(ecode2)) {
50577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
50578 }
50579 arg2 = static_cast< int >(val2);
50580 ecode3 = SWIG_AsVal_int(obj2, &val3);
50581 if (!SWIG_IsOK(ecode3)) {
50582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
50583 }
50584 arg3 = static_cast< int >(val3);
50585 {
50586 PyThreadState* __tstate = wxPyBeginAllowThreads();
50587 (arg1)->SetRatio(arg2,arg3);
50588 wxPyEndAllowThreads(__tstate);
50589 if (PyErr_Occurred()) SWIG_fail;
50590 }
50591 resultobj = SWIG_Py_Void();
50592 return resultobj;
50593 fail:
50594 return NULL;
50595 }
50596
50597
50598 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50599 PyObject *resultobj = 0;
50600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50601 wxSize *arg2 = 0 ;
50602 void *argp1 = 0 ;
50603 int res1 = 0 ;
50604 wxSize temp2 ;
50605 PyObject * obj0 = 0 ;
50606 PyObject * obj1 = 0 ;
50607 char * kwnames[] = {
50608 (char *) "self",(char *) "size", NULL
50609 };
50610
50611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
50612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50613 if (!SWIG_IsOK(res1)) {
50614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50615 }
50616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50617 {
50618 arg2 = &temp2;
50619 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50620 }
50621 {
50622 PyThreadState* __tstate = wxPyBeginAllowThreads();
50623 (arg1)->SetRatio((wxSize const &)*arg2);
50624 wxPyEndAllowThreads(__tstate);
50625 if (PyErr_Occurred()) SWIG_fail;
50626 }
50627 resultobj = SWIG_Py_Void();
50628 return resultobj;
50629 fail:
50630 return NULL;
50631 }
50632
50633
50634 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50635 PyObject *resultobj = 0;
50636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50637 float arg2 ;
50638 void *argp1 = 0 ;
50639 int res1 = 0 ;
50640 float val2 ;
50641 int ecode2 = 0 ;
50642 PyObject * obj0 = 0 ;
50643 PyObject * obj1 = 0 ;
50644 char * kwnames[] = {
50645 (char *) "self",(char *) "ratio", NULL
50646 };
50647
50648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
50649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50650 if (!SWIG_IsOK(res1)) {
50651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50652 }
50653 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50654 ecode2 = SWIG_AsVal_float(obj1, &val2);
50655 if (!SWIG_IsOK(ecode2)) {
50656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
50657 }
50658 arg2 = static_cast< float >(val2);
50659 {
50660 PyThreadState* __tstate = wxPyBeginAllowThreads();
50661 (arg1)->SetRatio(arg2);
50662 wxPyEndAllowThreads(__tstate);
50663 if (PyErr_Occurred()) SWIG_fail;
50664 }
50665 resultobj = SWIG_Py_Void();
50666 return resultobj;
50667 fail:
50668 return NULL;
50669 }
50670
50671
50672 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50673 PyObject *resultobj = 0;
50674 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50675 float result;
50676 void *argp1 = 0 ;
50677 int res1 = 0 ;
50678 PyObject *swig_obj[1] ;
50679
50680 if (!args) SWIG_fail;
50681 swig_obj[0] = args;
50682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50683 if (!SWIG_IsOK(res1)) {
50684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50685 }
50686 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50687 {
50688 PyThreadState* __tstate = wxPyBeginAllowThreads();
50689 result = (float)(arg1)->GetRatio();
50690 wxPyEndAllowThreads(__tstate);
50691 if (PyErr_Occurred()) SWIG_fail;
50692 }
50693 resultobj = SWIG_From_float(static_cast< float >(result));
50694 return resultobj;
50695 fail:
50696 return NULL;
50697 }
50698
50699
50700 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50701 PyObject *resultobj = 0;
50702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50703 wxRect result;
50704 void *argp1 = 0 ;
50705 int res1 = 0 ;
50706 PyObject *swig_obj[1] ;
50707
50708 if (!args) SWIG_fail;
50709 swig_obj[0] = args;
50710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50711 if (!SWIG_IsOK(res1)) {
50712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50713 }
50714 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50715 {
50716 PyThreadState* __tstate = wxPyBeginAllowThreads();
50717 result = (arg1)->GetRect();
50718 wxPyEndAllowThreads(__tstate);
50719 if (PyErr_Occurred()) SWIG_fail;
50720 }
50721 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
50722 return resultobj;
50723 fail:
50724 return NULL;
50725 }
50726
50727
50728 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50729 PyObject *resultobj = 0;
50730 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50731 bool result;
50732 void *argp1 = 0 ;
50733 int res1 = 0 ;
50734 PyObject *swig_obj[1] ;
50735
50736 if (!args) SWIG_fail;
50737 swig_obj[0] = args;
50738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50739 if (!SWIG_IsOK(res1)) {
50740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50741 }
50742 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50743 {
50744 PyThreadState* __tstate = wxPyBeginAllowThreads();
50745 result = (bool)(arg1)->IsWindow();
50746 wxPyEndAllowThreads(__tstate);
50747 if (PyErr_Occurred()) SWIG_fail;
50748 }
50749 {
50750 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50751 }
50752 return resultobj;
50753 fail:
50754 return NULL;
50755 }
50756
50757
50758 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50759 PyObject *resultobj = 0;
50760 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50761 bool result;
50762 void *argp1 = 0 ;
50763 int res1 = 0 ;
50764 PyObject *swig_obj[1] ;
50765
50766 if (!args) SWIG_fail;
50767 swig_obj[0] = args;
50768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50769 if (!SWIG_IsOK(res1)) {
50770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50771 }
50772 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50773 {
50774 PyThreadState* __tstate = wxPyBeginAllowThreads();
50775 result = (bool)(arg1)->IsSizer();
50776 wxPyEndAllowThreads(__tstate);
50777 if (PyErr_Occurred()) SWIG_fail;
50778 }
50779 {
50780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50781 }
50782 return resultobj;
50783 fail:
50784 return NULL;
50785 }
50786
50787
50788 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50789 PyObject *resultobj = 0;
50790 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50791 bool result;
50792 void *argp1 = 0 ;
50793 int res1 = 0 ;
50794 PyObject *swig_obj[1] ;
50795
50796 if (!args) SWIG_fail;
50797 swig_obj[0] = args;
50798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50799 if (!SWIG_IsOK(res1)) {
50800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50801 }
50802 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50803 {
50804 PyThreadState* __tstate = wxPyBeginAllowThreads();
50805 result = (bool)(arg1)->IsSpacer();
50806 wxPyEndAllowThreads(__tstate);
50807 if (PyErr_Occurred()) SWIG_fail;
50808 }
50809 {
50810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50811 }
50812 return resultobj;
50813 fail:
50814 return NULL;
50815 }
50816
50817
50818 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50819 PyObject *resultobj = 0;
50820 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50821 int arg2 ;
50822 void *argp1 = 0 ;
50823 int res1 = 0 ;
50824 int val2 ;
50825 int ecode2 = 0 ;
50826 PyObject * obj0 = 0 ;
50827 PyObject * obj1 = 0 ;
50828 char * kwnames[] = {
50829 (char *) "self",(char *) "proportion", NULL
50830 };
50831
50832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
50833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50834 if (!SWIG_IsOK(res1)) {
50835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50836 }
50837 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50838 ecode2 = SWIG_AsVal_int(obj1, &val2);
50839 if (!SWIG_IsOK(ecode2)) {
50840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
50841 }
50842 arg2 = static_cast< int >(val2);
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 (arg1)->SetProportion(arg2);
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 resultobj = SWIG_Py_Void();
50850 return resultobj;
50851 fail:
50852 return NULL;
50853 }
50854
50855
50856 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50857 PyObject *resultobj = 0;
50858 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50859 int result;
50860 void *argp1 = 0 ;
50861 int res1 = 0 ;
50862 PyObject *swig_obj[1] ;
50863
50864 if (!args) SWIG_fail;
50865 swig_obj[0] = args;
50866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50867 if (!SWIG_IsOK(res1)) {
50868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50869 }
50870 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50871 {
50872 PyThreadState* __tstate = wxPyBeginAllowThreads();
50873 result = (int)(arg1)->GetProportion();
50874 wxPyEndAllowThreads(__tstate);
50875 if (PyErr_Occurred()) SWIG_fail;
50876 }
50877 resultobj = SWIG_From_int(static_cast< int >(result));
50878 return resultobj;
50879 fail:
50880 return NULL;
50881 }
50882
50883
50884 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50885 PyObject *resultobj = 0;
50886 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50887 int arg2 ;
50888 void *argp1 = 0 ;
50889 int res1 = 0 ;
50890 int val2 ;
50891 int ecode2 = 0 ;
50892 PyObject * obj0 = 0 ;
50893 PyObject * obj1 = 0 ;
50894 char * kwnames[] = {
50895 (char *) "self",(char *) "flag", NULL
50896 };
50897
50898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
50899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50900 if (!SWIG_IsOK(res1)) {
50901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50902 }
50903 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50904 ecode2 = SWIG_AsVal_int(obj1, &val2);
50905 if (!SWIG_IsOK(ecode2)) {
50906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
50907 }
50908 arg2 = static_cast< int >(val2);
50909 {
50910 PyThreadState* __tstate = wxPyBeginAllowThreads();
50911 (arg1)->SetFlag(arg2);
50912 wxPyEndAllowThreads(__tstate);
50913 if (PyErr_Occurred()) SWIG_fail;
50914 }
50915 resultobj = SWIG_Py_Void();
50916 return resultobj;
50917 fail:
50918 return NULL;
50919 }
50920
50921
50922 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50923 PyObject *resultobj = 0;
50924 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50925 int result;
50926 void *argp1 = 0 ;
50927 int res1 = 0 ;
50928 PyObject *swig_obj[1] ;
50929
50930 if (!args) SWIG_fail;
50931 swig_obj[0] = args;
50932 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50935 }
50936 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50937 {
50938 PyThreadState* __tstate = wxPyBeginAllowThreads();
50939 result = (int)(arg1)->GetFlag();
50940 wxPyEndAllowThreads(__tstate);
50941 if (PyErr_Occurred()) SWIG_fail;
50942 }
50943 resultobj = SWIG_From_int(static_cast< int >(result));
50944 return resultobj;
50945 fail:
50946 return NULL;
50947 }
50948
50949
50950 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50951 PyObject *resultobj = 0;
50952 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50953 int arg2 ;
50954 void *argp1 = 0 ;
50955 int res1 = 0 ;
50956 int val2 ;
50957 int ecode2 = 0 ;
50958 PyObject * obj0 = 0 ;
50959 PyObject * obj1 = 0 ;
50960 char * kwnames[] = {
50961 (char *) "self",(char *) "border", NULL
50962 };
50963
50964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
50965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50966 if (!SWIG_IsOK(res1)) {
50967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
50968 }
50969 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
50970 ecode2 = SWIG_AsVal_int(obj1, &val2);
50971 if (!SWIG_IsOK(ecode2)) {
50972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
50973 }
50974 arg2 = static_cast< int >(val2);
50975 {
50976 PyThreadState* __tstate = wxPyBeginAllowThreads();
50977 (arg1)->SetBorder(arg2);
50978 wxPyEndAllowThreads(__tstate);
50979 if (PyErr_Occurred()) SWIG_fail;
50980 }
50981 resultobj = SWIG_Py_Void();
50982 return resultobj;
50983 fail:
50984 return NULL;
50985 }
50986
50987
50988 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50989 PyObject *resultobj = 0;
50990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
50991 int result;
50992 void *argp1 = 0 ;
50993 int res1 = 0 ;
50994 PyObject *swig_obj[1] ;
50995
50996 if (!args) SWIG_fail;
50997 swig_obj[0] = args;
50998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50999 if (!SWIG_IsOK(res1)) {
51000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51001 }
51002 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51003 {
51004 PyThreadState* __tstate = wxPyBeginAllowThreads();
51005 result = (int)(arg1)->GetBorder();
51006 wxPyEndAllowThreads(__tstate);
51007 if (PyErr_Occurred()) SWIG_fail;
51008 }
51009 resultobj = SWIG_From_int(static_cast< int >(result));
51010 return resultobj;
51011 fail:
51012 return NULL;
51013 }
51014
51015
51016 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51017 PyObject *resultobj = 0;
51018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51019 wxWindow *result = 0 ;
51020 void *argp1 = 0 ;
51021 int res1 = 0 ;
51022 PyObject *swig_obj[1] ;
51023
51024 if (!args) SWIG_fail;
51025 swig_obj[0] = args;
51026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51027 if (!SWIG_IsOK(res1)) {
51028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51029 }
51030 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51031 {
51032 PyThreadState* __tstate = wxPyBeginAllowThreads();
51033 result = (wxWindow *)(arg1)->GetWindow();
51034 wxPyEndAllowThreads(__tstate);
51035 if (PyErr_Occurred()) SWIG_fail;
51036 }
51037 {
51038 resultobj = wxPyMake_wxObject(result, 0);
51039 }
51040 return resultobj;
51041 fail:
51042 return NULL;
51043 }
51044
51045
51046 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51047 PyObject *resultobj = 0;
51048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51049 wxSizer *result = 0 ;
51050 void *argp1 = 0 ;
51051 int res1 = 0 ;
51052 PyObject *swig_obj[1] ;
51053
51054 if (!args) SWIG_fail;
51055 swig_obj[0] = args;
51056 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51057 if (!SWIG_IsOK(res1)) {
51058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51059 }
51060 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51061 {
51062 PyThreadState* __tstate = wxPyBeginAllowThreads();
51063 result = (wxSizer *)(arg1)->GetSizer();
51064 wxPyEndAllowThreads(__tstate);
51065 if (PyErr_Occurred()) SWIG_fail;
51066 }
51067 {
51068 resultobj = wxPyMake_wxObject(result, (bool)0);
51069 }
51070 return resultobj;
51071 fail:
51072 return NULL;
51073 }
51074
51075
51076 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51077 PyObject *resultobj = 0;
51078 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51079 wxSize result;
51080 void *argp1 = 0 ;
51081 int res1 = 0 ;
51082 PyObject *swig_obj[1] ;
51083
51084 if (!args) SWIG_fail;
51085 swig_obj[0] = args;
51086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51087 if (!SWIG_IsOK(res1)) {
51088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51089 }
51090 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51091 {
51092 PyThreadState* __tstate = wxPyBeginAllowThreads();
51093 result = (arg1)->GetSpacer();
51094 wxPyEndAllowThreads(__tstate);
51095 if (PyErr_Occurred()) SWIG_fail;
51096 }
51097 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
51098 return resultobj;
51099 fail:
51100 return NULL;
51101 }
51102
51103
51104 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51105 PyObject *resultobj = 0;
51106 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51107 wxWindow *arg2 = (wxWindow *) 0 ;
51108 void *argp1 = 0 ;
51109 int res1 = 0 ;
51110 void *argp2 = 0 ;
51111 int res2 = 0 ;
51112 PyObject * obj0 = 0 ;
51113 PyObject * obj1 = 0 ;
51114 char * kwnames[] = {
51115 (char *) "self",(char *) "window", NULL
51116 };
51117
51118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51120 if (!SWIG_IsOK(res1)) {
51121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51122 }
51123 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51124 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51125 if (!SWIG_IsOK(res2)) {
51126 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51127 }
51128 arg2 = reinterpret_cast< wxWindow * >(argp2);
51129 {
51130 PyThreadState* __tstate = wxPyBeginAllowThreads();
51131 (arg1)->SetWindow(arg2);
51132 wxPyEndAllowThreads(__tstate);
51133 if (PyErr_Occurred()) SWIG_fail;
51134 }
51135 resultobj = SWIG_Py_Void();
51136 return resultobj;
51137 fail:
51138 return NULL;
51139 }
51140
51141
51142 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51143 PyObject *resultobj = 0;
51144 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51145 wxSizer *arg2 = (wxSizer *) 0 ;
51146 void *argp1 = 0 ;
51147 int res1 = 0 ;
51148 int res2 = 0 ;
51149 PyObject * obj0 = 0 ;
51150 PyObject * obj1 = 0 ;
51151 char * kwnames[] = {
51152 (char *) "self",(char *) "sizer", NULL
51153 };
51154
51155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51157 if (!SWIG_IsOK(res1)) {
51158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51159 }
51160 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51161 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51162 if (!SWIG_IsOK(res2)) {
51163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51164 }
51165 {
51166 PyThreadState* __tstate = wxPyBeginAllowThreads();
51167 (arg1)->SetSizer(arg2);
51168 wxPyEndAllowThreads(__tstate);
51169 if (PyErr_Occurred()) SWIG_fail;
51170 }
51171 resultobj = SWIG_Py_Void();
51172 return resultobj;
51173 fail:
51174 return NULL;
51175 }
51176
51177
51178 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51179 PyObject *resultobj = 0;
51180 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51181 wxSize *arg2 = 0 ;
51182 void *argp1 = 0 ;
51183 int res1 = 0 ;
51184 wxSize temp2 ;
51185 PyObject * obj0 = 0 ;
51186 PyObject * obj1 = 0 ;
51187 char * kwnames[] = {
51188 (char *) "self",(char *) "size", NULL
51189 };
51190
51191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51193 if (!SWIG_IsOK(res1)) {
51194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51195 }
51196 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51197 {
51198 arg2 = &temp2;
51199 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51200 }
51201 {
51202 PyThreadState* __tstate = wxPyBeginAllowThreads();
51203 (arg1)->SetSpacer((wxSize const &)*arg2);
51204 wxPyEndAllowThreads(__tstate);
51205 if (PyErr_Occurred()) SWIG_fail;
51206 }
51207 resultobj = SWIG_Py_Void();
51208 return resultobj;
51209 fail:
51210 return NULL;
51211 }
51212
51213
51214 SWIGINTERN PyObject *_wrap_SizerItem_AssignWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51215 PyObject *resultobj = 0;
51216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51217 wxWindow *arg2 = (wxWindow *) 0 ;
51218 void *argp1 = 0 ;
51219 int res1 = 0 ;
51220 void *argp2 = 0 ;
51221 int res2 = 0 ;
51222 PyObject * obj0 = 0 ;
51223 PyObject * obj1 = 0 ;
51224 char * kwnames[] = {
51225 (char *) "self",(char *) "window", NULL
51226 };
51227
51228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignWindow",kwnames,&obj0,&obj1)) SWIG_fail;
51229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51230 if (!SWIG_IsOK(res1)) {
51231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51232 }
51233 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51235 if (!SWIG_IsOK(res2)) {
51236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
51237 }
51238 arg2 = reinterpret_cast< wxWindow * >(argp2);
51239 {
51240 PyThreadState* __tstate = wxPyBeginAllowThreads();
51241 (arg1)->AssignWindow(arg2);
51242 wxPyEndAllowThreads(__tstate);
51243 if (PyErr_Occurred()) SWIG_fail;
51244 }
51245 resultobj = SWIG_Py_Void();
51246 return resultobj;
51247 fail:
51248 return NULL;
51249 }
51250
51251
51252 SWIGINTERN PyObject *_wrap_SizerItem_AssignSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51253 PyObject *resultobj = 0;
51254 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51255 wxSizer *arg2 = (wxSizer *) 0 ;
51256 void *argp1 = 0 ;
51257 int res1 = 0 ;
51258 void *argp2 = 0 ;
51259 int res2 = 0 ;
51260 PyObject * obj0 = 0 ;
51261 PyObject * obj1 = 0 ;
51262 char * kwnames[] = {
51263 (char *) "self",(char *) "sizer", NULL
51264 };
51265
51266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51268 if (!SWIG_IsOK(res1)) {
51269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51270 }
51271 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51273 if (!SWIG_IsOK(res2)) {
51274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_AssignSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
51275 }
51276 arg2 = reinterpret_cast< wxSizer * >(argp2);
51277 {
51278 PyThreadState* __tstate = wxPyBeginAllowThreads();
51279 (arg1)->AssignSizer(arg2);
51280 wxPyEndAllowThreads(__tstate);
51281 if (PyErr_Occurred()) SWIG_fail;
51282 }
51283 resultobj = SWIG_Py_Void();
51284 return resultobj;
51285 fail:
51286 return NULL;
51287 }
51288
51289
51290 SWIGINTERN PyObject *_wrap_SizerItem_AssignSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51291 PyObject *resultobj = 0;
51292 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51293 wxSize *arg2 = 0 ;
51294 void *argp1 = 0 ;
51295 int res1 = 0 ;
51296 wxSize temp2 ;
51297 PyObject * obj0 = 0 ;
51298 PyObject * obj1 = 0 ;
51299 char * kwnames[] = {
51300 (char *) "self",(char *) "size", NULL
51301 };
51302
51303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_AssignSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
51304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51305 if (!SWIG_IsOK(res1)) {
51306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_AssignSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51307 }
51308 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51309 {
51310 arg2 = &temp2;
51311 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
51312 }
51313 {
51314 PyThreadState* __tstate = wxPyBeginAllowThreads();
51315 (arg1)->AssignSpacer((wxSize const &)*arg2);
51316 wxPyEndAllowThreads(__tstate);
51317 if (PyErr_Occurred()) SWIG_fail;
51318 }
51319 resultobj = SWIG_Py_Void();
51320 return resultobj;
51321 fail:
51322 return NULL;
51323 }
51324
51325
51326 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51327 PyObject *resultobj = 0;
51328 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51329 bool arg2 ;
51330 void *argp1 = 0 ;
51331 int res1 = 0 ;
51332 bool val2 ;
51333 int ecode2 = 0 ;
51334 PyObject * obj0 = 0 ;
51335 PyObject * obj1 = 0 ;
51336 char * kwnames[] = {
51337 (char *) "self",(char *) "show", NULL
51338 };
51339
51340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
51341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51342 if (!SWIG_IsOK(res1)) {
51343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51344 }
51345 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51346 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51347 if (!SWIG_IsOK(ecode2)) {
51348 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
51349 }
51350 arg2 = static_cast< bool >(val2);
51351 {
51352 PyThreadState* __tstate = wxPyBeginAllowThreads();
51353 (arg1)->Show(arg2);
51354 wxPyEndAllowThreads(__tstate);
51355 if (PyErr_Occurred()) SWIG_fail;
51356 }
51357 resultobj = SWIG_Py_Void();
51358 return resultobj;
51359 fail:
51360 return NULL;
51361 }
51362
51363
51364 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51365 PyObject *resultobj = 0;
51366 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51367 bool result;
51368 void *argp1 = 0 ;
51369 int res1 = 0 ;
51370 PyObject *swig_obj[1] ;
51371
51372 if (!args) SWIG_fail;
51373 swig_obj[0] = args;
51374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51375 if (!SWIG_IsOK(res1)) {
51376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51377 }
51378 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51379 {
51380 PyThreadState* __tstate = wxPyBeginAllowThreads();
51381 result = (bool)(arg1)->IsShown();
51382 wxPyEndAllowThreads(__tstate);
51383 if (PyErr_Occurred()) SWIG_fail;
51384 }
51385 {
51386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51387 }
51388 return resultobj;
51389 fail:
51390 return NULL;
51391 }
51392
51393
51394 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51395 PyObject *resultobj = 0;
51396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51397 wxPoint result;
51398 void *argp1 = 0 ;
51399 int res1 = 0 ;
51400 PyObject *swig_obj[1] ;
51401
51402 if (!args) SWIG_fail;
51403 swig_obj[0] = args;
51404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51405 if (!SWIG_IsOK(res1)) {
51406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51407 }
51408 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51409 {
51410 PyThreadState* __tstate = wxPyBeginAllowThreads();
51411 result = (arg1)->GetPosition();
51412 wxPyEndAllowThreads(__tstate);
51413 if (PyErr_Occurred()) SWIG_fail;
51414 }
51415 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
51416 return resultobj;
51417 fail:
51418 return NULL;
51419 }
51420
51421
51422 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51423 PyObject *resultobj = 0;
51424 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51425 PyObject *result = 0 ;
51426 void *argp1 = 0 ;
51427 int res1 = 0 ;
51428 PyObject *swig_obj[1] ;
51429
51430 if (!args) SWIG_fail;
51431 swig_obj[0] = args;
51432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51433 if (!SWIG_IsOK(res1)) {
51434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51435 }
51436 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51437 {
51438 PyThreadState* __tstate = wxPyBeginAllowThreads();
51439 result = (PyObject *)wxSizerItem_GetUserData(arg1);
51440 wxPyEndAllowThreads(__tstate);
51441 if (PyErr_Occurred()) SWIG_fail;
51442 }
51443 resultobj = result;
51444 return resultobj;
51445 fail:
51446 return NULL;
51447 }
51448
51449
51450 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51451 PyObject *resultobj = 0;
51452 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
51453 PyObject *arg2 = (PyObject *) 0 ;
51454 void *argp1 = 0 ;
51455 int res1 = 0 ;
51456 PyObject * obj0 = 0 ;
51457 PyObject * obj1 = 0 ;
51458 char * kwnames[] = {
51459 (char *) "self",(char *) "userData", NULL
51460 };
51461
51462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
51463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
51464 if (!SWIG_IsOK(res1)) {
51465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
51466 }
51467 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
51468 arg2 = obj1;
51469 {
51470 PyThreadState* __tstate = wxPyBeginAllowThreads();
51471 wxSizerItem_SetUserData(arg1,arg2);
51472 wxPyEndAllowThreads(__tstate);
51473 if (PyErr_Occurred()) SWIG_fail;
51474 }
51475 resultobj = SWIG_Py_Void();
51476 return resultobj;
51477 fail:
51478 return NULL;
51479 }
51480
51481
51482 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51483 PyObject *obj;
51484 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51485 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
51486 return SWIG_Py_Void();
51487 }
51488
51489 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51490 return SWIG_Python_InitShadowInstance(args);
51491 }
51492
51493 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51494 PyObject *resultobj = 0;
51495 wxSizer *arg1 = (wxSizer *) 0 ;
51496 void *argp1 = 0 ;
51497 int res1 = 0 ;
51498 PyObject *swig_obj[1] ;
51499
51500 if (!args) SWIG_fail;
51501 swig_obj[0] = args;
51502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
51503 if (!SWIG_IsOK(res1)) {
51504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
51505 }
51506 arg1 = reinterpret_cast< wxSizer * >(argp1);
51507 {
51508 PyThreadState* __tstate = wxPyBeginAllowThreads();
51509 delete arg1;
51510
51511 wxPyEndAllowThreads(__tstate);
51512 if (PyErr_Occurred()) SWIG_fail;
51513 }
51514 resultobj = SWIG_Py_Void();
51515 return resultobj;
51516 fail:
51517 return NULL;
51518 }
51519
51520
51521 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51522 PyObject *resultobj = 0;
51523 wxSizer *arg1 = (wxSizer *) 0 ;
51524 PyObject *arg2 = (PyObject *) 0 ;
51525 void *argp1 = 0 ;
51526 int res1 = 0 ;
51527 PyObject * obj0 = 0 ;
51528 PyObject * obj1 = 0 ;
51529 char * kwnames[] = {
51530 (char *) "self",(char *) "_self", NULL
51531 };
51532
51533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
51534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51535 if (!SWIG_IsOK(res1)) {
51536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
51537 }
51538 arg1 = reinterpret_cast< wxSizer * >(argp1);
51539 arg2 = obj1;
51540 {
51541 PyThreadState* __tstate = wxPyBeginAllowThreads();
51542 wxSizer__setOORInfo(arg1,arg2);
51543 wxPyEndAllowThreads(__tstate);
51544 if (PyErr_Occurred()) SWIG_fail;
51545 }
51546 resultobj = SWIG_Py_Void();
51547 return resultobj;
51548 fail:
51549 return NULL;
51550 }
51551
51552
51553 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51554 PyObject *resultobj = 0;
51555 wxSizer *arg1 = (wxSizer *) 0 ;
51556 PyObject *arg2 = (PyObject *) 0 ;
51557 int arg3 = (int) 0 ;
51558 int arg4 = (int) 0 ;
51559 int arg5 = (int) 0 ;
51560 PyObject *arg6 = (PyObject *) NULL ;
51561 wxSizerItem *result = 0 ;
51562 void *argp1 = 0 ;
51563 int res1 = 0 ;
51564 int val3 ;
51565 int ecode3 = 0 ;
51566 int val4 ;
51567 int ecode4 = 0 ;
51568 int val5 ;
51569 int ecode5 = 0 ;
51570 PyObject * obj0 = 0 ;
51571 PyObject * obj1 = 0 ;
51572 PyObject * obj2 = 0 ;
51573 PyObject * obj3 = 0 ;
51574 PyObject * obj4 = 0 ;
51575 PyObject * obj5 = 0 ;
51576 char * kwnames[] = {
51577 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51578 };
51579
51580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51582 if (!SWIG_IsOK(res1)) {
51583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
51584 }
51585 arg1 = reinterpret_cast< wxSizer * >(argp1);
51586 arg2 = obj1;
51587 if (obj2) {
51588 ecode3 = SWIG_AsVal_int(obj2, &val3);
51589 if (!SWIG_IsOK(ecode3)) {
51590 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
51591 }
51592 arg3 = static_cast< int >(val3);
51593 }
51594 if (obj3) {
51595 ecode4 = SWIG_AsVal_int(obj3, &val4);
51596 if (!SWIG_IsOK(ecode4)) {
51597 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
51598 }
51599 arg4 = static_cast< int >(val4);
51600 }
51601 if (obj4) {
51602 ecode5 = SWIG_AsVal_int(obj4, &val5);
51603 if (!SWIG_IsOK(ecode5)) {
51604 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
51605 }
51606 arg5 = static_cast< int >(val5);
51607 }
51608 if (obj5) {
51609 arg6 = obj5;
51610 }
51611 {
51612 PyThreadState* __tstate = wxPyBeginAllowThreads();
51613 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
51614 wxPyEndAllowThreads(__tstate);
51615 if (PyErr_Occurred()) SWIG_fail;
51616 }
51617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51618 return resultobj;
51619 fail:
51620 return NULL;
51621 }
51622
51623
51624 SWIGINTERN PyObject *_wrap_Sizer_AddF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51625 PyObject *resultobj = 0;
51626 wxSizer *arg1 = (wxSizer *) 0 ;
51627 PyObject *arg2 = (PyObject *) 0 ;
51628 wxSizerFlags *arg3 = 0 ;
51629 wxSizerItem *result = 0 ;
51630 void *argp1 = 0 ;
51631 int res1 = 0 ;
51632 void *argp3 = 0 ;
51633 int res3 = 0 ;
51634 PyObject * obj0 = 0 ;
51635 PyObject * obj1 = 0 ;
51636 PyObject * obj2 = 0 ;
51637 char * kwnames[] = {
51638 (char *) "self",(char *) "item",(char *) "flags", NULL
51639 };
51640
51641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_AddF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51643 if (!SWIG_IsOK(res1)) {
51644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddF" "', expected argument " "1"" of type '" "wxSizer *""'");
51645 }
51646 arg1 = reinterpret_cast< wxSizer * >(argp1);
51647 arg2 = obj1;
51648 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51649 if (!SWIG_IsOK(res3)) {
51650 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51651 }
51652 if (!argp3) {
51653 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_AddF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51654 }
51655 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51656 {
51657 PyThreadState* __tstate = wxPyBeginAllowThreads();
51658 result = (wxSizerItem *)wxSizer_AddF(arg1,arg2,*arg3);
51659 wxPyEndAllowThreads(__tstate);
51660 if (PyErr_Occurred()) SWIG_fail;
51661 }
51662 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51663 return resultobj;
51664 fail:
51665 return NULL;
51666 }
51667
51668
51669 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51670 PyObject *resultobj = 0;
51671 wxSizer *arg1 = (wxSizer *) 0 ;
51672 int arg2 ;
51673 PyObject *arg3 = (PyObject *) 0 ;
51674 int arg4 = (int) 0 ;
51675 int arg5 = (int) 0 ;
51676 int arg6 = (int) 0 ;
51677 PyObject *arg7 = (PyObject *) NULL ;
51678 wxSizerItem *result = 0 ;
51679 void *argp1 = 0 ;
51680 int res1 = 0 ;
51681 int val2 ;
51682 int ecode2 = 0 ;
51683 int val4 ;
51684 int ecode4 = 0 ;
51685 int val5 ;
51686 int ecode5 = 0 ;
51687 int val6 ;
51688 int ecode6 = 0 ;
51689 PyObject * obj0 = 0 ;
51690 PyObject * obj1 = 0 ;
51691 PyObject * obj2 = 0 ;
51692 PyObject * obj3 = 0 ;
51693 PyObject * obj4 = 0 ;
51694 PyObject * obj5 = 0 ;
51695 PyObject * obj6 = 0 ;
51696 char * kwnames[] = {
51697 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51698 };
51699
51700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
51701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51702 if (!SWIG_IsOK(res1)) {
51703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
51704 }
51705 arg1 = reinterpret_cast< wxSizer * >(argp1);
51706 ecode2 = SWIG_AsVal_int(obj1, &val2);
51707 if (!SWIG_IsOK(ecode2)) {
51708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
51709 }
51710 arg2 = static_cast< int >(val2);
51711 arg3 = obj2;
51712 if (obj3) {
51713 ecode4 = SWIG_AsVal_int(obj3, &val4);
51714 if (!SWIG_IsOK(ecode4)) {
51715 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
51716 }
51717 arg4 = static_cast< int >(val4);
51718 }
51719 if (obj4) {
51720 ecode5 = SWIG_AsVal_int(obj4, &val5);
51721 if (!SWIG_IsOK(ecode5)) {
51722 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
51723 }
51724 arg5 = static_cast< int >(val5);
51725 }
51726 if (obj5) {
51727 ecode6 = SWIG_AsVal_int(obj5, &val6);
51728 if (!SWIG_IsOK(ecode6)) {
51729 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
51730 }
51731 arg6 = static_cast< int >(val6);
51732 }
51733 if (obj6) {
51734 arg7 = obj6;
51735 }
51736 {
51737 PyThreadState* __tstate = wxPyBeginAllowThreads();
51738 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
51739 wxPyEndAllowThreads(__tstate);
51740 if (PyErr_Occurred()) SWIG_fail;
51741 }
51742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51743 return resultobj;
51744 fail:
51745 return NULL;
51746 }
51747
51748
51749 SWIGINTERN PyObject *_wrap_Sizer_InsertF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51750 PyObject *resultobj = 0;
51751 wxSizer *arg1 = (wxSizer *) 0 ;
51752 int arg2 ;
51753 PyObject *arg3 = (PyObject *) 0 ;
51754 wxSizerFlags *arg4 = 0 ;
51755 wxSizerItem *result = 0 ;
51756 void *argp1 = 0 ;
51757 int res1 = 0 ;
51758 int val2 ;
51759 int ecode2 = 0 ;
51760 void *argp4 = 0 ;
51761 int res4 = 0 ;
51762 PyObject * obj0 = 0 ;
51763 PyObject * obj1 = 0 ;
51764 PyObject * obj2 = 0 ;
51765 PyObject * obj3 = 0 ;
51766 char * kwnames[] = {
51767 (char *) "self",(char *) "before",(char *) "item",(char *) "flags", NULL
51768 };
51769
51770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Sizer_InsertF",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51772 if (!SWIG_IsOK(res1)) {
51773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertF" "', expected argument " "1"" of type '" "wxSizer *""'");
51774 }
51775 arg1 = reinterpret_cast< wxSizer * >(argp1);
51776 ecode2 = SWIG_AsVal_int(obj1, &val2);
51777 if (!SWIG_IsOK(ecode2)) {
51778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertF" "', expected argument " "2"" of type '" "int""'");
51779 }
51780 arg2 = static_cast< int >(val2);
51781 arg3 = obj2;
51782 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxSizerFlags, 0 );
51783 if (!SWIG_IsOK(res4)) {
51784 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51785 }
51786 if (!argp4) {
51787 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_InsertF" "', expected argument " "4"" of type '" "wxSizerFlags &""'");
51788 }
51789 arg4 = reinterpret_cast< wxSizerFlags * >(argp4);
51790 {
51791 PyThreadState* __tstate = wxPyBeginAllowThreads();
51792 result = (wxSizerItem *)wxSizer_InsertF(arg1,arg2,arg3,*arg4);
51793 wxPyEndAllowThreads(__tstate);
51794 if (PyErr_Occurred()) SWIG_fail;
51795 }
51796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51797 return resultobj;
51798 fail:
51799 return NULL;
51800 }
51801
51802
51803 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51804 PyObject *resultobj = 0;
51805 wxSizer *arg1 = (wxSizer *) 0 ;
51806 PyObject *arg2 = (PyObject *) 0 ;
51807 int arg3 = (int) 0 ;
51808 int arg4 = (int) 0 ;
51809 int arg5 = (int) 0 ;
51810 PyObject *arg6 = (PyObject *) NULL ;
51811 wxSizerItem *result = 0 ;
51812 void *argp1 = 0 ;
51813 int res1 = 0 ;
51814 int val3 ;
51815 int ecode3 = 0 ;
51816 int val4 ;
51817 int ecode4 = 0 ;
51818 int val5 ;
51819 int ecode5 = 0 ;
51820 PyObject * obj0 = 0 ;
51821 PyObject * obj1 = 0 ;
51822 PyObject * obj2 = 0 ;
51823 PyObject * obj3 = 0 ;
51824 PyObject * obj4 = 0 ;
51825 PyObject * obj5 = 0 ;
51826 char * kwnames[] = {
51827 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
51828 };
51829
51830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51832 if (!SWIG_IsOK(res1)) {
51833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
51834 }
51835 arg1 = reinterpret_cast< wxSizer * >(argp1);
51836 arg2 = obj1;
51837 if (obj2) {
51838 ecode3 = SWIG_AsVal_int(obj2, &val3);
51839 if (!SWIG_IsOK(ecode3)) {
51840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
51841 }
51842 arg3 = static_cast< int >(val3);
51843 }
51844 if (obj3) {
51845 ecode4 = SWIG_AsVal_int(obj3, &val4);
51846 if (!SWIG_IsOK(ecode4)) {
51847 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
51848 }
51849 arg4 = static_cast< int >(val4);
51850 }
51851 if (obj4) {
51852 ecode5 = SWIG_AsVal_int(obj4, &val5);
51853 if (!SWIG_IsOK(ecode5)) {
51854 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
51855 }
51856 arg5 = static_cast< int >(val5);
51857 }
51858 if (obj5) {
51859 arg6 = obj5;
51860 }
51861 {
51862 PyThreadState* __tstate = wxPyBeginAllowThreads();
51863 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
51864 wxPyEndAllowThreads(__tstate);
51865 if (PyErr_Occurred()) SWIG_fail;
51866 }
51867 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51868 return resultobj;
51869 fail:
51870 return NULL;
51871 }
51872
51873
51874 SWIGINTERN PyObject *_wrap_Sizer_PrependF(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51875 PyObject *resultobj = 0;
51876 wxSizer *arg1 = (wxSizer *) 0 ;
51877 PyObject *arg2 = (PyObject *) 0 ;
51878 wxSizerFlags *arg3 = 0 ;
51879 wxSizerItem *result = 0 ;
51880 void *argp1 = 0 ;
51881 int res1 = 0 ;
51882 void *argp3 = 0 ;
51883 int res3 = 0 ;
51884 PyObject * obj0 = 0 ;
51885 PyObject * obj1 = 0 ;
51886 PyObject * obj2 = 0 ;
51887 char * kwnames[] = {
51888 (char *) "self",(char *) "item",(char *) "flags", NULL
51889 };
51890
51891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_PrependF",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51893 if (!SWIG_IsOK(res1)) {
51894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependF" "', expected argument " "1"" of type '" "wxSizer *""'");
51895 }
51896 arg1 = reinterpret_cast< wxSizer * >(argp1);
51897 arg2 = obj1;
51898 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxSizerFlags, 0 );
51899 if (!SWIG_IsOK(res3)) {
51900 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51901 }
51902 if (!argp3) {
51903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Sizer_PrependF" "', expected argument " "3"" of type '" "wxSizerFlags &""'");
51904 }
51905 arg3 = reinterpret_cast< wxSizerFlags * >(argp3);
51906 {
51907 PyThreadState* __tstate = wxPyBeginAllowThreads();
51908 result = (wxSizerItem *)wxSizer_PrependF(arg1,arg2,*arg3);
51909 wxPyEndAllowThreads(__tstate);
51910 if (PyErr_Occurred()) SWIG_fail;
51911 }
51912 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
51913 return resultobj;
51914 fail:
51915 return NULL;
51916 }
51917
51918
51919 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51920 PyObject *resultobj = 0;
51921 wxSizer *arg1 = (wxSizer *) 0 ;
51922 PyObject *arg2 = (PyObject *) 0 ;
51923 bool result;
51924 void *argp1 = 0 ;
51925 int res1 = 0 ;
51926 PyObject * obj0 = 0 ;
51927 PyObject * obj1 = 0 ;
51928 char * kwnames[] = {
51929 (char *) "self",(char *) "item", NULL
51930 };
51931
51932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
51933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51934 if (!SWIG_IsOK(res1)) {
51935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
51936 }
51937 arg1 = reinterpret_cast< wxSizer * >(argp1);
51938 arg2 = obj1;
51939 {
51940 PyThreadState* __tstate = wxPyBeginAllowThreads();
51941 result = (bool)wxSizer_Remove(arg1,arg2);
51942 wxPyEndAllowThreads(__tstate);
51943 if (PyErr_Occurred()) SWIG_fail;
51944 }
51945 {
51946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51947 }
51948 return resultobj;
51949 fail:
51950 return NULL;
51951 }
51952
51953
51954 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51955 PyObject *resultobj = 0;
51956 wxSizer *arg1 = (wxSizer *) 0 ;
51957 PyObject *arg2 = (PyObject *) 0 ;
51958 bool result;
51959 void *argp1 = 0 ;
51960 int res1 = 0 ;
51961 PyObject * obj0 = 0 ;
51962 PyObject * obj1 = 0 ;
51963 char * kwnames[] = {
51964 (char *) "self",(char *) "item", NULL
51965 };
51966
51967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
51968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51969 if (!SWIG_IsOK(res1)) {
51970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
51971 }
51972 arg1 = reinterpret_cast< wxSizer * >(argp1);
51973 arg2 = obj1;
51974 {
51975 PyThreadState* __tstate = wxPyBeginAllowThreads();
51976 result = (bool)wxSizer_Detach(arg1,arg2);
51977 wxPyEndAllowThreads(__tstate);
51978 if (PyErr_Occurred()) SWIG_fail;
51979 }
51980 {
51981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51982 }
51983 return resultobj;
51984 fail:
51985 return NULL;
51986 }
51987
51988
51989 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51990 PyObject *resultobj = 0;
51991 wxSizer *arg1 = (wxSizer *) 0 ;
51992 PyObject *arg2 = (PyObject *) 0 ;
51993 bool arg3 = (bool) false ;
51994 wxSizerItem *result = 0 ;
51995 void *argp1 = 0 ;
51996 int res1 = 0 ;
51997 bool val3 ;
51998 int ecode3 = 0 ;
51999 PyObject * obj0 = 0 ;
52000 PyObject * obj1 = 0 ;
52001 PyObject * obj2 = 0 ;
52002 char * kwnames[] = {
52003 (char *) "self",(char *) "item",(char *) "recursive", NULL
52004 };
52005
52006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Sizer_GetItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52008 if (!SWIG_IsOK(res1)) {
52009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52010 }
52011 arg1 = reinterpret_cast< wxSizer * >(argp1);
52012 arg2 = obj1;
52013 if (obj2) {
52014 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52015 if (!SWIG_IsOK(ecode3)) {
52016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_GetItem" "', expected argument " "3"" of type '" "bool""'");
52017 }
52018 arg3 = static_cast< bool >(val3);
52019 }
52020 {
52021 PyThreadState* __tstate = wxPyBeginAllowThreads();
52022 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2,arg3);
52023 wxPyEndAllowThreads(__tstate);
52024 if (PyErr_Occurred()) SWIG_fail;
52025 }
52026 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52027 return resultobj;
52028 fail:
52029 return NULL;
52030 }
52031
52032
52033 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52034 PyObject *resultobj = 0;
52035 wxSizer *arg1 = (wxSizer *) 0 ;
52036 PyObject *arg2 = (PyObject *) 0 ;
52037 wxSize *arg3 = 0 ;
52038 void *argp1 = 0 ;
52039 int res1 = 0 ;
52040 wxSize temp3 ;
52041 PyObject * obj0 = 0 ;
52042 PyObject * obj1 = 0 ;
52043 PyObject * obj2 = 0 ;
52044 char * kwnames[] = {
52045 (char *) "self",(char *) "item",(char *) "size", NULL
52046 };
52047
52048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52050 if (!SWIG_IsOK(res1)) {
52051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52052 }
52053 arg1 = reinterpret_cast< wxSizer * >(argp1);
52054 arg2 = obj1;
52055 {
52056 arg3 = &temp3;
52057 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
52058 }
52059 {
52060 PyThreadState* __tstate = wxPyBeginAllowThreads();
52061 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
52062 wxPyEndAllowThreads(__tstate);
52063 if (PyErr_Occurred()) SWIG_fail;
52064 }
52065 resultobj = SWIG_Py_Void();
52066 return resultobj;
52067 fail:
52068 return NULL;
52069 }
52070
52071
52072 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52073 PyObject *resultobj = 0;
52074 wxSizer *arg1 = (wxSizer *) 0 ;
52075 wxWindow *arg2 = (wxWindow *) 0 ;
52076 wxWindow *arg3 = (wxWindow *) 0 ;
52077 bool arg4 = (bool) false ;
52078 bool result;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 void *argp2 = 0 ;
52082 int res2 = 0 ;
52083 void *argp3 = 0 ;
52084 int res3 = 0 ;
52085 bool val4 ;
52086 int ecode4 = 0 ;
52087 PyObject * obj0 = 0 ;
52088 PyObject * obj1 = 0 ;
52089 PyObject * obj2 = 0 ;
52090 PyObject * obj3 = 0 ;
52091 char * kwnames[] = {
52092 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
52093 };
52094
52095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52097 if (!SWIG_IsOK(res1)) {
52098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
52099 }
52100 arg1 = reinterpret_cast< wxSizer * >(argp1);
52101 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52102 if (!SWIG_IsOK(res2)) {
52103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52104 }
52105 arg2 = reinterpret_cast< wxWindow * >(argp2);
52106 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52107 if (!SWIG_IsOK(res3)) {
52108 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
52109 }
52110 arg3 = reinterpret_cast< wxWindow * >(argp3);
52111 if (obj3) {
52112 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52113 if (!SWIG_IsOK(ecode4)) {
52114 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
52115 }
52116 arg4 = static_cast< bool >(val4);
52117 }
52118 {
52119 PyThreadState* __tstate = wxPyBeginAllowThreads();
52120 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52121 wxPyEndAllowThreads(__tstate);
52122 if (PyErr_Occurred()) SWIG_fail;
52123 }
52124 {
52125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52126 }
52127 return resultobj;
52128 fail:
52129 return NULL;
52130 }
52131
52132
52133 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52134 PyObject *resultobj = 0;
52135 wxSizer *arg1 = (wxSizer *) 0 ;
52136 wxSizer *arg2 = (wxSizer *) 0 ;
52137 wxSizer *arg3 = (wxSizer *) 0 ;
52138 bool arg4 = (bool) false ;
52139 bool result;
52140 void *argp1 = 0 ;
52141 int res1 = 0 ;
52142 void *argp2 = 0 ;
52143 int res2 = 0 ;
52144 void *argp3 = 0 ;
52145 int res3 = 0 ;
52146 bool val4 ;
52147 int ecode4 = 0 ;
52148 PyObject * obj0 = 0 ;
52149 PyObject * obj1 = 0 ;
52150 PyObject * obj2 = 0 ;
52151 PyObject * obj3 = 0 ;
52152 char * kwnames[] = {
52153 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
52154 };
52155
52156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52158 if (!SWIG_IsOK(res1)) {
52159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
52160 }
52161 arg1 = reinterpret_cast< wxSizer * >(argp1);
52162 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
52163 if (!SWIG_IsOK(res2)) {
52164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
52165 }
52166 arg2 = reinterpret_cast< wxSizer * >(argp2);
52167 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
52168 if (!SWIG_IsOK(res3)) {
52169 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
52170 }
52171 arg3 = reinterpret_cast< wxSizer * >(argp3);
52172 if (obj3) {
52173 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52174 if (!SWIG_IsOK(ecode4)) {
52175 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
52176 }
52177 arg4 = static_cast< bool >(val4);
52178 }
52179 {
52180 PyThreadState* __tstate = wxPyBeginAllowThreads();
52181 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
52182 wxPyEndAllowThreads(__tstate);
52183 if (PyErr_Occurred()) SWIG_fail;
52184 }
52185 {
52186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52187 }
52188 return resultobj;
52189 fail:
52190 return NULL;
52191 }
52192
52193
52194 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52195 PyObject *resultobj = 0;
52196 wxSizer *arg1 = (wxSizer *) 0 ;
52197 size_t arg2 ;
52198 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52199 bool result;
52200 void *argp1 = 0 ;
52201 int res1 = 0 ;
52202 size_t val2 ;
52203 int ecode2 = 0 ;
52204 void *argp3 = 0 ;
52205 int res3 = 0 ;
52206 PyObject * obj0 = 0 ;
52207 PyObject * obj1 = 0 ;
52208 PyObject * obj2 = 0 ;
52209 char * kwnames[] = {
52210 (char *) "self",(char *) "index",(char *) "newitem", NULL
52211 };
52212
52213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52215 if (!SWIG_IsOK(res1)) {
52216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52217 }
52218 arg1 = reinterpret_cast< wxSizer * >(argp1);
52219 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52220 if (!SWIG_IsOK(ecode2)) {
52221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
52222 }
52223 arg2 = static_cast< size_t >(val2);
52224 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
52225 if (!SWIG_IsOK(res3)) {
52226 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52227 }
52228 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
52229 {
52230 PyThreadState* __tstate = wxPyBeginAllowThreads();
52231 result = (bool)(arg1)->Replace(arg2,arg3);
52232 wxPyEndAllowThreads(__tstate);
52233 if (PyErr_Occurred()) SWIG_fail;
52234 }
52235 {
52236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52237 }
52238 return resultobj;
52239 fail:
52240 return NULL;
52241 }
52242
52243
52244 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52245 PyObject *resultobj = 0;
52246 wxSizer *arg1 = (wxSizer *) 0 ;
52247 wxWindow *arg2 = (wxWindow *) 0 ;
52248 void *argp1 = 0 ;
52249 int res1 = 0 ;
52250 void *argp2 = 0 ;
52251 int res2 = 0 ;
52252 PyObject * obj0 = 0 ;
52253 PyObject * obj1 = 0 ;
52254 char * kwnames[] = {
52255 (char *) "self",(char *) "window", NULL
52256 };
52257
52258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
52259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52260 if (!SWIG_IsOK(res1)) {
52261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
52262 }
52263 arg1 = reinterpret_cast< wxSizer * >(argp1);
52264 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52265 if (!SWIG_IsOK(res2)) {
52266 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
52267 }
52268 arg2 = reinterpret_cast< wxWindow * >(argp2);
52269 {
52270 PyThreadState* __tstate = wxPyBeginAllowThreads();
52271 (arg1)->SetContainingWindow(arg2);
52272 wxPyEndAllowThreads(__tstate);
52273 if (PyErr_Occurred()) SWIG_fail;
52274 }
52275 resultobj = SWIG_Py_Void();
52276 return resultobj;
52277 fail:
52278 return NULL;
52279 }
52280
52281
52282 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52283 PyObject *resultobj = 0;
52284 wxSizer *arg1 = (wxSizer *) 0 ;
52285 wxWindow *result = 0 ;
52286 void *argp1 = 0 ;
52287 int res1 = 0 ;
52288 PyObject *swig_obj[1] ;
52289
52290 if (!args) SWIG_fail;
52291 swig_obj[0] = args;
52292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52293 if (!SWIG_IsOK(res1)) {
52294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
52295 }
52296 arg1 = reinterpret_cast< wxSizer * >(argp1);
52297 {
52298 PyThreadState* __tstate = wxPyBeginAllowThreads();
52299 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
52300 wxPyEndAllowThreads(__tstate);
52301 if (PyErr_Occurred()) SWIG_fail;
52302 }
52303 {
52304 resultobj = wxPyMake_wxObject(result, 0);
52305 }
52306 return resultobj;
52307 fail:
52308 return NULL;
52309 }
52310
52311
52312 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52313 PyObject *resultobj = 0;
52314 wxSizer *arg1 = (wxSizer *) 0 ;
52315 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52316 wxSizerItem *result = 0 ;
52317 void *argp1 = 0 ;
52318 int res1 = 0 ;
52319 int res2 = 0 ;
52320 PyObject * obj0 = 0 ;
52321 PyObject * obj1 = 0 ;
52322 char * kwnames[] = {
52323 (char *) "self",(char *) "item", NULL
52324 };
52325
52326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
52327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52328 if (!SWIG_IsOK(res1)) {
52329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52330 }
52331 arg1 = reinterpret_cast< wxSizer * >(argp1);
52332 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52333 if (!SWIG_IsOK(res2)) {
52334 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52335 }
52336 {
52337 PyThreadState* __tstate = wxPyBeginAllowThreads();
52338 result = (wxSizerItem *)(arg1)->Add(arg2);
52339 wxPyEndAllowThreads(__tstate);
52340 if (PyErr_Occurred()) SWIG_fail;
52341 }
52342 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52343 return resultobj;
52344 fail:
52345 return NULL;
52346 }
52347
52348
52349 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52350 PyObject *resultobj = 0;
52351 wxSizer *arg1 = (wxSizer *) 0 ;
52352 size_t arg2 ;
52353 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
52354 wxSizerItem *result = 0 ;
52355 void *argp1 = 0 ;
52356 int res1 = 0 ;
52357 size_t val2 ;
52358 int ecode2 = 0 ;
52359 int res3 = 0 ;
52360 PyObject * obj0 = 0 ;
52361 PyObject * obj1 = 0 ;
52362 PyObject * obj2 = 0 ;
52363 char * kwnames[] = {
52364 (char *) "self",(char *) "index",(char *) "item", NULL
52365 };
52366
52367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52369 if (!SWIG_IsOK(res1)) {
52370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52371 }
52372 arg1 = reinterpret_cast< wxSizer * >(argp1);
52373 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52374 if (!SWIG_IsOK(ecode2)) {
52375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
52376 }
52377 arg2 = static_cast< size_t >(val2);
52378 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52379 if (!SWIG_IsOK(res3)) {
52380 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
52381 }
52382 {
52383 PyThreadState* __tstate = wxPyBeginAllowThreads();
52384 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
52385 wxPyEndAllowThreads(__tstate);
52386 if (PyErr_Occurred()) SWIG_fail;
52387 }
52388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52389 return resultobj;
52390 fail:
52391 return NULL;
52392 }
52393
52394
52395 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52396 PyObject *resultobj = 0;
52397 wxSizer *arg1 = (wxSizer *) 0 ;
52398 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
52399 wxSizerItem *result = 0 ;
52400 void *argp1 = 0 ;
52401 int res1 = 0 ;
52402 int res2 = 0 ;
52403 PyObject * obj0 = 0 ;
52404 PyObject * obj1 = 0 ;
52405 char * kwnames[] = {
52406 (char *) "self",(char *) "item", NULL
52407 };
52408
52409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
52410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52411 if (!SWIG_IsOK(res1)) {
52412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
52413 }
52414 arg1 = reinterpret_cast< wxSizer * >(argp1);
52415 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
52416 if (!SWIG_IsOK(res2)) {
52417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
52418 }
52419 {
52420 PyThreadState* __tstate = wxPyBeginAllowThreads();
52421 result = (wxSizerItem *)(arg1)->Prepend(arg2);
52422 wxPyEndAllowThreads(__tstate);
52423 if (PyErr_Occurred()) SWIG_fail;
52424 }
52425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
52426 return resultobj;
52427 fail:
52428 return NULL;
52429 }
52430
52431
52432 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52433 PyObject *resultobj = 0;
52434 wxSizer *arg1 = (wxSizer *) 0 ;
52435 int arg2 ;
52436 int arg3 ;
52437 int arg4 ;
52438 int arg5 ;
52439 void *argp1 = 0 ;
52440 int res1 = 0 ;
52441 int val2 ;
52442 int ecode2 = 0 ;
52443 int val3 ;
52444 int ecode3 = 0 ;
52445 int val4 ;
52446 int ecode4 = 0 ;
52447 int val5 ;
52448 int ecode5 = 0 ;
52449 PyObject * obj0 = 0 ;
52450 PyObject * obj1 = 0 ;
52451 PyObject * obj2 = 0 ;
52452 PyObject * obj3 = 0 ;
52453 PyObject * obj4 = 0 ;
52454 char * kwnames[] = {
52455 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
52456 };
52457
52458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
52459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52460 if (!SWIG_IsOK(res1)) {
52461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
52462 }
52463 arg1 = reinterpret_cast< wxSizer * >(argp1);
52464 ecode2 = SWIG_AsVal_int(obj1, &val2);
52465 if (!SWIG_IsOK(ecode2)) {
52466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
52467 }
52468 arg2 = static_cast< int >(val2);
52469 ecode3 = SWIG_AsVal_int(obj2, &val3);
52470 if (!SWIG_IsOK(ecode3)) {
52471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
52472 }
52473 arg3 = static_cast< int >(val3);
52474 ecode4 = SWIG_AsVal_int(obj3, &val4);
52475 if (!SWIG_IsOK(ecode4)) {
52476 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
52477 }
52478 arg4 = static_cast< int >(val4);
52479 ecode5 = SWIG_AsVal_int(obj4, &val5);
52480 if (!SWIG_IsOK(ecode5)) {
52481 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
52482 }
52483 arg5 = static_cast< int >(val5);
52484 {
52485 PyThreadState* __tstate = wxPyBeginAllowThreads();
52486 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
52487 wxPyEndAllowThreads(__tstate);
52488 if (PyErr_Occurred()) SWIG_fail;
52489 }
52490 resultobj = SWIG_Py_Void();
52491 return resultobj;
52492 fail:
52493 return NULL;
52494 }
52495
52496
52497 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52498 PyObject *resultobj = 0;
52499 wxSizer *arg1 = (wxSizer *) 0 ;
52500 wxSize *arg2 = 0 ;
52501 void *argp1 = 0 ;
52502 int res1 = 0 ;
52503 wxSize temp2 ;
52504 PyObject * obj0 = 0 ;
52505 PyObject * obj1 = 0 ;
52506 char * kwnames[] = {
52507 (char *) "self",(char *) "size", NULL
52508 };
52509
52510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
52511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52512 if (!SWIG_IsOK(res1)) {
52513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52514 }
52515 arg1 = reinterpret_cast< wxSizer * >(argp1);
52516 {
52517 arg2 = &temp2;
52518 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
52519 }
52520 {
52521 PyThreadState* __tstate = wxPyBeginAllowThreads();
52522 (arg1)->SetMinSize((wxSize const &)*arg2);
52523 wxPyEndAllowThreads(__tstate);
52524 if (PyErr_Occurred()) SWIG_fail;
52525 }
52526 resultobj = SWIG_Py_Void();
52527 return resultobj;
52528 fail:
52529 return NULL;
52530 }
52531
52532
52533 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52534 PyObject *resultobj = 0;
52535 wxSizer *arg1 = (wxSizer *) 0 ;
52536 wxSize result;
52537 void *argp1 = 0 ;
52538 int res1 = 0 ;
52539 PyObject *swig_obj[1] ;
52540
52541 if (!args) SWIG_fail;
52542 swig_obj[0] = args;
52543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52544 if (!SWIG_IsOK(res1)) {
52545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52546 }
52547 arg1 = reinterpret_cast< wxSizer * >(argp1);
52548 {
52549 PyThreadState* __tstate = wxPyBeginAllowThreads();
52550 result = (arg1)->GetSize();
52551 wxPyEndAllowThreads(__tstate);
52552 if (PyErr_Occurred()) SWIG_fail;
52553 }
52554 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52555 return resultobj;
52556 fail:
52557 return NULL;
52558 }
52559
52560
52561 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52562 PyObject *resultobj = 0;
52563 wxSizer *arg1 = (wxSizer *) 0 ;
52564 wxPoint result;
52565 void *argp1 = 0 ;
52566 int res1 = 0 ;
52567 PyObject *swig_obj[1] ;
52568
52569 if (!args) SWIG_fail;
52570 swig_obj[0] = args;
52571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52572 if (!SWIG_IsOK(res1)) {
52573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
52574 }
52575 arg1 = reinterpret_cast< wxSizer * >(argp1);
52576 {
52577 PyThreadState* __tstate = wxPyBeginAllowThreads();
52578 result = (arg1)->GetPosition();
52579 wxPyEndAllowThreads(__tstate);
52580 if (PyErr_Occurred()) SWIG_fail;
52581 }
52582 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
52583 return resultobj;
52584 fail:
52585 return NULL;
52586 }
52587
52588
52589 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52590 PyObject *resultobj = 0;
52591 wxSizer *arg1 = (wxSizer *) 0 ;
52592 wxSize result;
52593 void *argp1 = 0 ;
52594 int res1 = 0 ;
52595 PyObject *swig_obj[1] ;
52596
52597 if (!args) SWIG_fail;
52598 swig_obj[0] = args;
52599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52600 if (!SWIG_IsOK(res1)) {
52601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
52602 }
52603 arg1 = reinterpret_cast< wxSizer * >(argp1);
52604 {
52605 PyThreadState* __tstate = wxPyBeginAllowThreads();
52606 result = (arg1)->GetMinSize();
52607 wxPyEndAllowThreads(__tstate);
52608 if (PyErr_Occurred()) SWIG_fail;
52609 }
52610 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52611 return resultobj;
52612 fail:
52613 return NULL;
52614 }
52615
52616
52617 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52618 PyObject *resultobj = 0;
52619 wxSizer *arg1 = (wxSizer *) 0 ;
52620 void *argp1 = 0 ;
52621 int res1 = 0 ;
52622 PyObject *swig_obj[1] ;
52623
52624 if (!args) SWIG_fail;
52625 swig_obj[0] = args;
52626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52627 if (!SWIG_IsOK(res1)) {
52628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
52629 }
52630 arg1 = reinterpret_cast< wxSizer * >(argp1);
52631 {
52632 PyThreadState* __tstate = wxPyBeginAllowThreads();
52633 (arg1)->RecalcSizes();
52634 wxPyEndAllowThreads(__tstate);
52635 if (PyErr_Occurred()) SWIG_fail;
52636 }
52637 resultobj = SWIG_Py_Void();
52638 return resultobj;
52639 fail:
52640 return NULL;
52641 }
52642
52643
52644 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52645 PyObject *resultobj = 0;
52646 wxSizer *arg1 = (wxSizer *) 0 ;
52647 wxSize result;
52648 void *argp1 = 0 ;
52649 int res1 = 0 ;
52650 PyObject *swig_obj[1] ;
52651
52652 if (!args) SWIG_fail;
52653 swig_obj[0] = args;
52654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52655 if (!SWIG_IsOK(res1)) {
52656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
52657 }
52658 arg1 = reinterpret_cast< wxSizer * >(argp1);
52659 {
52660 PyThreadState* __tstate = wxPyBeginAllowThreads();
52661 result = (arg1)->CalcMin();
52662 wxPyEndAllowThreads(__tstate);
52663 if (PyErr_Occurred()) SWIG_fail;
52664 }
52665 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52666 return resultobj;
52667 fail:
52668 return NULL;
52669 }
52670
52671
52672 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52673 PyObject *resultobj = 0;
52674 wxSizer *arg1 = (wxSizer *) 0 ;
52675 void *argp1 = 0 ;
52676 int res1 = 0 ;
52677 PyObject *swig_obj[1] ;
52678
52679 if (!args) SWIG_fail;
52680 swig_obj[0] = args;
52681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52682 if (!SWIG_IsOK(res1)) {
52683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
52684 }
52685 arg1 = reinterpret_cast< wxSizer * >(argp1);
52686 {
52687 PyThreadState* __tstate = wxPyBeginAllowThreads();
52688 (arg1)->Layout();
52689 wxPyEndAllowThreads(__tstate);
52690 if (PyErr_Occurred()) SWIG_fail;
52691 }
52692 resultobj = SWIG_Py_Void();
52693 return resultobj;
52694 fail:
52695 return NULL;
52696 }
52697
52698
52699 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52700 PyObject *resultobj = 0;
52701 wxSizer *arg1 = (wxSizer *) 0 ;
52702 wxWindow *arg2 = (wxWindow *) 0 ;
52703 wxSize result;
52704 void *argp1 = 0 ;
52705 int res1 = 0 ;
52706 void *argp2 = 0 ;
52707 int res2 = 0 ;
52708 PyObject * obj0 = 0 ;
52709 PyObject * obj1 = 0 ;
52710 char * kwnames[] = {
52711 (char *) "self",(char *) "window", NULL
52712 };
52713
52714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
52715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52716 if (!SWIG_IsOK(res1)) {
52717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
52718 }
52719 arg1 = reinterpret_cast< wxSizer * >(argp1);
52720 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52721 if (!SWIG_IsOK(res2)) {
52722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
52723 }
52724 arg2 = reinterpret_cast< wxWindow * >(argp2);
52725 {
52726 PyThreadState* __tstate = wxPyBeginAllowThreads();
52727 result = (arg1)->Fit(arg2);
52728 wxPyEndAllowThreads(__tstate);
52729 if (PyErr_Occurred()) SWIG_fail;
52730 }
52731 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
52732 return resultobj;
52733 fail:
52734 return NULL;
52735 }
52736
52737
52738 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52739 PyObject *resultobj = 0;
52740 wxSizer *arg1 = (wxSizer *) 0 ;
52741 wxWindow *arg2 = (wxWindow *) 0 ;
52742 void *argp1 = 0 ;
52743 int res1 = 0 ;
52744 void *argp2 = 0 ;
52745 int res2 = 0 ;
52746 PyObject * obj0 = 0 ;
52747 PyObject * obj1 = 0 ;
52748 char * kwnames[] = {
52749 (char *) "self",(char *) "window", NULL
52750 };
52751
52752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
52753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52754 if (!SWIG_IsOK(res1)) {
52755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
52756 }
52757 arg1 = reinterpret_cast< wxSizer * >(argp1);
52758 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52759 if (!SWIG_IsOK(res2)) {
52760 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
52761 }
52762 arg2 = reinterpret_cast< wxWindow * >(argp2);
52763 {
52764 PyThreadState* __tstate = wxPyBeginAllowThreads();
52765 (arg1)->FitInside(arg2);
52766 wxPyEndAllowThreads(__tstate);
52767 if (PyErr_Occurred()) SWIG_fail;
52768 }
52769 resultobj = SWIG_Py_Void();
52770 return resultobj;
52771 fail:
52772 return NULL;
52773 }
52774
52775
52776 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52777 PyObject *resultobj = 0;
52778 wxSizer *arg1 = (wxSizer *) 0 ;
52779 wxWindow *arg2 = (wxWindow *) 0 ;
52780 void *argp1 = 0 ;
52781 int res1 = 0 ;
52782 void *argp2 = 0 ;
52783 int res2 = 0 ;
52784 PyObject * obj0 = 0 ;
52785 PyObject * obj1 = 0 ;
52786 char * kwnames[] = {
52787 (char *) "self",(char *) "window", NULL
52788 };
52789
52790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52791 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52792 if (!SWIG_IsOK(res1)) {
52793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52794 }
52795 arg1 = reinterpret_cast< wxSizer * >(argp1);
52796 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52797 if (!SWIG_IsOK(res2)) {
52798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52799 }
52800 arg2 = reinterpret_cast< wxWindow * >(argp2);
52801 {
52802 PyThreadState* __tstate = wxPyBeginAllowThreads();
52803 (arg1)->SetSizeHints(arg2);
52804 wxPyEndAllowThreads(__tstate);
52805 if (PyErr_Occurred()) SWIG_fail;
52806 }
52807 resultobj = SWIG_Py_Void();
52808 return resultobj;
52809 fail:
52810 return NULL;
52811 }
52812
52813
52814 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52815 PyObject *resultobj = 0;
52816 wxSizer *arg1 = (wxSizer *) 0 ;
52817 wxWindow *arg2 = (wxWindow *) 0 ;
52818 void *argp1 = 0 ;
52819 int res1 = 0 ;
52820 void *argp2 = 0 ;
52821 int res2 = 0 ;
52822 PyObject * obj0 = 0 ;
52823 PyObject * obj1 = 0 ;
52824 char * kwnames[] = {
52825 (char *) "self",(char *) "window", NULL
52826 };
52827
52828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
52829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52830 if (!SWIG_IsOK(res1)) {
52831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
52832 }
52833 arg1 = reinterpret_cast< wxSizer * >(argp1);
52834 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52835 if (!SWIG_IsOK(res2)) {
52836 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
52837 }
52838 arg2 = reinterpret_cast< wxWindow * >(argp2);
52839 {
52840 PyThreadState* __tstate = wxPyBeginAllowThreads();
52841 (arg1)->SetVirtualSizeHints(arg2);
52842 wxPyEndAllowThreads(__tstate);
52843 if (PyErr_Occurred()) SWIG_fail;
52844 }
52845 resultobj = SWIG_Py_Void();
52846 return resultobj;
52847 fail:
52848 return NULL;
52849 }
52850
52851
52852 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52853 PyObject *resultobj = 0;
52854 wxSizer *arg1 = (wxSizer *) 0 ;
52855 bool arg2 = (bool) false ;
52856 void *argp1 = 0 ;
52857 int res1 = 0 ;
52858 bool val2 ;
52859 int ecode2 = 0 ;
52860 PyObject * obj0 = 0 ;
52861 PyObject * obj1 = 0 ;
52862 char * kwnames[] = {
52863 (char *) "self",(char *) "deleteWindows", NULL
52864 };
52865
52866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
52867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52868 if (!SWIG_IsOK(res1)) {
52869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
52870 }
52871 arg1 = reinterpret_cast< wxSizer * >(argp1);
52872 if (obj1) {
52873 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52874 if (!SWIG_IsOK(ecode2)) {
52875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
52876 }
52877 arg2 = static_cast< bool >(val2);
52878 }
52879 {
52880 PyThreadState* __tstate = wxPyBeginAllowThreads();
52881 (arg1)->Clear(arg2);
52882 wxPyEndAllowThreads(__tstate);
52883 if (PyErr_Occurred()) SWIG_fail;
52884 }
52885 resultobj = SWIG_Py_Void();
52886 return resultobj;
52887 fail:
52888 return NULL;
52889 }
52890
52891
52892 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52893 PyObject *resultobj = 0;
52894 wxSizer *arg1 = (wxSizer *) 0 ;
52895 void *argp1 = 0 ;
52896 int res1 = 0 ;
52897 PyObject *swig_obj[1] ;
52898
52899 if (!args) SWIG_fail;
52900 swig_obj[0] = args;
52901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52902 if (!SWIG_IsOK(res1)) {
52903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
52904 }
52905 arg1 = reinterpret_cast< wxSizer * >(argp1);
52906 {
52907 PyThreadState* __tstate = wxPyBeginAllowThreads();
52908 (arg1)->DeleteWindows();
52909 wxPyEndAllowThreads(__tstate);
52910 if (PyErr_Occurred()) SWIG_fail;
52911 }
52912 resultobj = SWIG_Py_Void();
52913 return resultobj;
52914 fail:
52915 return NULL;
52916 }
52917
52918
52919 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52920 PyObject *resultobj = 0;
52921 wxSizer *arg1 = (wxSizer *) 0 ;
52922 PyObject *result = 0 ;
52923 void *argp1 = 0 ;
52924 int res1 = 0 ;
52925 PyObject *swig_obj[1] ;
52926
52927 if (!args) SWIG_fail;
52928 swig_obj[0] = args;
52929 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52930 if (!SWIG_IsOK(res1)) {
52931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
52932 }
52933 arg1 = reinterpret_cast< wxSizer * >(argp1);
52934 {
52935 PyThreadState* __tstate = wxPyBeginAllowThreads();
52936 result = (PyObject *)wxSizer_GetChildren(arg1);
52937 wxPyEndAllowThreads(__tstate);
52938 if (PyErr_Occurred()) SWIG_fail;
52939 }
52940 resultobj = result;
52941 return resultobj;
52942 fail:
52943 return NULL;
52944 }
52945
52946
52947 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52948 PyObject *resultobj = 0;
52949 wxSizer *arg1 = (wxSizer *) 0 ;
52950 PyObject *arg2 = (PyObject *) 0 ;
52951 bool arg3 = (bool) true ;
52952 bool arg4 = (bool) false ;
52953 bool result;
52954 void *argp1 = 0 ;
52955 int res1 = 0 ;
52956 bool val3 ;
52957 int ecode3 = 0 ;
52958 bool val4 ;
52959 int ecode4 = 0 ;
52960 PyObject * obj0 = 0 ;
52961 PyObject * obj1 = 0 ;
52962 PyObject * obj2 = 0 ;
52963 PyObject * obj3 = 0 ;
52964 char * kwnames[] = {
52965 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
52966 };
52967
52968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
52970 if (!SWIG_IsOK(res1)) {
52971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
52972 }
52973 arg1 = reinterpret_cast< wxSizer * >(argp1);
52974 arg2 = obj1;
52975 if (obj2) {
52976 ecode3 = SWIG_AsVal_bool(obj2, &val3);
52977 if (!SWIG_IsOK(ecode3)) {
52978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
52979 }
52980 arg3 = static_cast< bool >(val3);
52981 }
52982 if (obj3) {
52983 ecode4 = SWIG_AsVal_bool(obj3, &val4);
52984 if (!SWIG_IsOK(ecode4)) {
52985 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
52986 }
52987 arg4 = static_cast< bool >(val4);
52988 }
52989 {
52990 PyThreadState* __tstate = wxPyBeginAllowThreads();
52991 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
52992 wxPyEndAllowThreads(__tstate);
52993 if (PyErr_Occurred()) SWIG_fail;
52994 }
52995 {
52996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52997 }
52998 return resultobj;
52999 fail:
53000 return NULL;
53001 }
53002
53003
53004 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53005 PyObject *resultobj = 0;
53006 wxSizer *arg1 = (wxSizer *) 0 ;
53007 PyObject *arg2 = (PyObject *) 0 ;
53008 bool result;
53009 void *argp1 = 0 ;
53010 int res1 = 0 ;
53011 PyObject * obj0 = 0 ;
53012 PyObject * obj1 = 0 ;
53013 char * kwnames[] = {
53014 (char *) "self",(char *) "item", NULL
53015 };
53016
53017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
53018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53019 if (!SWIG_IsOK(res1)) {
53020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
53021 }
53022 arg1 = reinterpret_cast< wxSizer * >(argp1);
53023 arg2 = obj1;
53024 {
53025 PyThreadState* __tstate = wxPyBeginAllowThreads();
53026 result = (bool)wxSizer_IsShown(arg1,arg2);
53027 wxPyEndAllowThreads(__tstate);
53028 if (PyErr_Occurred()) SWIG_fail;
53029 }
53030 {
53031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53032 }
53033 return resultobj;
53034 fail:
53035 return NULL;
53036 }
53037
53038
53039 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53040 PyObject *resultobj = 0;
53041 wxSizer *arg1 = (wxSizer *) 0 ;
53042 bool arg2 ;
53043 void *argp1 = 0 ;
53044 int res1 = 0 ;
53045 bool val2 ;
53046 int ecode2 = 0 ;
53047 PyObject * obj0 = 0 ;
53048 PyObject * obj1 = 0 ;
53049 char * kwnames[] = {
53050 (char *) "self",(char *) "show", NULL
53051 };
53052
53053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
53054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
53055 if (!SWIG_IsOK(res1)) {
53056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
53057 }
53058 arg1 = reinterpret_cast< wxSizer * >(argp1);
53059 ecode2 = SWIG_AsVal_bool(obj1, &val2);
53060 if (!SWIG_IsOK(ecode2)) {
53061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
53062 }
53063 arg2 = static_cast< bool >(val2);
53064 {
53065 PyThreadState* __tstate = wxPyBeginAllowThreads();
53066 (arg1)->ShowItems(arg2);
53067 wxPyEndAllowThreads(__tstate);
53068 if (PyErr_Occurred()) SWIG_fail;
53069 }
53070 resultobj = SWIG_Py_Void();
53071 return resultobj;
53072 fail:
53073 return NULL;
53074 }
53075
53076
53077 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53078 PyObject *obj;
53079 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53080 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
53081 return SWIG_Py_Void();
53082 }
53083
53084 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53085 PyObject *resultobj = 0;
53086 wxPySizer *result = 0 ;
53087
53088 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
53089 {
53090 PyThreadState* __tstate = wxPyBeginAllowThreads();
53091 result = (wxPySizer *)new wxPySizer();
53092 wxPyEndAllowThreads(__tstate);
53093 if (PyErr_Occurred()) SWIG_fail;
53094 }
53095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
53096 return resultobj;
53097 fail:
53098 return NULL;
53099 }
53100
53101
53102 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53103 PyObject *resultobj = 0;
53104 wxPySizer *arg1 = (wxPySizer *) 0 ;
53105 PyObject *arg2 = (PyObject *) 0 ;
53106 PyObject *arg3 = (PyObject *) 0 ;
53107 void *argp1 = 0 ;
53108 int res1 = 0 ;
53109 PyObject * obj0 = 0 ;
53110 PyObject * obj1 = 0 ;
53111 PyObject * obj2 = 0 ;
53112 char * kwnames[] = {
53113 (char *) "self",(char *) "self",(char *) "_class", NULL
53114 };
53115
53116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
53118 if (!SWIG_IsOK(res1)) {
53119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
53120 }
53121 arg1 = reinterpret_cast< wxPySizer * >(argp1);
53122 arg2 = obj1;
53123 arg3 = obj2;
53124 {
53125 PyThreadState* __tstate = wxPyBeginAllowThreads();
53126 (arg1)->_setCallbackInfo(arg2,arg3);
53127 wxPyEndAllowThreads(__tstate);
53128 if (PyErr_Occurred()) SWIG_fail;
53129 }
53130 resultobj = SWIG_Py_Void();
53131 return resultobj;
53132 fail:
53133 return NULL;
53134 }
53135
53136
53137 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53138 PyObject *obj;
53139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53140 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
53141 return SWIG_Py_Void();
53142 }
53143
53144 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53145 return SWIG_Python_InitShadowInstance(args);
53146 }
53147
53148 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53149 PyObject *resultobj = 0;
53150 int arg1 = (int) wxHORIZONTAL ;
53151 wxBoxSizer *result = 0 ;
53152 int val1 ;
53153 int ecode1 = 0 ;
53154 PyObject * obj0 = 0 ;
53155 char * kwnames[] = {
53156 (char *) "orient", NULL
53157 };
53158
53159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
53160 if (obj0) {
53161 ecode1 = SWIG_AsVal_int(obj0, &val1);
53162 if (!SWIG_IsOK(ecode1)) {
53163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
53164 }
53165 arg1 = static_cast< int >(val1);
53166 }
53167 {
53168 PyThreadState* __tstate = wxPyBeginAllowThreads();
53169 result = (wxBoxSizer *)new wxBoxSizer(arg1);
53170 wxPyEndAllowThreads(__tstate);
53171 if (PyErr_Occurred()) SWIG_fail;
53172 }
53173 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
53174 return resultobj;
53175 fail:
53176 return NULL;
53177 }
53178
53179
53180 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53181 PyObject *resultobj = 0;
53182 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53183 int result;
53184 void *argp1 = 0 ;
53185 int res1 = 0 ;
53186 PyObject *swig_obj[1] ;
53187
53188 if (!args) SWIG_fail;
53189 swig_obj[0] = args;
53190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53191 if (!SWIG_IsOK(res1)) {
53192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53193 }
53194 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53195 {
53196 PyThreadState* __tstate = wxPyBeginAllowThreads();
53197 result = (int)(arg1)->GetOrientation();
53198 wxPyEndAllowThreads(__tstate);
53199 if (PyErr_Occurred()) SWIG_fail;
53200 }
53201 resultobj = SWIG_From_int(static_cast< int >(result));
53202 return resultobj;
53203 fail:
53204 return NULL;
53205 }
53206
53207
53208 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53209 PyObject *resultobj = 0;
53210 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
53211 int arg2 ;
53212 void *argp1 = 0 ;
53213 int res1 = 0 ;
53214 int val2 ;
53215 int ecode2 = 0 ;
53216 PyObject * obj0 = 0 ;
53217 PyObject * obj1 = 0 ;
53218 char * kwnames[] = {
53219 (char *) "self",(char *) "orient", NULL
53220 };
53221
53222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
53223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
53224 if (!SWIG_IsOK(res1)) {
53225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
53226 }
53227 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
53228 ecode2 = SWIG_AsVal_int(obj1, &val2);
53229 if (!SWIG_IsOK(ecode2)) {
53230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
53231 }
53232 arg2 = static_cast< int >(val2);
53233 {
53234 PyThreadState* __tstate = wxPyBeginAllowThreads();
53235 (arg1)->SetOrientation(arg2);
53236 wxPyEndAllowThreads(__tstate);
53237 if (PyErr_Occurred()) SWIG_fail;
53238 }
53239 resultobj = SWIG_Py_Void();
53240 return resultobj;
53241 fail:
53242 return NULL;
53243 }
53244
53245
53246 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53247 PyObject *obj;
53248 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53249 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
53250 return SWIG_Py_Void();
53251 }
53252
53253 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53254 return SWIG_Python_InitShadowInstance(args);
53255 }
53256
53257 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53258 PyObject *resultobj = 0;
53259 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
53260 int arg2 = (int) wxHORIZONTAL ;
53261 wxStaticBoxSizer *result = 0 ;
53262 void *argp1 = 0 ;
53263 int res1 = 0 ;
53264 int val2 ;
53265 int ecode2 = 0 ;
53266 PyObject * obj0 = 0 ;
53267 PyObject * obj1 = 0 ;
53268 char * kwnames[] = {
53269 (char *) "box",(char *) "orient", NULL
53270 };
53271
53272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
53274 if (!SWIG_IsOK(res1)) {
53275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
53276 }
53277 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
53278 if (obj1) {
53279 ecode2 = SWIG_AsVal_int(obj1, &val2);
53280 if (!SWIG_IsOK(ecode2)) {
53281 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
53282 }
53283 arg2 = static_cast< int >(val2);
53284 }
53285 {
53286 PyThreadState* __tstate = wxPyBeginAllowThreads();
53287 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
53288 wxPyEndAllowThreads(__tstate);
53289 if (PyErr_Occurred()) SWIG_fail;
53290 }
53291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
53292 return resultobj;
53293 fail:
53294 return NULL;
53295 }
53296
53297
53298 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53299 PyObject *resultobj = 0;
53300 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
53301 wxStaticBox *result = 0 ;
53302 void *argp1 = 0 ;
53303 int res1 = 0 ;
53304 PyObject *swig_obj[1] ;
53305
53306 if (!args) SWIG_fail;
53307 swig_obj[0] = args;
53308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
53309 if (!SWIG_IsOK(res1)) {
53310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
53311 }
53312 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
53313 {
53314 PyThreadState* __tstate = wxPyBeginAllowThreads();
53315 result = (wxStaticBox *)(arg1)->GetStaticBox();
53316 wxPyEndAllowThreads(__tstate);
53317 if (PyErr_Occurred()) SWIG_fail;
53318 }
53319 {
53320 resultobj = wxPyMake_wxObject(result, (bool)0);
53321 }
53322 return resultobj;
53323 fail:
53324 return NULL;
53325 }
53326
53327
53328 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53329 PyObject *obj;
53330 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53331 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
53332 return SWIG_Py_Void();
53333 }
53334
53335 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53336 return SWIG_Python_InitShadowInstance(args);
53337 }
53338
53339 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53340 PyObject *resultobj = 0;
53341 int arg1 = (int) 1 ;
53342 int arg2 = (int) 0 ;
53343 int arg3 = (int) 0 ;
53344 int arg4 = (int) 0 ;
53345 wxGridSizer *result = 0 ;
53346 int val1 ;
53347 int ecode1 = 0 ;
53348 int val2 ;
53349 int ecode2 = 0 ;
53350 int val3 ;
53351 int ecode3 = 0 ;
53352 int val4 ;
53353 int ecode4 = 0 ;
53354 PyObject * obj0 = 0 ;
53355 PyObject * obj1 = 0 ;
53356 PyObject * obj2 = 0 ;
53357 PyObject * obj3 = 0 ;
53358 char * kwnames[] = {
53359 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53360 };
53361
53362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53363 if (obj0) {
53364 ecode1 = SWIG_AsVal_int(obj0, &val1);
53365 if (!SWIG_IsOK(ecode1)) {
53366 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
53367 }
53368 arg1 = static_cast< int >(val1);
53369 }
53370 if (obj1) {
53371 ecode2 = SWIG_AsVal_int(obj1, &val2);
53372 if (!SWIG_IsOK(ecode2)) {
53373 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
53374 }
53375 arg2 = static_cast< int >(val2);
53376 }
53377 if (obj2) {
53378 ecode3 = SWIG_AsVal_int(obj2, &val3);
53379 if (!SWIG_IsOK(ecode3)) {
53380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
53381 }
53382 arg3 = static_cast< int >(val3);
53383 }
53384 if (obj3) {
53385 ecode4 = SWIG_AsVal_int(obj3, &val4);
53386 if (!SWIG_IsOK(ecode4)) {
53387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
53388 }
53389 arg4 = static_cast< int >(val4);
53390 }
53391 {
53392 PyThreadState* __tstate = wxPyBeginAllowThreads();
53393 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
53394 wxPyEndAllowThreads(__tstate);
53395 if (PyErr_Occurred()) SWIG_fail;
53396 }
53397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
53398 return resultobj;
53399 fail:
53400 return NULL;
53401 }
53402
53403
53404 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53405 PyObject *resultobj = 0;
53406 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53407 int arg2 ;
53408 void *argp1 = 0 ;
53409 int res1 = 0 ;
53410 int val2 ;
53411 int ecode2 = 0 ;
53412 PyObject * obj0 = 0 ;
53413 PyObject * obj1 = 0 ;
53414 char * kwnames[] = {
53415 (char *) "self",(char *) "cols", NULL
53416 };
53417
53418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
53419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53420 if (!SWIG_IsOK(res1)) {
53421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53422 }
53423 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53424 ecode2 = SWIG_AsVal_int(obj1, &val2);
53425 if (!SWIG_IsOK(ecode2)) {
53426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
53427 }
53428 arg2 = static_cast< int >(val2);
53429 {
53430 PyThreadState* __tstate = wxPyBeginAllowThreads();
53431 (arg1)->SetCols(arg2);
53432 wxPyEndAllowThreads(__tstate);
53433 if (PyErr_Occurred()) SWIG_fail;
53434 }
53435 resultobj = SWIG_Py_Void();
53436 return resultobj;
53437 fail:
53438 return NULL;
53439 }
53440
53441
53442 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53443 PyObject *resultobj = 0;
53444 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53445 int arg2 ;
53446 void *argp1 = 0 ;
53447 int res1 = 0 ;
53448 int val2 ;
53449 int ecode2 = 0 ;
53450 PyObject * obj0 = 0 ;
53451 PyObject * obj1 = 0 ;
53452 char * kwnames[] = {
53453 (char *) "self",(char *) "rows", NULL
53454 };
53455
53456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
53457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53458 if (!SWIG_IsOK(res1)) {
53459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53460 }
53461 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53462 ecode2 = SWIG_AsVal_int(obj1, &val2);
53463 if (!SWIG_IsOK(ecode2)) {
53464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
53465 }
53466 arg2 = static_cast< int >(val2);
53467 {
53468 PyThreadState* __tstate = wxPyBeginAllowThreads();
53469 (arg1)->SetRows(arg2);
53470 wxPyEndAllowThreads(__tstate);
53471 if (PyErr_Occurred()) SWIG_fail;
53472 }
53473 resultobj = SWIG_Py_Void();
53474 return resultobj;
53475 fail:
53476 return NULL;
53477 }
53478
53479
53480 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53481 PyObject *resultobj = 0;
53482 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53483 int arg2 ;
53484 void *argp1 = 0 ;
53485 int res1 = 0 ;
53486 int val2 ;
53487 int ecode2 = 0 ;
53488 PyObject * obj0 = 0 ;
53489 PyObject * obj1 = 0 ;
53490 char * kwnames[] = {
53491 (char *) "self",(char *) "gap", NULL
53492 };
53493
53494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
53495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53496 if (!SWIG_IsOK(res1)) {
53497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53498 }
53499 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53500 ecode2 = SWIG_AsVal_int(obj1, &val2);
53501 if (!SWIG_IsOK(ecode2)) {
53502 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
53503 }
53504 arg2 = static_cast< int >(val2);
53505 {
53506 PyThreadState* __tstate = wxPyBeginAllowThreads();
53507 (arg1)->SetVGap(arg2);
53508 wxPyEndAllowThreads(__tstate);
53509 if (PyErr_Occurred()) SWIG_fail;
53510 }
53511 resultobj = SWIG_Py_Void();
53512 return resultobj;
53513 fail:
53514 return NULL;
53515 }
53516
53517
53518 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53519 PyObject *resultobj = 0;
53520 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53521 int arg2 ;
53522 void *argp1 = 0 ;
53523 int res1 = 0 ;
53524 int val2 ;
53525 int ecode2 = 0 ;
53526 PyObject * obj0 = 0 ;
53527 PyObject * obj1 = 0 ;
53528 char * kwnames[] = {
53529 (char *) "self",(char *) "gap", NULL
53530 };
53531
53532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
53533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53534 if (!SWIG_IsOK(res1)) {
53535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53536 }
53537 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53538 ecode2 = SWIG_AsVal_int(obj1, &val2);
53539 if (!SWIG_IsOK(ecode2)) {
53540 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
53541 }
53542 arg2 = static_cast< int >(val2);
53543 {
53544 PyThreadState* __tstate = wxPyBeginAllowThreads();
53545 (arg1)->SetHGap(arg2);
53546 wxPyEndAllowThreads(__tstate);
53547 if (PyErr_Occurred()) SWIG_fail;
53548 }
53549 resultobj = SWIG_Py_Void();
53550 return resultobj;
53551 fail:
53552 return NULL;
53553 }
53554
53555
53556 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53557 PyObject *resultobj = 0;
53558 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53559 int result;
53560 void *argp1 = 0 ;
53561 int res1 = 0 ;
53562 PyObject *swig_obj[1] ;
53563
53564 if (!args) SWIG_fail;
53565 swig_obj[0] = args;
53566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53567 if (!SWIG_IsOK(res1)) {
53568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53569 }
53570 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53571 {
53572 PyThreadState* __tstate = wxPyBeginAllowThreads();
53573 result = (int)(arg1)->GetCols();
53574 wxPyEndAllowThreads(__tstate);
53575 if (PyErr_Occurred()) SWIG_fail;
53576 }
53577 resultobj = SWIG_From_int(static_cast< int >(result));
53578 return resultobj;
53579 fail:
53580 return NULL;
53581 }
53582
53583
53584 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53585 PyObject *resultobj = 0;
53586 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53587 int result;
53588 void *argp1 = 0 ;
53589 int res1 = 0 ;
53590 PyObject *swig_obj[1] ;
53591
53592 if (!args) SWIG_fail;
53593 swig_obj[0] = args;
53594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53595 if (!SWIG_IsOK(res1)) {
53596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53597 }
53598 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53599 {
53600 PyThreadState* __tstate = wxPyBeginAllowThreads();
53601 result = (int)(arg1)->GetRows();
53602 wxPyEndAllowThreads(__tstate);
53603 if (PyErr_Occurred()) SWIG_fail;
53604 }
53605 resultobj = SWIG_From_int(static_cast< int >(result));
53606 return resultobj;
53607 fail:
53608 return NULL;
53609 }
53610
53611
53612 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53613 PyObject *resultobj = 0;
53614 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53615 int result;
53616 void *argp1 = 0 ;
53617 int res1 = 0 ;
53618 PyObject *swig_obj[1] ;
53619
53620 if (!args) SWIG_fail;
53621 swig_obj[0] = args;
53622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53623 if (!SWIG_IsOK(res1)) {
53624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53625 }
53626 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53627 {
53628 PyThreadState* __tstate = wxPyBeginAllowThreads();
53629 result = (int)(arg1)->GetVGap();
53630 wxPyEndAllowThreads(__tstate);
53631 if (PyErr_Occurred()) SWIG_fail;
53632 }
53633 resultobj = SWIG_From_int(static_cast< int >(result));
53634 return resultobj;
53635 fail:
53636 return NULL;
53637 }
53638
53639
53640 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53641 PyObject *resultobj = 0;
53642 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
53643 int result;
53644 void *argp1 = 0 ;
53645 int res1 = 0 ;
53646 PyObject *swig_obj[1] ;
53647
53648 if (!args) SWIG_fail;
53649 swig_obj[0] = args;
53650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
53651 if (!SWIG_IsOK(res1)) {
53652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
53653 }
53654 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
53655 {
53656 PyThreadState* __tstate = wxPyBeginAllowThreads();
53657 result = (int)(arg1)->GetHGap();
53658 wxPyEndAllowThreads(__tstate);
53659 if (PyErr_Occurred()) SWIG_fail;
53660 }
53661 resultobj = SWIG_From_int(static_cast< int >(result));
53662 return resultobj;
53663 fail:
53664 return NULL;
53665 }
53666
53667
53668 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53669 PyObject *obj;
53670 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53671 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
53672 return SWIG_Py_Void();
53673 }
53674
53675 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53676 return SWIG_Python_InitShadowInstance(args);
53677 }
53678
53679 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53680 PyObject *resultobj = 0;
53681 int arg1 = (int) 1 ;
53682 int arg2 = (int) 0 ;
53683 int arg3 = (int) 0 ;
53684 int arg4 = (int) 0 ;
53685 wxFlexGridSizer *result = 0 ;
53686 int val1 ;
53687 int ecode1 = 0 ;
53688 int val2 ;
53689 int ecode2 = 0 ;
53690 int val3 ;
53691 int ecode3 = 0 ;
53692 int val4 ;
53693 int ecode4 = 0 ;
53694 PyObject * obj0 = 0 ;
53695 PyObject * obj1 = 0 ;
53696 PyObject * obj2 = 0 ;
53697 PyObject * obj3 = 0 ;
53698 char * kwnames[] = {
53699 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
53700 };
53701
53702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
53703 if (obj0) {
53704 ecode1 = SWIG_AsVal_int(obj0, &val1);
53705 if (!SWIG_IsOK(ecode1)) {
53706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
53707 }
53708 arg1 = static_cast< int >(val1);
53709 }
53710 if (obj1) {
53711 ecode2 = SWIG_AsVal_int(obj1, &val2);
53712 if (!SWIG_IsOK(ecode2)) {
53713 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
53714 }
53715 arg2 = static_cast< int >(val2);
53716 }
53717 if (obj2) {
53718 ecode3 = SWIG_AsVal_int(obj2, &val3);
53719 if (!SWIG_IsOK(ecode3)) {
53720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
53721 }
53722 arg3 = static_cast< int >(val3);
53723 }
53724 if (obj3) {
53725 ecode4 = SWIG_AsVal_int(obj3, &val4);
53726 if (!SWIG_IsOK(ecode4)) {
53727 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
53728 }
53729 arg4 = static_cast< int >(val4);
53730 }
53731 {
53732 PyThreadState* __tstate = wxPyBeginAllowThreads();
53733 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
53734 wxPyEndAllowThreads(__tstate);
53735 if (PyErr_Occurred()) SWIG_fail;
53736 }
53737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
53738 return resultobj;
53739 fail:
53740 return NULL;
53741 }
53742
53743
53744 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53745 PyObject *resultobj = 0;
53746 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53747 size_t arg2 ;
53748 int arg3 = (int) 0 ;
53749 void *argp1 = 0 ;
53750 int res1 = 0 ;
53751 size_t val2 ;
53752 int ecode2 = 0 ;
53753 int val3 ;
53754 int ecode3 = 0 ;
53755 PyObject * obj0 = 0 ;
53756 PyObject * obj1 = 0 ;
53757 PyObject * obj2 = 0 ;
53758 char * kwnames[] = {
53759 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53760 };
53761
53762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53764 if (!SWIG_IsOK(res1)) {
53765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53766 }
53767 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53768 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53769 if (!SWIG_IsOK(ecode2)) {
53770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53771 }
53772 arg2 = static_cast< size_t >(val2);
53773 if (obj2) {
53774 ecode3 = SWIG_AsVal_int(obj2, &val3);
53775 if (!SWIG_IsOK(ecode3)) {
53776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
53777 }
53778 arg3 = static_cast< int >(val3);
53779 }
53780 {
53781 PyThreadState* __tstate = wxPyBeginAllowThreads();
53782 (arg1)->AddGrowableRow(arg2,arg3);
53783 wxPyEndAllowThreads(__tstate);
53784 if (PyErr_Occurred()) SWIG_fail;
53785 }
53786 resultobj = SWIG_Py_Void();
53787 return resultobj;
53788 fail:
53789 return NULL;
53790 }
53791
53792
53793 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53794 PyObject *resultobj = 0;
53795 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53796 size_t arg2 ;
53797 void *argp1 = 0 ;
53798 int res1 = 0 ;
53799 size_t val2 ;
53800 int ecode2 = 0 ;
53801 PyObject * obj0 = 0 ;
53802 PyObject * obj1 = 0 ;
53803 char * kwnames[] = {
53804 (char *) "self",(char *) "idx", NULL
53805 };
53806
53807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
53808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53809 if (!SWIG_IsOK(res1)) {
53810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53811 }
53812 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53813 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53814 if (!SWIG_IsOK(ecode2)) {
53815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
53816 }
53817 arg2 = static_cast< size_t >(val2);
53818 {
53819 PyThreadState* __tstate = wxPyBeginAllowThreads();
53820 (arg1)->RemoveGrowableRow(arg2);
53821 wxPyEndAllowThreads(__tstate);
53822 if (PyErr_Occurred()) SWIG_fail;
53823 }
53824 resultobj = SWIG_Py_Void();
53825 return resultobj;
53826 fail:
53827 return NULL;
53828 }
53829
53830
53831 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53832 PyObject *resultobj = 0;
53833 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53834 size_t arg2 ;
53835 int arg3 = (int) 0 ;
53836 void *argp1 = 0 ;
53837 int res1 = 0 ;
53838 size_t val2 ;
53839 int ecode2 = 0 ;
53840 int val3 ;
53841 int ecode3 = 0 ;
53842 PyObject * obj0 = 0 ;
53843 PyObject * obj1 = 0 ;
53844 PyObject * obj2 = 0 ;
53845 char * kwnames[] = {
53846 (char *) "self",(char *) "idx",(char *) "proportion", NULL
53847 };
53848
53849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53851 if (!SWIG_IsOK(res1)) {
53852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53853 }
53854 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53855 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53856 if (!SWIG_IsOK(ecode2)) {
53857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53858 }
53859 arg2 = static_cast< size_t >(val2);
53860 if (obj2) {
53861 ecode3 = SWIG_AsVal_int(obj2, &val3);
53862 if (!SWIG_IsOK(ecode3)) {
53863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
53864 }
53865 arg3 = static_cast< int >(val3);
53866 }
53867 {
53868 PyThreadState* __tstate = wxPyBeginAllowThreads();
53869 (arg1)->AddGrowableCol(arg2,arg3);
53870 wxPyEndAllowThreads(__tstate);
53871 if (PyErr_Occurred()) SWIG_fail;
53872 }
53873 resultobj = SWIG_Py_Void();
53874 return resultobj;
53875 fail:
53876 return NULL;
53877 }
53878
53879
53880 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53881 PyObject *resultobj = 0;
53882 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53883 size_t arg2 ;
53884 void *argp1 = 0 ;
53885 int res1 = 0 ;
53886 size_t val2 ;
53887 int ecode2 = 0 ;
53888 PyObject * obj0 = 0 ;
53889 PyObject * obj1 = 0 ;
53890 char * kwnames[] = {
53891 (char *) "self",(char *) "idx", NULL
53892 };
53893
53894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
53895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53896 if (!SWIG_IsOK(res1)) {
53897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53898 }
53899 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53900 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
53901 if (!SWIG_IsOK(ecode2)) {
53902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
53903 }
53904 arg2 = static_cast< size_t >(val2);
53905 {
53906 PyThreadState* __tstate = wxPyBeginAllowThreads();
53907 (arg1)->RemoveGrowableCol(arg2);
53908 wxPyEndAllowThreads(__tstate);
53909 if (PyErr_Occurred()) SWIG_fail;
53910 }
53911 resultobj = SWIG_Py_Void();
53912 return resultobj;
53913 fail:
53914 return NULL;
53915 }
53916
53917
53918 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53919 PyObject *resultobj = 0;
53920 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53921 int arg2 ;
53922 void *argp1 = 0 ;
53923 int res1 = 0 ;
53924 int val2 ;
53925 int ecode2 = 0 ;
53926 PyObject * obj0 = 0 ;
53927 PyObject * obj1 = 0 ;
53928 char * kwnames[] = {
53929 (char *) "self",(char *) "direction", NULL
53930 };
53931
53932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
53933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53934 if (!SWIG_IsOK(res1)) {
53935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53936 }
53937 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53938 ecode2 = SWIG_AsVal_int(obj1, &val2);
53939 if (!SWIG_IsOK(ecode2)) {
53940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
53941 }
53942 arg2 = static_cast< int >(val2);
53943 {
53944 PyThreadState* __tstate = wxPyBeginAllowThreads();
53945 (arg1)->SetFlexibleDirection(arg2);
53946 wxPyEndAllowThreads(__tstate);
53947 if (PyErr_Occurred()) SWIG_fail;
53948 }
53949 resultobj = SWIG_Py_Void();
53950 return resultobj;
53951 fail:
53952 return NULL;
53953 }
53954
53955
53956 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53957 PyObject *resultobj = 0;
53958 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53959 int result;
53960 void *argp1 = 0 ;
53961 int res1 = 0 ;
53962 PyObject *swig_obj[1] ;
53963
53964 if (!args) SWIG_fail;
53965 swig_obj[0] = args;
53966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
53967 if (!SWIG_IsOK(res1)) {
53968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
53969 }
53970 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
53971 {
53972 PyThreadState* __tstate = wxPyBeginAllowThreads();
53973 result = (int)(arg1)->GetFlexibleDirection();
53974 wxPyEndAllowThreads(__tstate);
53975 if (PyErr_Occurred()) SWIG_fail;
53976 }
53977 resultobj = SWIG_From_int(static_cast< int >(result));
53978 return resultobj;
53979 fail:
53980 return NULL;
53981 }
53982
53983
53984 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53985 PyObject *resultobj = 0;
53986 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
53987 wxFlexSizerGrowMode arg2 ;
53988 void *argp1 = 0 ;
53989 int res1 = 0 ;
53990 int val2 ;
53991 int ecode2 = 0 ;
53992 PyObject * obj0 = 0 ;
53993 PyObject * obj1 = 0 ;
53994 char * kwnames[] = {
53995 (char *) "self",(char *) "mode", NULL
53996 };
53997
53998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
53999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54000 if (!SWIG_IsOK(res1)) {
54001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54002 }
54003 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54004 ecode2 = SWIG_AsVal_int(obj1, &val2);
54005 if (!SWIG_IsOK(ecode2)) {
54006 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
54007 }
54008 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
54009 {
54010 PyThreadState* __tstate = wxPyBeginAllowThreads();
54011 (arg1)->SetNonFlexibleGrowMode(arg2);
54012 wxPyEndAllowThreads(__tstate);
54013 if (PyErr_Occurred()) SWIG_fail;
54014 }
54015 resultobj = SWIG_Py_Void();
54016 return resultobj;
54017 fail:
54018 return NULL;
54019 }
54020
54021
54022 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54023 PyObject *resultobj = 0;
54024 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54025 wxFlexSizerGrowMode result;
54026 void *argp1 = 0 ;
54027 int res1 = 0 ;
54028 PyObject *swig_obj[1] ;
54029
54030 if (!args) SWIG_fail;
54031 swig_obj[0] = args;
54032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54033 if (!SWIG_IsOK(res1)) {
54034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
54035 }
54036 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54037 {
54038 PyThreadState* __tstate = wxPyBeginAllowThreads();
54039 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
54040 wxPyEndAllowThreads(__tstate);
54041 if (PyErr_Occurred()) SWIG_fail;
54042 }
54043 resultobj = SWIG_From_int(static_cast< int >(result));
54044 return resultobj;
54045 fail:
54046 return NULL;
54047 }
54048
54049
54050 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54051 PyObject *resultobj = 0;
54052 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54053 wxArrayInt *result = 0 ;
54054 void *argp1 = 0 ;
54055 int res1 = 0 ;
54056 PyObject *swig_obj[1] ;
54057
54058 if (!args) SWIG_fail;
54059 swig_obj[0] = args;
54060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54061 if (!SWIG_IsOK(res1)) {
54062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54063 }
54064 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54065 {
54066 PyThreadState* __tstate = wxPyBeginAllowThreads();
54067 {
54068 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
54069 result = (wxArrayInt *) &_result_ref;
54070 }
54071 wxPyEndAllowThreads(__tstate);
54072 if (PyErr_Occurred()) SWIG_fail;
54073 }
54074 {
54075 resultobj = wxArrayInt2PyList_helper(*result);
54076 }
54077 return resultobj;
54078 fail:
54079 return NULL;
54080 }
54081
54082
54083 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54084 PyObject *resultobj = 0;
54085 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
54086 wxArrayInt *result = 0 ;
54087 void *argp1 = 0 ;
54088 int res1 = 0 ;
54089 PyObject *swig_obj[1] ;
54090
54091 if (!args) SWIG_fail;
54092 swig_obj[0] = args;
54093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
54094 if (!SWIG_IsOK(res1)) {
54095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
54096 }
54097 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
54098 {
54099 PyThreadState* __tstate = wxPyBeginAllowThreads();
54100 {
54101 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
54102 result = (wxArrayInt *) &_result_ref;
54103 }
54104 wxPyEndAllowThreads(__tstate);
54105 if (PyErr_Occurred()) SWIG_fail;
54106 }
54107 {
54108 resultobj = wxArrayInt2PyList_helper(*result);
54109 }
54110 return resultobj;
54111 fail:
54112 return NULL;
54113 }
54114
54115
54116 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54117 PyObject *obj;
54118 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54119 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
54120 return SWIG_Py_Void();
54121 }
54122
54123 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54124 return SWIG_Python_InitShadowInstance(args);
54125 }
54126
54127 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54128 PyObject *resultobj = 0;
54129 wxStdDialogButtonSizer *result = 0 ;
54130
54131 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
54132 {
54133 PyThreadState* __tstate = wxPyBeginAllowThreads();
54134 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
54135 wxPyEndAllowThreads(__tstate);
54136 if (PyErr_Occurred()) SWIG_fail;
54137 }
54138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
54139 return resultobj;
54140 fail:
54141 return NULL;
54142 }
54143
54144
54145 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54146 PyObject *resultobj = 0;
54147 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54148 wxButton *arg2 = (wxButton *) 0 ;
54149 void *argp1 = 0 ;
54150 int res1 = 0 ;
54151 void *argp2 = 0 ;
54152 int res2 = 0 ;
54153 PyObject * obj0 = 0 ;
54154 PyObject * obj1 = 0 ;
54155 char * kwnames[] = {
54156 (char *) "self",(char *) "button", NULL
54157 };
54158
54159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
54160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54161 if (!SWIG_IsOK(res1)) {
54162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54163 }
54164 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54166 if (!SWIG_IsOK(res2)) {
54167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
54168 }
54169 arg2 = reinterpret_cast< wxButton * >(argp2);
54170 {
54171 PyThreadState* __tstate = wxPyBeginAllowThreads();
54172 (arg1)->AddButton(arg2);
54173 wxPyEndAllowThreads(__tstate);
54174 if (PyErr_Occurred()) SWIG_fail;
54175 }
54176 resultobj = SWIG_Py_Void();
54177 return resultobj;
54178 fail:
54179 return NULL;
54180 }
54181
54182
54183 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54184 PyObject *resultobj = 0;
54185 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54186 void *argp1 = 0 ;
54187 int res1 = 0 ;
54188 PyObject *swig_obj[1] ;
54189
54190 if (!args) SWIG_fail;
54191 swig_obj[0] = args;
54192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54193 if (!SWIG_IsOK(res1)) {
54194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54195 }
54196 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54197 {
54198 PyThreadState* __tstate = wxPyBeginAllowThreads();
54199 (arg1)->Realize();
54200 wxPyEndAllowThreads(__tstate);
54201 if (PyErr_Occurred()) SWIG_fail;
54202 }
54203 resultobj = SWIG_Py_Void();
54204 return resultobj;
54205 fail:
54206 return NULL;
54207 }
54208
54209
54210 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54211 PyObject *resultobj = 0;
54212 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54213 wxButton *arg2 = (wxButton *) 0 ;
54214 void *argp1 = 0 ;
54215 int res1 = 0 ;
54216 void *argp2 = 0 ;
54217 int res2 = 0 ;
54218 PyObject * obj0 = 0 ;
54219 PyObject * obj1 = 0 ;
54220 char * kwnames[] = {
54221 (char *) "self",(char *) "button", NULL
54222 };
54223
54224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54226 if (!SWIG_IsOK(res1)) {
54227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54228 }
54229 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54230 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54231 if (!SWIG_IsOK(res2)) {
54232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54233 }
54234 arg2 = reinterpret_cast< wxButton * >(argp2);
54235 {
54236 PyThreadState* __tstate = wxPyBeginAllowThreads();
54237 (arg1)->SetAffirmativeButton(arg2);
54238 wxPyEndAllowThreads(__tstate);
54239 if (PyErr_Occurred()) SWIG_fail;
54240 }
54241 resultobj = SWIG_Py_Void();
54242 return resultobj;
54243 fail:
54244 return NULL;
54245 }
54246
54247
54248 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54249 PyObject *resultobj = 0;
54250 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54251 wxButton *arg2 = (wxButton *) 0 ;
54252 void *argp1 = 0 ;
54253 int res1 = 0 ;
54254 void *argp2 = 0 ;
54255 int res2 = 0 ;
54256 PyObject * obj0 = 0 ;
54257 PyObject * obj1 = 0 ;
54258 char * kwnames[] = {
54259 (char *) "self",(char *) "button", NULL
54260 };
54261
54262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
54263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54264 if (!SWIG_IsOK(res1)) {
54265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54266 }
54267 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54268 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54269 if (!SWIG_IsOK(res2)) {
54270 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
54271 }
54272 arg2 = reinterpret_cast< wxButton * >(argp2);
54273 {
54274 PyThreadState* __tstate = wxPyBeginAllowThreads();
54275 (arg1)->SetNegativeButton(arg2);
54276 wxPyEndAllowThreads(__tstate);
54277 if (PyErr_Occurred()) SWIG_fail;
54278 }
54279 resultobj = SWIG_Py_Void();
54280 return resultobj;
54281 fail:
54282 return NULL;
54283 }
54284
54285
54286 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54287 PyObject *resultobj = 0;
54288 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54289 wxButton *arg2 = (wxButton *) 0 ;
54290 void *argp1 = 0 ;
54291 int res1 = 0 ;
54292 void *argp2 = 0 ;
54293 int res2 = 0 ;
54294 PyObject * obj0 = 0 ;
54295 PyObject * obj1 = 0 ;
54296 char * kwnames[] = {
54297 (char *) "self",(char *) "button", NULL
54298 };
54299
54300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
54301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54302 if (!SWIG_IsOK(res1)) {
54303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
54304 }
54305 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
54307 if (!SWIG_IsOK(res2)) {
54308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
54309 }
54310 arg2 = reinterpret_cast< wxButton * >(argp2);
54311 {
54312 PyThreadState* __tstate = wxPyBeginAllowThreads();
54313 (arg1)->SetCancelButton(arg2);
54314 wxPyEndAllowThreads(__tstate);
54315 if (PyErr_Occurred()) SWIG_fail;
54316 }
54317 resultobj = SWIG_Py_Void();
54318 return resultobj;
54319 fail:
54320 return NULL;
54321 }
54322
54323
54324 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54325 PyObject *resultobj = 0;
54326 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54327 wxButton *result = 0 ;
54328 void *argp1 = 0 ;
54329 int res1 = 0 ;
54330 PyObject *swig_obj[1] ;
54331
54332 if (!args) SWIG_fail;
54333 swig_obj[0] = args;
54334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54335 if (!SWIG_IsOK(res1)) {
54336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54337 }
54338 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54339 {
54340 PyThreadState* __tstate = wxPyBeginAllowThreads();
54341 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
54342 wxPyEndAllowThreads(__tstate);
54343 if (PyErr_Occurred()) SWIG_fail;
54344 }
54345 {
54346 resultobj = wxPyMake_wxObject(result, (bool)0);
54347 }
54348 return resultobj;
54349 fail:
54350 return NULL;
54351 }
54352
54353
54354 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54355 PyObject *resultobj = 0;
54356 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54357 wxButton *result = 0 ;
54358 void *argp1 = 0 ;
54359 int res1 = 0 ;
54360 PyObject *swig_obj[1] ;
54361
54362 if (!args) SWIG_fail;
54363 swig_obj[0] = args;
54364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54365 if (!SWIG_IsOK(res1)) {
54366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54367 }
54368 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54369 {
54370 PyThreadState* __tstate = wxPyBeginAllowThreads();
54371 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
54372 wxPyEndAllowThreads(__tstate);
54373 if (PyErr_Occurred()) SWIG_fail;
54374 }
54375 {
54376 resultobj = wxPyMake_wxObject(result, (bool)0);
54377 }
54378 return resultobj;
54379 fail:
54380 return NULL;
54381 }
54382
54383
54384 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54385 PyObject *resultobj = 0;
54386 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54387 wxButton *result = 0 ;
54388 void *argp1 = 0 ;
54389 int res1 = 0 ;
54390 PyObject *swig_obj[1] ;
54391
54392 if (!args) SWIG_fail;
54393 swig_obj[0] = args;
54394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54395 if (!SWIG_IsOK(res1)) {
54396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54397 }
54398 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54399 {
54400 PyThreadState* __tstate = wxPyBeginAllowThreads();
54401 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
54402 wxPyEndAllowThreads(__tstate);
54403 if (PyErr_Occurred()) SWIG_fail;
54404 }
54405 {
54406 resultobj = wxPyMake_wxObject(result, (bool)0);
54407 }
54408 return resultobj;
54409 fail:
54410 return NULL;
54411 }
54412
54413
54414 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54415 PyObject *resultobj = 0;
54416 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54417 wxButton *result = 0 ;
54418 void *argp1 = 0 ;
54419 int res1 = 0 ;
54420 PyObject *swig_obj[1] ;
54421
54422 if (!args) SWIG_fail;
54423 swig_obj[0] = args;
54424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54425 if (!SWIG_IsOK(res1)) {
54426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54427 }
54428 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54429 {
54430 PyThreadState* __tstate = wxPyBeginAllowThreads();
54431 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
54432 wxPyEndAllowThreads(__tstate);
54433 if (PyErr_Occurred()) SWIG_fail;
54434 }
54435 {
54436 resultobj = wxPyMake_wxObject(result, (bool)0);
54437 }
54438 return resultobj;
54439 fail:
54440 return NULL;
54441 }
54442
54443
54444 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54445 PyObject *resultobj = 0;
54446 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
54447 wxButton *result = 0 ;
54448 void *argp1 = 0 ;
54449 int res1 = 0 ;
54450 PyObject *swig_obj[1] ;
54451
54452 if (!args) SWIG_fail;
54453 swig_obj[0] = args;
54454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
54455 if (!SWIG_IsOK(res1)) {
54456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
54457 }
54458 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
54459 {
54460 PyThreadState* __tstate = wxPyBeginAllowThreads();
54461 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
54462 wxPyEndAllowThreads(__tstate);
54463 if (PyErr_Occurred()) SWIG_fail;
54464 }
54465 {
54466 resultobj = wxPyMake_wxObject(result, (bool)0);
54467 }
54468 return resultobj;
54469 fail:
54470 return NULL;
54471 }
54472
54473
54474 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54475 PyObject *obj;
54476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54477 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
54478 return SWIG_Py_Void();
54479 }
54480
54481 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54482 return SWIG_Python_InitShadowInstance(args);
54483 }
54484
54485 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54486 PyObject *resultobj = 0;
54487 int arg1 = (int) 0 ;
54488 int arg2 = (int) 0 ;
54489 wxGBPosition *result = 0 ;
54490 int val1 ;
54491 int ecode1 = 0 ;
54492 int val2 ;
54493 int ecode2 = 0 ;
54494 PyObject * obj0 = 0 ;
54495 PyObject * obj1 = 0 ;
54496 char * kwnames[] = {
54497 (char *) "row",(char *) "col", NULL
54498 };
54499
54500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54501 if (obj0) {
54502 ecode1 = SWIG_AsVal_int(obj0, &val1);
54503 if (!SWIG_IsOK(ecode1)) {
54504 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
54505 }
54506 arg1 = static_cast< int >(val1);
54507 }
54508 if (obj1) {
54509 ecode2 = SWIG_AsVal_int(obj1, &val2);
54510 if (!SWIG_IsOK(ecode2)) {
54511 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
54512 }
54513 arg2 = static_cast< int >(val2);
54514 }
54515 {
54516 PyThreadState* __tstate = wxPyBeginAllowThreads();
54517 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
54518 wxPyEndAllowThreads(__tstate);
54519 if (PyErr_Occurred()) SWIG_fail;
54520 }
54521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
54522 return resultobj;
54523 fail:
54524 return NULL;
54525 }
54526
54527
54528 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54529 PyObject *resultobj = 0;
54530 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54531 void *argp1 = 0 ;
54532 int res1 = 0 ;
54533 PyObject *swig_obj[1] ;
54534
54535 if (!args) SWIG_fail;
54536 swig_obj[0] = args;
54537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
54538 if (!SWIG_IsOK(res1)) {
54539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54540 }
54541 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54542 {
54543 PyThreadState* __tstate = wxPyBeginAllowThreads();
54544 delete arg1;
54545
54546 wxPyEndAllowThreads(__tstate);
54547 if (PyErr_Occurred()) SWIG_fail;
54548 }
54549 resultobj = SWIG_Py_Void();
54550 return resultobj;
54551 fail:
54552 return NULL;
54553 }
54554
54555
54556 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54557 PyObject *resultobj = 0;
54558 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54559 int result;
54560 void *argp1 = 0 ;
54561 int res1 = 0 ;
54562 PyObject *swig_obj[1] ;
54563
54564 if (!args) SWIG_fail;
54565 swig_obj[0] = args;
54566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54567 if (!SWIG_IsOK(res1)) {
54568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54569 }
54570 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54571 {
54572 PyThreadState* __tstate = wxPyBeginAllowThreads();
54573 result = (int)((wxGBPosition const *)arg1)->GetRow();
54574 wxPyEndAllowThreads(__tstate);
54575 if (PyErr_Occurred()) SWIG_fail;
54576 }
54577 resultobj = SWIG_From_int(static_cast< int >(result));
54578 return resultobj;
54579 fail:
54580 return NULL;
54581 }
54582
54583
54584 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54585 PyObject *resultobj = 0;
54586 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54587 int result;
54588 void *argp1 = 0 ;
54589 int res1 = 0 ;
54590 PyObject *swig_obj[1] ;
54591
54592 if (!args) SWIG_fail;
54593 swig_obj[0] = args;
54594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54595 if (!SWIG_IsOK(res1)) {
54596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
54597 }
54598 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54599 {
54600 PyThreadState* __tstate = wxPyBeginAllowThreads();
54601 result = (int)((wxGBPosition const *)arg1)->GetCol();
54602 wxPyEndAllowThreads(__tstate);
54603 if (PyErr_Occurred()) SWIG_fail;
54604 }
54605 resultobj = SWIG_From_int(static_cast< int >(result));
54606 return resultobj;
54607 fail:
54608 return NULL;
54609 }
54610
54611
54612 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54613 PyObject *resultobj = 0;
54614 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54615 int arg2 ;
54616 void *argp1 = 0 ;
54617 int res1 = 0 ;
54618 int val2 ;
54619 int ecode2 = 0 ;
54620 PyObject * obj0 = 0 ;
54621 PyObject * obj1 = 0 ;
54622 char * kwnames[] = {
54623 (char *) "self",(char *) "row", NULL
54624 };
54625
54626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
54627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54628 if (!SWIG_IsOK(res1)) {
54629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54630 }
54631 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54632 ecode2 = SWIG_AsVal_int(obj1, &val2);
54633 if (!SWIG_IsOK(ecode2)) {
54634 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
54635 }
54636 arg2 = static_cast< int >(val2);
54637 {
54638 PyThreadState* __tstate = wxPyBeginAllowThreads();
54639 (arg1)->SetRow(arg2);
54640 wxPyEndAllowThreads(__tstate);
54641 if (PyErr_Occurred()) SWIG_fail;
54642 }
54643 resultobj = SWIG_Py_Void();
54644 return resultobj;
54645 fail:
54646 return NULL;
54647 }
54648
54649
54650 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54651 PyObject *resultobj = 0;
54652 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54653 int arg2 ;
54654 void *argp1 = 0 ;
54655 int res1 = 0 ;
54656 int val2 ;
54657 int ecode2 = 0 ;
54658 PyObject * obj0 = 0 ;
54659 PyObject * obj1 = 0 ;
54660 char * kwnames[] = {
54661 (char *) "self",(char *) "col", NULL
54662 };
54663
54664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
54665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54666 if (!SWIG_IsOK(res1)) {
54667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54668 }
54669 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54670 ecode2 = SWIG_AsVal_int(obj1, &val2);
54671 if (!SWIG_IsOK(ecode2)) {
54672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
54673 }
54674 arg2 = static_cast< int >(val2);
54675 {
54676 PyThreadState* __tstate = wxPyBeginAllowThreads();
54677 (arg1)->SetCol(arg2);
54678 wxPyEndAllowThreads(__tstate);
54679 if (PyErr_Occurred()) SWIG_fail;
54680 }
54681 resultobj = SWIG_Py_Void();
54682 return resultobj;
54683 fail:
54684 return NULL;
54685 }
54686
54687
54688 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54689 PyObject *resultobj = 0;
54690 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54691 PyObject *arg2 = (PyObject *) 0 ;
54692 bool result;
54693 void *argp1 = 0 ;
54694 int res1 = 0 ;
54695 PyObject * obj0 = 0 ;
54696 PyObject * obj1 = 0 ;
54697 char * kwnames[] = {
54698 (char *) "self",(char *) "other", NULL
54699 };
54700
54701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
54702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54703 if (!SWIG_IsOK(res1)) {
54704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54705 }
54706 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54707 arg2 = obj1;
54708 {
54709 result = (bool)wxGBPosition___eq__(arg1,arg2);
54710 if (PyErr_Occurred()) SWIG_fail;
54711 }
54712 {
54713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54714 }
54715 return resultobj;
54716 fail:
54717 return NULL;
54718 }
54719
54720
54721 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54722 PyObject *resultobj = 0;
54723 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54724 PyObject *arg2 = (PyObject *) 0 ;
54725 bool result;
54726 void *argp1 = 0 ;
54727 int res1 = 0 ;
54728 PyObject * obj0 = 0 ;
54729 PyObject * obj1 = 0 ;
54730 char * kwnames[] = {
54731 (char *) "self",(char *) "other", NULL
54732 };
54733
54734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
54735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54736 if (!SWIG_IsOK(res1)) {
54737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54738 }
54739 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54740 arg2 = obj1;
54741 {
54742 result = (bool)wxGBPosition___ne__(arg1,arg2);
54743 if (PyErr_Occurred()) SWIG_fail;
54744 }
54745 {
54746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54747 }
54748 return resultobj;
54749 fail:
54750 return NULL;
54751 }
54752
54753
54754 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54755 PyObject *resultobj = 0;
54756 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54757 int arg2 = (int) 0 ;
54758 int arg3 = (int) 0 ;
54759 void *argp1 = 0 ;
54760 int res1 = 0 ;
54761 int val2 ;
54762 int ecode2 = 0 ;
54763 int val3 ;
54764 int ecode3 = 0 ;
54765 PyObject * obj0 = 0 ;
54766 PyObject * obj1 = 0 ;
54767 PyObject * obj2 = 0 ;
54768 char * kwnames[] = {
54769 (char *) "self",(char *) "row",(char *) "col", NULL
54770 };
54771
54772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54774 if (!SWIG_IsOK(res1)) {
54775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54776 }
54777 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54778 if (obj1) {
54779 ecode2 = SWIG_AsVal_int(obj1, &val2);
54780 if (!SWIG_IsOK(ecode2)) {
54781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
54782 }
54783 arg2 = static_cast< int >(val2);
54784 }
54785 if (obj2) {
54786 ecode3 = SWIG_AsVal_int(obj2, &val3);
54787 if (!SWIG_IsOK(ecode3)) {
54788 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
54789 }
54790 arg3 = static_cast< int >(val3);
54791 }
54792 {
54793 PyThreadState* __tstate = wxPyBeginAllowThreads();
54794 wxGBPosition_Set(arg1,arg2,arg3);
54795 wxPyEndAllowThreads(__tstate);
54796 if (PyErr_Occurred()) SWIG_fail;
54797 }
54798 resultobj = SWIG_Py_Void();
54799 return resultobj;
54800 fail:
54801 return NULL;
54802 }
54803
54804
54805 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54806 PyObject *resultobj = 0;
54807 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
54808 PyObject *result = 0 ;
54809 void *argp1 = 0 ;
54810 int res1 = 0 ;
54811 PyObject *swig_obj[1] ;
54812
54813 if (!args) SWIG_fail;
54814 swig_obj[0] = args;
54815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
54816 if (!SWIG_IsOK(res1)) {
54817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
54818 }
54819 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
54820 {
54821 PyThreadState* __tstate = wxPyBeginAllowThreads();
54822 result = (PyObject *)wxGBPosition_Get(arg1);
54823 wxPyEndAllowThreads(__tstate);
54824 if (PyErr_Occurred()) SWIG_fail;
54825 }
54826 resultobj = result;
54827 return resultobj;
54828 fail:
54829 return NULL;
54830 }
54831
54832
54833 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54834 PyObject *obj;
54835 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54836 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
54837 return SWIG_Py_Void();
54838 }
54839
54840 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54841 return SWIG_Python_InitShadowInstance(args);
54842 }
54843
54844 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54845 PyObject *resultobj = 0;
54846 int arg1 = (int) 1 ;
54847 int arg2 = (int) 1 ;
54848 wxGBSpan *result = 0 ;
54849 int val1 ;
54850 int ecode1 = 0 ;
54851 int val2 ;
54852 int ecode2 = 0 ;
54853 PyObject * obj0 = 0 ;
54854 PyObject * obj1 = 0 ;
54855 char * kwnames[] = {
54856 (char *) "rowspan",(char *) "colspan", NULL
54857 };
54858
54859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
54860 if (obj0) {
54861 ecode1 = SWIG_AsVal_int(obj0, &val1);
54862 if (!SWIG_IsOK(ecode1)) {
54863 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
54864 }
54865 arg1 = static_cast< int >(val1);
54866 }
54867 if (obj1) {
54868 ecode2 = SWIG_AsVal_int(obj1, &val2);
54869 if (!SWIG_IsOK(ecode2)) {
54870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
54871 }
54872 arg2 = static_cast< int >(val2);
54873 }
54874 {
54875 PyThreadState* __tstate = wxPyBeginAllowThreads();
54876 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
54877 wxPyEndAllowThreads(__tstate);
54878 if (PyErr_Occurred()) SWIG_fail;
54879 }
54880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
54881 return resultobj;
54882 fail:
54883 return NULL;
54884 }
54885
54886
54887 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54888 PyObject *resultobj = 0;
54889 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54890 void *argp1 = 0 ;
54891 int res1 = 0 ;
54892 PyObject *swig_obj[1] ;
54893
54894 if (!args) SWIG_fail;
54895 swig_obj[0] = args;
54896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
54897 if (!SWIG_IsOK(res1)) {
54898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54899 }
54900 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54901 {
54902 PyThreadState* __tstate = wxPyBeginAllowThreads();
54903 delete arg1;
54904
54905 wxPyEndAllowThreads(__tstate);
54906 if (PyErr_Occurred()) SWIG_fail;
54907 }
54908 resultobj = SWIG_Py_Void();
54909 return resultobj;
54910 fail:
54911 return NULL;
54912 }
54913
54914
54915 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54916 PyObject *resultobj = 0;
54917 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54918 int result;
54919 void *argp1 = 0 ;
54920 int res1 = 0 ;
54921 PyObject *swig_obj[1] ;
54922
54923 if (!args) SWIG_fail;
54924 swig_obj[0] = args;
54925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54926 if (!SWIG_IsOK(res1)) {
54927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54928 }
54929 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54930 {
54931 PyThreadState* __tstate = wxPyBeginAllowThreads();
54932 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
54933 wxPyEndAllowThreads(__tstate);
54934 if (PyErr_Occurred()) SWIG_fail;
54935 }
54936 resultobj = SWIG_From_int(static_cast< int >(result));
54937 return resultobj;
54938 fail:
54939 return NULL;
54940 }
54941
54942
54943 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54944 PyObject *resultobj = 0;
54945 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54946 int result;
54947 void *argp1 = 0 ;
54948 int res1 = 0 ;
54949 PyObject *swig_obj[1] ;
54950
54951 if (!args) SWIG_fail;
54952 swig_obj[0] = args;
54953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54954 if (!SWIG_IsOK(res1)) {
54955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
54956 }
54957 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54958 {
54959 PyThreadState* __tstate = wxPyBeginAllowThreads();
54960 result = (int)((wxGBSpan const *)arg1)->GetColspan();
54961 wxPyEndAllowThreads(__tstate);
54962 if (PyErr_Occurred()) SWIG_fail;
54963 }
54964 resultobj = SWIG_From_int(static_cast< int >(result));
54965 return resultobj;
54966 fail:
54967 return NULL;
54968 }
54969
54970
54971 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54972 PyObject *resultobj = 0;
54973 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
54974 int arg2 ;
54975 void *argp1 = 0 ;
54976 int res1 = 0 ;
54977 int val2 ;
54978 int ecode2 = 0 ;
54979 PyObject * obj0 = 0 ;
54980 PyObject * obj1 = 0 ;
54981 char * kwnames[] = {
54982 (char *) "self",(char *) "rowspan", NULL
54983 };
54984
54985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
54986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
54987 if (!SWIG_IsOK(res1)) {
54988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
54989 }
54990 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
54991 ecode2 = SWIG_AsVal_int(obj1, &val2);
54992 if (!SWIG_IsOK(ecode2)) {
54993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
54994 }
54995 arg2 = static_cast< int >(val2);
54996 {
54997 PyThreadState* __tstate = wxPyBeginAllowThreads();
54998 (arg1)->SetRowspan(arg2);
54999 wxPyEndAllowThreads(__tstate);
55000 if (PyErr_Occurred()) SWIG_fail;
55001 }
55002 resultobj = SWIG_Py_Void();
55003 return resultobj;
55004 fail:
55005 return NULL;
55006 }
55007
55008
55009 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55010 PyObject *resultobj = 0;
55011 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55012 int arg2 ;
55013 void *argp1 = 0 ;
55014 int res1 = 0 ;
55015 int val2 ;
55016 int ecode2 = 0 ;
55017 PyObject * obj0 = 0 ;
55018 PyObject * obj1 = 0 ;
55019 char * kwnames[] = {
55020 (char *) "self",(char *) "colspan", NULL
55021 };
55022
55023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
55024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55025 if (!SWIG_IsOK(res1)) {
55026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55027 }
55028 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55029 ecode2 = SWIG_AsVal_int(obj1, &val2);
55030 if (!SWIG_IsOK(ecode2)) {
55031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
55032 }
55033 arg2 = static_cast< int >(val2);
55034 {
55035 PyThreadState* __tstate = wxPyBeginAllowThreads();
55036 (arg1)->SetColspan(arg2);
55037 wxPyEndAllowThreads(__tstate);
55038 if (PyErr_Occurred()) SWIG_fail;
55039 }
55040 resultobj = SWIG_Py_Void();
55041 return resultobj;
55042 fail:
55043 return NULL;
55044 }
55045
55046
55047 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55048 PyObject *resultobj = 0;
55049 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55050 PyObject *arg2 = (PyObject *) 0 ;
55051 bool result;
55052 void *argp1 = 0 ;
55053 int res1 = 0 ;
55054 PyObject * obj0 = 0 ;
55055 PyObject * obj1 = 0 ;
55056 char * kwnames[] = {
55057 (char *) "self",(char *) "other", NULL
55058 };
55059
55060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
55061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55062 if (!SWIG_IsOK(res1)) {
55063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55064 }
55065 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55066 arg2 = obj1;
55067 {
55068 result = (bool)wxGBSpan___eq__(arg1,arg2);
55069 if (PyErr_Occurred()) SWIG_fail;
55070 }
55071 {
55072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55073 }
55074 return resultobj;
55075 fail:
55076 return NULL;
55077 }
55078
55079
55080 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55081 PyObject *resultobj = 0;
55082 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55083 PyObject *arg2 = (PyObject *) 0 ;
55084 bool result;
55085 void *argp1 = 0 ;
55086 int res1 = 0 ;
55087 PyObject * obj0 = 0 ;
55088 PyObject * obj1 = 0 ;
55089 char * kwnames[] = {
55090 (char *) "self",(char *) "other", NULL
55091 };
55092
55093 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
55094 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55095 if (!SWIG_IsOK(res1)) {
55096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55097 }
55098 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55099 arg2 = obj1;
55100 {
55101 result = (bool)wxGBSpan___ne__(arg1,arg2);
55102 if (PyErr_Occurred()) SWIG_fail;
55103 }
55104 {
55105 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55106 }
55107 return resultobj;
55108 fail:
55109 return NULL;
55110 }
55111
55112
55113 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55114 PyObject *resultobj = 0;
55115 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55116 int arg2 = (int) 1 ;
55117 int arg3 = (int) 1 ;
55118 void *argp1 = 0 ;
55119 int res1 = 0 ;
55120 int val2 ;
55121 int ecode2 = 0 ;
55122 int val3 ;
55123 int ecode3 = 0 ;
55124 PyObject * obj0 = 0 ;
55125 PyObject * obj1 = 0 ;
55126 PyObject * obj2 = 0 ;
55127 char * kwnames[] = {
55128 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
55129 };
55130
55131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55133 if (!SWIG_IsOK(res1)) {
55134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55135 }
55136 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55137 if (obj1) {
55138 ecode2 = SWIG_AsVal_int(obj1, &val2);
55139 if (!SWIG_IsOK(ecode2)) {
55140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
55141 }
55142 arg2 = static_cast< int >(val2);
55143 }
55144 if (obj2) {
55145 ecode3 = SWIG_AsVal_int(obj2, &val3);
55146 if (!SWIG_IsOK(ecode3)) {
55147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
55148 }
55149 arg3 = static_cast< int >(val3);
55150 }
55151 {
55152 PyThreadState* __tstate = wxPyBeginAllowThreads();
55153 wxGBSpan_Set(arg1,arg2,arg3);
55154 wxPyEndAllowThreads(__tstate);
55155 if (PyErr_Occurred()) SWIG_fail;
55156 }
55157 resultobj = SWIG_Py_Void();
55158 return resultobj;
55159 fail:
55160 return NULL;
55161 }
55162
55163
55164 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55165 PyObject *resultobj = 0;
55166 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
55167 PyObject *result = 0 ;
55168 void *argp1 = 0 ;
55169 int res1 = 0 ;
55170 PyObject *swig_obj[1] ;
55171
55172 if (!args) SWIG_fail;
55173 swig_obj[0] = args;
55174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
55175 if (!SWIG_IsOK(res1)) {
55176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
55177 }
55178 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
55179 {
55180 PyThreadState* __tstate = wxPyBeginAllowThreads();
55181 result = (PyObject *)wxGBSpan_Get(arg1);
55182 wxPyEndAllowThreads(__tstate);
55183 if (PyErr_Occurred()) SWIG_fail;
55184 }
55185 resultobj = result;
55186 return resultobj;
55187 fail:
55188 return NULL;
55189 }
55190
55191
55192 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55193 PyObject *obj;
55194 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55195 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
55196 return SWIG_Py_Void();
55197 }
55198
55199 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55200 return SWIG_Python_InitShadowInstance(args);
55201 }
55202
55203 SWIGINTERN int DefaultSpan_set(PyObject *) {
55204 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
55205 return 1;
55206 }
55207
55208
55209 SWIGINTERN PyObject *DefaultSpan_get(void) {
55210 PyObject *pyobj = 0;
55211
55212 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
55213 return pyobj;
55214 }
55215
55216
55217 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55218 PyObject *resultobj = 0;
55219 wxGBSizerItem *result = 0 ;
55220
55221 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
55222 {
55223 PyThreadState* __tstate = wxPyBeginAllowThreads();
55224 result = (wxGBSizerItem *)new wxGBSizerItem();
55225 wxPyEndAllowThreads(__tstate);
55226 if (PyErr_Occurred()) SWIG_fail;
55227 }
55228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
55229 return resultobj;
55230 fail:
55231 return NULL;
55232 }
55233
55234
55235 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55236 PyObject *resultobj = 0;
55237 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55238 void *argp1 = 0 ;
55239 int res1 = 0 ;
55240 PyObject *swig_obj[1] ;
55241
55242 if (!args) SWIG_fail;
55243 swig_obj[0] = args;
55244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55245 if (!SWIG_IsOK(res1)) {
55246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55247 }
55248 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55249 {
55250 PyThreadState* __tstate = wxPyBeginAllowThreads();
55251 delete arg1;
55252
55253 wxPyEndAllowThreads(__tstate);
55254 if (PyErr_Occurred()) SWIG_fail;
55255 }
55256 resultobj = SWIG_Py_Void();
55257 return resultobj;
55258 fail:
55259 return NULL;
55260 }
55261
55262
55263 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55264 PyObject *resultobj = 0;
55265 wxWindow *arg1 = (wxWindow *) 0 ;
55266 wxGBPosition *arg2 = 0 ;
55267 wxGBSpan *arg3 = 0 ;
55268 int arg4 ;
55269 int arg5 ;
55270 PyObject *arg6 = (PyObject *) NULL ;
55271 wxGBSizerItem *result = 0 ;
55272 void *argp1 = 0 ;
55273 int res1 = 0 ;
55274 wxGBPosition temp2 ;
55275 wxGBSpan temp3 ;
55276 int val4 ;
55277 int ecode4 = 0 ;
55278 int val5 ;
55279 int ecode5 = 0 ;
55280 PyObject * obj0 = 0 ;
55281 PyObject * obj1 = 0 ;
55282 PyObject * obj2 = 0 ;
55283 PyObject * obj3 = 0 ;
55284 PyObject * obj4 = 0 ;
55285 PyObject * obj5 = 0 ;
55286 char * kwnames[] = {
55287 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55288 };
55289
55290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
55292 if (!SWIG_IsOK(res1)) {
55293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
55294 }
55295 arg1 = reinterpret_cast< wxWindow * >(argp1);
55296 {
55297 arg2 = &temp2;
55298 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55299 }
55300 {
55301 arg3 = &temp3;
55302 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55303 }
55304 ecode4 = SWIG_AsVal_int(obj3, &val4);
55305 if (!SWIG_IsOK(ecode4)) {
55306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
55307 }
55308 arg4 = static_cast< int >(val4);
55309 ecode5 = SWIG_AsVal_int(obj4, &val5);
55310 if (!SWIG_IsOK(ecode5)) {
55311 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
55312 }
55313 arg5 = static_cast< int >(val5);
55314 if (obj5) {
55315 arg6 = obj5;
55316 }
55317 {
55318 PyThreadState* __tstate = wxPyBeginAllowThreads();
55319 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55320 wxPyEndAllowThreads(__tstate);
55321 if (PyErr_Occurred()) SWIG_fail;
55322 }
55323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55324 return resultobj;
55325 fail:
55326 return NULL;
55327 }
55328
55329
55330 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55331 PyObject *resultobj = 0;
55332 wxSizer *arg1 = (wxSizer *) 0 ;
55333 wxGBPosition *arg2 = 0 ;
55334 wxGBSpan *arg3 = 0 ;
55335 int arg4 ;
55336 int arg5 ;
55337 PyObject *arg6 = (PyObject *) NULL ;
55338 wxGBSizerItem *result = 0 ;
55339 int res1 = 0 ;
55340 wxGBPosition temp2 ;
55341 wxGBSpan temp3 ;
55342 int val4 ;
55343 int ecode4 = 0 ;
55344 int val5 ;
55345 int ecode5 = 0 ;
55346 PyObject * obj0 = 0 ;
55347 PyObject * obj1 = 0 ;
55348 PyObject * obj2 = 0 ;
55349 PyObject * obj3 = 0 ;
55350 PyObject * obj4 = 0 ;
55351 PyObject * obj5 = 0 ;
55352 char * kwnames[] = {
55353 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55354 };
55355
55356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55357 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
55358 if (!SWIG_IsOK(res1)) {
55359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
55360 }
55361 {
55362 arg2 = &temp2;
55363 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55364 }
55365 {
55366 arg3 = &temp3;
55367 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55368 }
55369 ecode4 = SWIG_AsVal_int(obj3, &val4);
55370 if (!SWIG_IsOK(ecode4)) {
55371 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
55372 }
55373 arg4 = static_cast< int >(val4);
55374 ecode5 = SWIG_AsVal_int(obj4, &val5);
55375 if (!SWIG_IsOK(ecode5)) {
55376 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
55377 }
55378 arg5 = static_cast< int >(val5);
55379 if (obj5) {
55380 arg6 = obj5;
55381 }
55382 {
55383 PyThreadState* __tstate = wxPyBeginAllowThreads();
55384 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
55385 wxPyEndAllowThreads(__tstate);
55386 if (PyErr_Occurred()) SWIG_fail;
55387 }
55388 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55389 return resultobj;
55390 fail:
55391 return NULL;
55392 }
55393
55394
55395 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55396 PyObject *resultobj = 0;
55397 int arg1 ;
55398 int arg2 ;
55399 wxGBPosition *arg3 = 0 ;
55400 wxGBSpan *arg4 = 0 ;
55401 int arg5 ;
55402 int arg6 ;
55403 PyObject *arg7 = (PyObject *) NULL ;
55404 wxGBSizerItem *result = 0 ;
55405 int val1 ;
55406 int ecode1 = 0 ;
55407 int val2 ;
55408 int ecode2 = 0 ;
55409 wxGBPosition temp3 ;
55410 wxGBSpan temp4 ;
55411 int val5 ;
55412 int ecode5 = 0 ;
55413 int val6 ;
55414 int ecode6 = 0 ;
55415 PyObject * obj0 = 0 ;
55416 PyObject * obj1 = 0 ;
55417 PyObject * obj2 = 0 ;
55418 PyObject * obj3 = 0 ;
55419 PyObject * obj4 = 0 ;
55420 PyObject * obj5 = 0 ;
55421 PyObject * obj6 = 0 ;
55422 char * kwnames[] = {
55423 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55424 };
55425
55426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55427 ecode1 = SWIG_AsVal_int(obj0, &val1);
55428 if (!SWIG_IsOK(ecode1)) {
55429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
55430 }
55431 arg1 = static_cast< int >(val1);
55432 ecode2 = SWIG_AsVal_int(obj1, &val2);
55433 if (!SWIG_IsOK(ecode2)) {
55434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
55435 }
55436 arg2 = static_cast< int >(val2);
55437 {
55438 arg3 = &temp3;
55439 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55440 }
55441 {
55442 arg4 = &temp4;
55443 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55444 }
55445 ecode5 = SWIG_AsVal_int(obj4, &val5);
55446 if (!SWIG_IsOK(ecode5)) {
55447 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
55448 }
55449 arg5 = static_cast< int >(val5);
55450 ecode6 = SWIG_AsVal_int(obj5, &val6);
55451 if (!SWIG_IsOK(ecode6)) {
55452 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
55453 }
55454 arg6 = static_cast< int >(val6);
55455 if (obj6) {
55456 arg7 = obj6;
55457 }
55458 {
55459 PyThreadState* __tstate = wxPyBeginAllowThreads();
55460 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55461 wxPyEndAllowThreads(__tstate);
55462 if (PyErr_Occurred()) SWIG_fail;
55463 }
55464 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
55465 return resultobj;
55466 fail:
55467 return NULL;
55468 }
55469
55470
55471 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55472 PyObject *resultobj = 0;
55473 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55474 wxGBPosition result;
55475 void *argp1 = 0 ;
55476 int res1 = 0 ;
55477 PyObject *swig_obj[1] ;
55478
55479 if (!args) SWIG_fail;
55480 swig_obj[0] = args;
55481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55482 if (!SWIG_IsOK(res1)) {
55483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55484 }
55485 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55486 {
55487 PyThreadState* __tstate = wxPyBeginAllowThreads();
55488 result = ((wxGBSizerItem const *)arg1)->GetPos();
55489 wxPyEndAllowThreads(__tstate);
55490 if (PyErr_Occurred()) SWIG_fail;
55491 }
55492 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55493 return resultobj;
55494 fail:
55495 return NULL;
55496 }
55497
55498
55499 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55500 PyObject *resultobj = 0;
55501 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55502 wxGBSpan result;
55503 void *argp1 = 0 ;
55504 int res1 = 0 ;
55505 PyObject *swig_obj[1] ;
55506
55507 if (!args) SWIG_fail;
55508 swig_obj[0] = args;
55509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55510 if (!SWIG_IsOK(res1)) {
55511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55512 }
55513 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55514 {
55515 PyThreadState* __tstate = wxPyBeginAllowThreads();
55516 result = ((wxGBSizerItem const *)arg1)->GetSpan();
55517 wxPyEndAllowThreads(__tstate);
55518 if (PyErr_Occurred()) SWIG_fail;
55519 }
55520 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
55521 return resultobj;
55522 fail:
55523 return NULL;
55524 }
55525
55526
55527 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55528 PyObject *resultobj = 0;
55529 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55530 wxGBPosition *arg2 = 0 ;
55531 bool result;
55532 void *argp1 = 0 ;
55533 int res1 = 0 ;
55534 wxGBPosition temp2 ;
55535 PyObject * obj0 = 0 ;
55536 PyObject * obj1 = 0 ;
55537 char * kwnames[] = {
55538 (char *) "self",(char *) "pos", NULL
55539 };
55540
55541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
55542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55543 if (!SWIG_IsOK(res1)) {
55544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55545 }
55546 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55547 {
55548 arg2 = &temp2;
55549 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55550 }
55551 {
55552 PyThreadState* __tstate = wxPyBeginAllowThreads();
55553 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
55554 wxPyEndAllowThreads(__tstate);
55555 if (PyErr_Occurred()) SWIG_fail;
55556 }
55557 {
55558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55559 }
55560 return resultobj;
55561 fail:
55562 return NULL;
55563 }
55564
55565
55566 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55567 PyObject *resultobj = 0;
55568 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55569 wxGBSpan *arg2 = 0 ;
55570 bool result;
55571 void *argp1 = 0 ;
55572 int res1 = 0 ;
55573 wxGBSpan temp2 ;
55574 PyObject * obj0 = 0 ;
55575 PyObject * obj1 = 0 ;
55576 char * kwnames[] = {
55577 (char *) "self",(char *) "span", NULL
55578 };
55579
55580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
55581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55582 if (!SWIG_IsOK(res1)) {
55583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55584 }
55585 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55586 {
55587 arg2 = &temp2;
55588 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
55589 }
55590 {
55591 PyThreadState* __tstate = wxPyBeginAllowThreads();
55592 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
55593 wxPyEndAllowThreads(__tstate);
55594 if (PyErr_Occurred()) SWIG_fail;
55595 }
55596 {
55597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55598 }
55599 return resultobj;
55600 fail:
55601 return NULL;
55602 }
55603
55604
55605 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55606 PyObject *resultobj = 0;
55607 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55608 wxGBSizerItem *arg2 = 0 ;
55609 bool result;
55610 void *argp1 = 0 ;
55611 int res1 = 0 ;
55612 void *argp2 = 0 ;
55613 int res2 = 0 ;
55614 PyObject * obj0 = 0 ;
55615 PyObject * obj1 = 0 ;
55616 char * kwnames[] = {
55617 (char *) "self",(char *) "other", NULL
55618 };
55619
55620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
55621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55622 if (!SWIG_IsOK(res1)) {
55623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55624 }
55625 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55626 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
55627 if (!SWIG_IsOK(res2)) {
55628 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55629 }
55630 if (!argp2) {
55631 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
55632 }
55633 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55634 {
55635 PyThreadState* __tstate = wxPyBeginAllowThreads();
55636 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
55637 wxPyEndAllowThreads(__tstate);
55638 if (PyErr_Occurred()) SWIG_fail;
55639 }
55640 {
55641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55642 }
55643 return resultobj;
55644 fail:
55645 return NULL;
55646 }
55647
55648
55649 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55650 PyObject *resultobj = 0;
55651 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55652 wxGBPosition *arg2 = 0 ;
55653 wxGBSpan *arg3 = 0 ;
55654 bool result;
55655 void *argp1 = 0 ;
55656 int res1 = 0 ;
55657 wxGBPosition temp2 ;
55658 wxGBSpan temp3 ;
55659 PyObject * obj0 = 0 ;
55660 PyObject * obj1 = 0 ;
55661 PyObject * obj2 = 0 ;
55662 char * kwnames[] = {
55663 (char *) "self",(char *) "pos",(char *) "span", NULL
55664 };
55665
55666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55668 if (!SWIG_IsOK(res1)) {
55669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55670 }
55671 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55672 {
55673 arg2 = &temp2;
55674 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55675 }
55676 {
55677 arg3 = &temp3;
55678 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55679 }
55680 {
55681 PyThreadState* __tstate = wxPyBeginAllowThreads();
55682 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
55683 wxPyEndAllowThreads(__tstate);
55684 if (PyErr_Occurred()) SWIG_fail;
55685 }
55686 {
55687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55688 }
55689 return resultobj;
55690 fail:
55691 return NULL;
55692 }
55693
55694
55695 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55696 PyObject *resultobj = 0;
55697 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55698 wxGBPosition result;
55699 void *argp1 = 0 ;
55700 int res1 = 0 ;
55701 PyObject *swig_obj[1] ;
55702
55703 if (!args) SWIG_fail;
55704 swig_obj[0] = args;
55705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55706 if (!SWIG_IsOK(res1)) {
55707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55708 }
55709 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55710 {
55711 PyThreadState* __tstate = wxPyBeginAllowThreads();
55712 result = wxGBSizerItem_GetEndPos(arg1);
55713 wxPyEndAllowThreads(__tstate);
55714 if (PyErr_Occurred()) SWIG_fail;
55715 }
55716 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
55717 return resultobj;
55718 fail:
55719 return NULL;
55720 }
55721
55722
55723 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55724 PyObject *resultobj = 0;
55725 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55726 wxGridBagSizer *result = 0 ;
55727 void *argp1 = 0 ;
55728 int res1 = 0 ;
55729 PyObject *swig_obj[1] ;
55730
55731 if (!args) SWIG_fail;
55732 swig_obj[0] = args;
55733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55734 if (!SWIG_IsOK(res1)) {
55735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
55736 }
55737 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55738 {
55739 PyThreadState* __tstate = wxPyBeginAllowThreads();
55740 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
55741 wxPyEndAllowThreads(__tstate);
55742 if (PyErr_Occurred()) SWIG_fail;
55743 }
55744 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55745 return resultobj;
55746 fail:
55747 return NULL;
55748 }
55749
55750
55751 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55752 PyObject *resultobj = 0;
55753 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
55754 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
55755 void *argp1 = 0 ;
55756 int res1 = 0 ;
55757 void *argp2 = 0 ;
55758 int res2 = 0 ;
55759 PyObject * obj0 = 0 ;
55760 PyObject * obj1 = 0 ;
55761 char * kwnames[] = {
55762 (char *) "self",(char *) "sizer", NULL
55763 };
55764
55765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55767 if (!SWIG_IsOK(res1)) {
55768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
55769 }
55770 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
55771 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55772 if (!SWIG_IsOK(res2)) {
55773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
55774 }
55775 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
55776 {
55777 PyThreadState* __tstate = wxPyBeginAllowThreads();
55778 (arg1)->SetGBSizer(arg2);
55779 wxPyEndAllowThreads(__tstate);
55780 if (PyErr_Occurred()) SWIG_fail;
55781 }
55782 resultobj = SWIG_Py_Void();
55783 return resultobj;
55784 fail:
55785 return NULL;
55786 }
55787
55788
55789 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55790 PyObject *obj;
55791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55792 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
55793 return SWIG_Py_Void();
55794 }
55795
55796 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55797 return SWIG_Python_InitShadowInstance(args);
55798 }
55799
55800 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55801 PyObject *resultobj = 0;
55802 int arg1 = (int) 0 ;
55803 int arg2 = (int) 0 ;
55804 wxGridBagSizer *result = 0 ;
55805 int val1 ;
55806 int ecode1 = 0 ;
55807 int val2 ;
55808 int ecode2 = 0 ;
55809 PyObject * obj0 = 0 ;
55810 PyObject * obj1 = 0 ;
55811 char * kwnames[] = {
55812 (char *) "vgap",(char *) "hgap", NULL
55813 };
55814
55815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
55816 if (obj0) {
55817 ecode1 = SWIG_AsVal_int(obj0, &val1);
55818 if (!SWIG_IsOK(ecode1)) {
55819 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
55820 }
55821 arg1 = static_cast< int >(val1);
55822 }
55823 if (obj1) {
55824 ecode2 = SWIG_AsVal_int(obj1, &val2);
55825 if (!SWIG_IsOK(ecode2)) {
55826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
55827 }
55828 arg2 = static_cast< int >(val2);
55829 }
55830 {
55831 PyThreadState* __tstate = wxPyBeginAllowThreads();
55832 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
55833 wxPyEndAllowThreads(__tstate);
55834 if (PyErr_Occurred()) SWIG_fail;
55835 }
55836 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
55837 return resultobj;
55838 fail:
55839 return NULL;
55840 }
55841
55842
55843 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55844 PyObject *resultobj = 0;
55845 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55846 PyObject *arg2 = (PyObject *) 0 ;
55847 wxGBPosition *arg3 = 0 ;
55848 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
55849 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
55850 int arg5 = (int) 0 ;
55851 int arg6 = (int) 0 ;
55852 PyObject *arg7 = (PyObject *) NULL ;
55853 wxGBSizerItem *result = 0 ;
55854 void *argp1 = 0 ;
55855 int res1 = 0 ;
55856 wxGBPosition temp3 ;
55857 wxGBSpan temp4 ;
55858 int val5 ;
55859 int ecode5 = 0 ;
55860 int val6 ;
55861 int ecode6 = 0 ;
55862 PyObject * obj0 = 0 ;
55863 PyObject * obj1 = 0 ;
55864 PyObject * obj2 = 0 ;
55865 PyObject * obj3 = 0 ;
55866 PyObject * obj4 = 0 ;
55867 PyObject * obj5 = 0 ;
55868 PyObject * obj6 = 0 ;
55869 char * kwnames[] = {
55870 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
55871 };
55872
55873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
55874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55875 if (!SWIG_IsOK(res1)) {
55876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55877 }
55878 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55879 arg2 = obj1;
55880 {
55881 arg3 = &temp3;
55882 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
55883 }
55884 if (obj3) {
55885 {
55886 arg4 = &temp4;
55887 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
55888 }
55889 }
55890 if (obj4) {
55891 ecode5 = SWIG_AsVal_int(obj4, &val5);
55892 if (!SWIG_IsOK(ecode5)) {
55893 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
55894 }
55895 arg5 = static_cast< int >(val5);
55896 }
55897 if (obj5) {
55898 ecode6 = SWIG_AsVal_int(obj5, &val6);
55899 if (!SWIG_IsOK(ecode6)) {
55900 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
55901 }
55902 arg6 = static_cast< int >(val6);
55903 }
55904 if (obj6) {
55905 arg7 = obj6;
55906 }
55907 {
55908 PyThreadState* __tstate = wxPyBeginAllowThreads();
55909 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
55910 wxPyEndAllowThreads(__tstate);
55911 if (PyErr_Occurred()) SWIG_fail;
55912 }
55913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55914 return resultobj;
55915 fail:
55916 return NULL;
55917 }
55918
55919
55920 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55921 PyObject *resultobj = 0;
55922 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55923 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55924 wxGBSizerItem *result = 0 ;
55925 void *argp1 = 0 ;
55926 int res1 = 0 ;
55927 int res2 = 0 ;
55928 PyObject * obj0 = 0 ;
55929 PyObject * obj1 = 0 ;
55930 char * kwnames[] = {
55931 (char *) "self",(char *) "item", NULL
55932 };
55933
55934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
55935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55936 if (!SWIG_IsOK(res1)) {
55937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55938 }
55939 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55940 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
55941 if (!SWIG_IsOK(res2)) {
55942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55943 }
55944 {
55945 PyThreadState* __tstate = wxPyBeginAllowThreads();
55946 result = (wxGBSizerItem *)(arg1)->Add(arg2);
55947 wxPyEndAllowThreads(__tstate);
55948 if (PyErr_Occurred()) SWIG_fail;
55949 }
55950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55951 return resultobj;
55952 fail:
55953 return NULL;
55954 }
55955
55956
55957 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55958 PyObject *resultobj = 0;
55959 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55960 int arg2 ;
55961 int arg3 ;
55962 wxSize result;
55963 void *argp1 = 0 ;
55964 int res1 = 0 ;
55965 int val2 ;
55966 int ecode2 = 0 ;
55967 int val3 ;
55968 int ecode3 = 0 ;
55969 PyObject * obj0 = 0 ;
55970 PyObject * obj1 = 0 ;
55971 PyObject * obj2 = 0 ;
55972 char * kwnames[] = {
55973 (char *) "self",(char *) "row",(char *) "col", NULL
55974 };
55975
55976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55978 if (!SWIG_IsOK(res1)) {
55979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
55980 }
55981 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55982 ecode2 = SWIG_AsVal_int(obj1, &val2);
55983 if (!SWIG_IsOK(ecode2)) {
55984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
55985 }
55986 arg2 = static_cast< int >(val2);
55987 ecode3 = SWIG_AsVal_int(obj2, &val3);
55988 if (!SWIG_IsOK(ecode3)) {
55989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
55990 }
55991 arg3 = static_cast< int >(val3);
55992 {
55993 PyThreadState* __tstate = wxPyBeginAllowThreads();
55994 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
55995 wxPyEndAllowThreads(__tstate);
55996 if (PyErr_Occurred()) SWIG_fail;
55997 }
55998 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
55999 return resultobj;
56000 fail:
56001 return NULL;
56002 }
56003
56004
56005 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56006 PyObject *resultobj = 0;
56007 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56008 wxSize result;
56009 void *argp1 = 0 ;
56010 int res1 = 0 ;
56011 PyObject *swig_obj[1] ;
56012
56013 if (!args) SWIG_fail;
56014 swig_obj[0] = args;
56015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56016 if (!SWIG_IsOK(res1)) {
56017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
56018 }
56019 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56020 {
56021 PyThreadState* __tstate = wxPyBeginAllowThreads();
56022 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
56023 wxPyEndAllowThreads(__tstate);
56024 if (PyErr_Occurred()) SWIG_fail;
56025 }
56026 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
56027 return resultobj;
56028 fail:
56029 return NULL;
56030 }
56031
56032
56033 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56034 PyObject *resultobj = 0;
56035 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56036 wxSize *arg2 = 0 ;
56037 void *argp1 = 0 ;
56038 int res1 = 0 ;
56039 wxSize temp2 ;
56040 PyObject * obj0 = 0 ;
56041 PyObject * obj1 = 0 ;
56042 char * kwnames[] = {
56043 (char *) "self",(char *) "sz", NULL
56044 };
56045
56046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
56047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56048 if (!SWIG_IsOK(res1)) {
56049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56050 }
56051 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56052 {
56053 arg2 = &temp2;
56054 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
56055 }
56056 {
56057 PyThreadState* __tstate = wxPyBeginAllowThreads();
56058 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
56059 wxPyEndAllowThreads(__tstate);
56060 if (PyErr_Occurred()) SWIG_fail;
56061 }
56062 resultobj = SWIG_Py_Void();
56063 return resultobj;
56064 fail:
56065 return NULL;
56066 }
56067
56068
56069 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56070 PyObject *resultobj = 0;
56071 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56072 wxWindow *arg2 = (wxWindow *) 0 ;
56073 wxGBPosition result;
56074 void *argp1 = 0 ;
56075 int res1 = 0 ;
56076 void *argp2 = 0 ;
56077 int res2 = 0 ;
56078
56079 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56081 if (!SWIG_IsOK(res1)) {
56082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56083 }
56084 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56085 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56086 if (!SWIG_IsOK(res2)) {
56087 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56088 }
56089 arg2 = reinterpret_cast< wxWindow * >(argp2);
56090 {
56091 PyThreadState* __tstate = wxPyBeginAllowThreads();
56092 result = (arg1)->GetItemPosition(arg2);
56093 wxPyEndAllowThreads(__tstate);
56094 if (PyErr_Occurred()) SWIG_fail;
56095 }
56096 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56097 return resultobj;
56098 fail:
56099 return NULL;
56100 }
56101
56102
56103 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56104 PyObject *resultobj = 0;
56105 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56106 wxSizer *arg2 = (wxSizer *) 0 ;
56107 wxGBPosition result;
56108 void *argp1 = 0 ;
56109 int res1 = 0 ;
56110 void *argp2 = 0 ;
56111 int res2 = 0 ;
56112
56113 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56115 if (!SWIG_IsOK(res1)) {
56116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56117 }
56118 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56119 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56120 if (!SWIG_IsOK(res2)) {
56121 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56122 }
56123 arg2 = reinterpret_cast< wxSizer * >(argp2);
56124 {
56125 PyThreadState* __tstate = wxPyBeginAllowThreads();
56126 result = (arg1)->GetItemPosition(arg2);
56127 wxPyEndAllowThreads(__tstate);
56128 if (PyErr_Occurred()) SWIG_fail;
56129 }
56130 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56131 return resultobj;
56132 fail:
56133 return NULL;
56134 }
56135
56136
56137 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56138 PyObject *resultobj = 0;
56139 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56140 size_t arg2 ;
56141 wxGBPosition result;
56142 void *argp1 = 0 ;
56143 int res1 = 0 ;
56144 size_t val2 ;
56145 int ecode2 = 0 ;
56146
56147 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56149 if (!SWIG_IsOK(res1)) {
56150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56151 }
56152 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56153 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56154 if (!SWIG_IsOK(ecode2)) {
56155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56156 }
56157 arg2 = static_cast< size_t >(val2);
56158 {
56159 PyThreadState* __tstate = wxPyBeginAllowThreads();
56160 result = (arg1)->GetItemPosition(arg2);
56161 wxPyEndAllowThreads(__tstate);
56162 if (PyErr_Occurred()) SWIG_fail;
56163 }
56164 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
56165 return resultobj;
56166 fail:
56167 return NULL;
56168 }
56169
56170
56171 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
56172 int argc;
56173 PyObject *argv[3];
56174
56175 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
56176 --argc;
56177 if (argc == 2) {
56178 int _v = 0;
56179 {
56180 void *vptr = 0;
56181 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56182 _v = SWIG_CheckState(res);
56183 }
56184 if (!_v) goto check_1;
56185 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
56186 }
56187 check_1:
56188
56189 if (argc == 2) {
56190 int _v = 0;
56191 {
56192 void *vptr = 0;
56193 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56194 _v = SWIG_CheckState(res);
56195 }
56196 if (!_v) goto check_2;
56197 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
56198 }
56199 check_2:
56200
56201 if (argc == 2) {
56202 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
56203 }
56204
56205 fail:
56206 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
56207 return NULL;
56208 }
56209
56210
56211 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56212 PyObject *resultobj = 0;
56213 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56214 wxWindow *arg2 = (wxWindow *) 0 ;
56215 wxGBPosition *arg3 = 0 ;
56216 bool result;
56217 void *argp1 = 0 ;
56218 int res1 = 0 ;
56219 void *argp2 = 0 ;
56220 int res2 = 0 ;
56221 wxGBPosition temp3 ;
56222
56223 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56225 if (!SWIG_IsOK(res1)) {
56226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56227 }
56228 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56229 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56230 if (!SWIG_IsOK(res2)) {
56231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
56232 }
56233 arg2 = reinterpret_cast< wxWindow * >(argp2);
56234 {
56235 arg3 = &temp3;
56236 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56237 }
56238 {
56239 PyThreadState* __tstate = wxPyBeginAllowThreads();
56240 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56241 wxPyEndAllowThreads(__tstate);
56242 if (PyErr_Occurred()) SWIG_fail;
56243 }
56244 {
56245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56246 }
56247 return resultobj;
56248 fail:
56249 return NULL;
56250 }
56251
56252
56253 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56254 PyObject *resultobj = 0;
56255 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56256 wxSizer *arg2 = (wxSizer *) 0 ;
56257 wxGBPosition *arg3 = 0 ;
56258 bool result;
56259 void *argp1 = 0 ;
56260 int res1 = 0 ;
56261 void *argp2 = 0 ;
56262 int res2 = 0 ;
56263 wxGBPosition temp3 ;
56264
56265 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56267 if (!SWIG_IsOK(res1)) {
56268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56269 }
56270 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56271 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56272 if (!SWIG_IsOK(res2)) {
56273 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
56274 }
56275 arg2 = reinterpret_cast< wxSizer * >(argp2);
56276 {
56277 arg3 = &temp3;
56278 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56279 }
56280 {
56281 PyThreadState* __tstate = wxPyBeginAllowThreads();
56282 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56283 wxPyEndAllowThreads(__tstate);
56284 if (PyErr_Occurred()) SWIG_fail;
56285 }
56286 {
56287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56288 }
56289 return resultobj;
56290 fail:
56291 return NULL;
56292 }
56293
56294
56295 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56296 PyObject *resultobj = 0;
56297 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56298 size_t arg2 ;
56299 wxGBPosition *arg3 = 0 ;
56300 bool result;
56301 void *argp1 = 0 ;
56302 int res1 = 0 ;
56303 size_t val2 ;
56304 int ecode2 = 0 ;
56305 wxGBPosition temp3 ;
56306
56307 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56309 if (!SWIG_IsOK(res1)) {
56310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56311 }
56312 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56313 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56314 if (!SWIG_IsOK(ecode2)) {
56315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
56316 }
56317 arg2 = static_cast< size_t >(val2);
56318 {
56319 arg3 = &temp3;
56320 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
56321 }
56322 {
56323 PyThreadState* __tstate = wxPyBeginAllowThreads();
56324 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
56325 wxPyEndAllowThreads(__tstate);
56326 if (PyErr_Occurred()) SWIG_fail;
56327 }
56328 {
56329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56330 }
56331 return resultobj;
56332 fail:
56333 return NULL;
56334 }
56335
56336
56337 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
56338 int argc;
56339 PyObject *argv[4];
56340
56341 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
56342 --argc;
56343 if (argc == 3) {
56344 int _v = 0;
56345 {
56346 void *vptr = 0;
56347 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56348 _v = SWIG_CheckState(res);
56349 }
56350 if (!_v) goto check_1;
56351 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
56352 }
56353 check_1:
56354
56355 if (argc == 3) {
56356 int _v = 0;
56357 {
56358 void *vptr = 0;
56359 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56360 _v = SWIG_CheckState(res);
56361 }
56362 if (!_v) goto check_2;
56363 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
56364 }
56365 check_2:
56366
56367 if (argc == 3) {
56368 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
56369 }
56370
56371 fail:
56372 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
56373 return NULL;
56374 }
56375
56376
56377 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56378 PyObject *resultobj = 0;
56379 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56380 wxWindow *arg2 = (wxWindow *) 0 ;
56381 wxGBSpan result;
56382 void *argp1 = 0 ;
56383 int res1 = 0 ;
56384 void *argp2 = 0 ;
56385 int res2 = 0 ;
56386
56387 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56389 if (!SWIG_IsOK(res1)) {
56390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56391 }
56392 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56393 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56394 if (!SWIG_IsOK(res2)) {
56395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56396 }
56397 arg2 = reinterpret_cast< wxWindow * >(argp2);
56398 {
56399 PyThreadState* __tstate = wxPyBeginAllowThreads();
56400 result = (arg1)->GetItemSpan(arg2);
56401 wxPyEndAllowThreads(__tstate);
56402 if (PyErr_Occurred()) SWIG_fail;
56403 }
56404 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56405 return resultobj;
56406 fail:
56407 return NULL;
56408 }
56409
56410
56411 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56412 PyObject *resultobj = 0;
56413 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56414 wxSizer *arg2 = (wxSizer *) 0 ;
56415 wxGBSpan result;
56416 void *argp1 = 0 ;
56417 int res1 = 0 ;
56418 void *argp2 = 0 ;
56419 int res2 = 0 ;
56420
56421 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56423 if (!SWIG_IsOK(res1)) {
56424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56425 }
56426 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56427 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56428 if (!SWIG_IsOK(res2)) {
56429 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56430 }
56431 arg2 = reinterpret_cast< wxSizer * >(argp2);
56432 {
56433 PyThreadState* __tstate = wxPyBeginAllowThreads();
56434 result = (arg1)->GetItemSpan(arg2);
56435 wxPyEndAllowThreads(__tstate);
56436 if (PyErr_Occurred()) SWIG_fail;
56437 }
56438 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56439 return resultobj;
56440 fail:
56441 return NULL;
56442 }
56443
56444
56445 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56446 PyObject *resultobj = 0;
56447 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56448 size_t arg2 ;
56449 wxGBSpan result;
56450 void *argp1 = 0 ;
56451 int res1 = 0 ;
56452 size_t val2 ;
56453 int ecode2 = 0 ;
56454
56455 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56457 if (!SWIG_IsOK(res1)) {
56458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56459 }
56460 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56461 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56462 if (!SWIG_IsOK(ecode2)) {
56463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56464 }
56465 arg2 = static_cast< size_t >(val2);
56466 {
56467 PyThreadState* __tstate = wxPyBeginAllowThreads();
56468 result = (arg1)->GetItemSpan(arg2);
56469 wxPyEndAllowThreads(__tstate);
56470 if (PyErr_Occurred()) SWIG_fail;
56471 }
56472 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
56473 return resultobj;
56474 fail:
56475 return NULL;
56476 }
56477
56478
56479 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
56480 int argc;
56481 PyObject *argv[3];
56482
56483 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
56484 --argc;
56485 if (argc == 2) {
56486 int _v = 0;
56487 {
56488 void *vptr = 0;
56489 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56490 _v = SWIG_CheckState(res);
56491 }
56492 if (!_v) goto check_1;
56493 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
56494 }
56495 check_1:
56496
56497 if (argc == 2) {
56498 int _v = 0;
56499 {
56500 void *vptr = 0;
56501 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56502 _v = SWIG_CheckState(res);
56503 }
56504 if (!_v) goto check_2;
56505 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
56506 }
56507 check_2:
56508
56509 if (argc == 2) {
56510 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
56511 }
56512
56513 fail:
56514 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
56515 return NULL;
56516 }
56517
56518
56519 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56520 PyObject *resultobj = 0;
56521 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56522 wxWindow *arg2 = (wxWindow *) 0 ;
56523 wxGBSpan *arg3 = 0 ;
56524 bool result;
56525 void *argp1 = 0 ;
56526 int res1 = 0 ;
56527 void *argp2 = 0 ;
56528 int res2 = 0 ;
56529 wxGBSpan temp3 ;
56530
56531 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56533 if (!SWIG_IsOK(res1)) {
56534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56535 }
56536 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56537 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56538 if (!SWIG_IsOK(res2)) {
56539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
56540 }
56541 arg2 = reinterpret_cast< wxWindow * >(argp2);
56542 {
56543 arg3 = &temp3;
56544 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56545 }
56546 {
56547 PyThreadState* __tstate = wxPyBeginAllowThreads();
56548 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56549 wxPyEndAllowThreads(__tstate);
56550 if (PyErr_Occurred()) SWIG_fail;
56551 }
56552 {
56553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56554 }
56555 return resultobj;
56556 fail:
56557 return NULL;
56558 }
56559
56560
56561 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56562 PyObject *resultobj = 0;
56563 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56564 wxSizer *arg2 = (wxSizer *) 0 ;
56565 wxGBSpan *arg3 = 0 ;
56566 bool result;
56567 void *argp1 = 0 ;
56568 int res1 = 0 ;
56569 void *argp2 = 0 ;
56570 int res2 = 0 ;
56571 wxGBSpan temp3 ;
56572
56573 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56575 if (!SWIG_IsOK(res1)) {
56576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56577 }
56578 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56579 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56580 if (!SWIG_IsOK(res2)) {
56581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
56582 }
56583 arg2 = reinterpret_cast< wxSizer * >(argp2);
56584 {
56585 arg3 = &temp3;
56586 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56587 }
56588 {
56589 PyThreadState* __tstate = wxPyBeginAllowThreads();
56590 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56591 wxPyEndAllowThreads(__tstate);
56592 if (PyErr_Occurred()) SWIG_fail;
56593 }
56594 {
56595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56596 }
56597 return resultobj;
56598 fail:
56599 return NULL;
56600 }
56601
56602
56603 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56604 PyObject *resultobj = 0;
56605 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56606 size_t arg2 ;
56607 wxGBSpan *arg3 = 0 ;
56608 bool result;
56609 void *argp1 = 0 ;
56610 int res1 = 0 ;
56611 size_t val2 ;
56612 int ecode2 = 0 ;
56613 wxGBSpan temp3 ;
56614
56615 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
56616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56617 if (!SWIG_IsOK(res1)) {
56618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56619 }
56620 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56621 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
56622 if (!SWIG_IsOK(ecode2)) {
56623 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
56624 }
56625 arg2 = static_cast< size_t >(val2);
56626 {
56627 arg3 = &temp3;
56628 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
56629 }
56630 {
56631 PyThreadState* __tstate = wxPyBeginAllowThreads();
56632 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
56633 wxPyEndAllowThreads(__tstate);
56634 if (PyErr_Occurred()) SWIG_fail;
56635 }
56636 {
56637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56638 }
56639 return resultobj;
56640 fail:
56641 return NULL;
56642 }
56643
56644
56645 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
56646 int argc;
56647 PyObject *argv[4];
56648
56649 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
56650 --argc;
56651 if (argc == 3) {
56652 int _v = 0;
56653 {
56654 void *vptr = 0;
56655 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56656 _v = SWIG_CheckState(res);
56657 }
56658 if (!_v) goto check_1;
56659 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
56660 }
56661 check_1:
56662
56663 if (argc == 3) {
56664 int _v = 0;
56665 {
56666 void *vptr = 0;
56667 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
56668 _v = SWIG_CheckState(res);
56669 }
56670 if (!_v) goto check_2;
56671 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
56672 }
56673 check_2:
56674
56675 if (argc == 3) {
56676 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
56677 }
56678
56679 fail:
56680 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
56681 return NULL;
56682 }
56683
56684
56685 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56686 PyObject *resultobj = 0;
56687 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56688 wxWindow *arg2 = (wxWindow *) 0 ;
56689 wxGBSizerItem *result = 0 ;
56690 void *argp1 = 0 ;
56691 int res1 = 0 ;
56692 void *argp2 = 0 ;
56693 int res2 = 0 ;
56694
56695 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56697 if (!SWIG_IsOK(res1)) {
56698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56699 }
56700 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56701 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56702 if (!SWIG_IsOK(res2)) {
56703 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
56704 }
56705 arg2 = reinterpret_cast< wxWindow * >(argp2);
56706 {
56707 PyThreadState* __tstate = wxPyBeginAllowThreads();
56708 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56709 wxPyEndAllowThreads(__tstate);
56710 if (PyErr_Occurred()) SWIG_fail;
56711 }
56712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56713 return resultobj;
56714 fail:
56715 return NULL;
56716 }
56717
56718
56719 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
56720 PyObject *resultobj = 0;
56721 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56722 wxSizer *arg2 = (wxSizer *) 0 ;
56723 wxGBSizerItem *result = 0 ;
56724 void *argp1 = 0 ;
56725 int res1 = 0 ;
56726 void *argp2 = 0 ;
56727 int res2 = 0 ;
56728
56729 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
56730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56731 if (!SWIG_IsOK(res1)) {
56732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56733 }
56734 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56735 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
56736 if (!SWIG_IsOK(res2)) {
56737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
56738 }
56739 arg2 = reinterpret_cast< wxSizer * >(argp2);
56740 {
56741 PyThreadState* __tstate = wxPyBeginAllowThreads();
56742 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
56743 wxPyEndAllowThreads(__tstate);
56744 if (PyErr_Occurred()) SWIG_fail;
56745 }
56746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56747 return resultobj;
56748 fail:
56749 return NULL;
56750 }
56751
56752
56753 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
56754 int argc;
56755 PyObject *argv[3];
56756
56757 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
56758 --argc;
56759 if (argc == 2) {
56760 int _v = 0;
56761 {
56762 void *vptr = 0;
56763 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
56764 _v = SWIG_CheckState(res);
56765 }
56766 if (!_v) goto check_1;
56767 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
56768 }
56769 check_1:
56770
56771 if (argc == 2) {
56772 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
56773 }
56774
56775 fail:
56776 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
56777 return NULL;
56778 }
56779
56780
56781 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56782 PyObject *resultobj = 0;
56783 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56784 wxGBPosition *arg2 = 0 ;
56785 wxGBSizerItem *result = 0 ;
56786 void *argp1 = 0 ;
56787 int res1 = 0 ;
56788 wxGBPosition temp2 ;
56789 PyObject * obj0 = 0 ;
56790 PyObject * obj1 = 0 ;
56791 char * kwnames[] = {
56792 (char *) "self",(char *) "pos", NULL
56793 };
56794
56795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
56796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56797 if (!SWIG_IsOK(res1)) {
56798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56799 }
56800 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56801 {
56802 arg2 = &temp2;
56803 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56804 }
56805 {
56806 PyThreadState* __tstate = wxPyBeginAllowThreads();
56807 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
56808 wxPyEndAllowThreads(__tstate);
56809 if (PyErr_Occurred()) SWIG_fail;
56810 }
56811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56812 return resultobj;
56813 fail:
56814 return NULL;
56815 }
56816
56817
56818 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56819 PyObject *resultobj = 0;
56820 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56821 wxPoint *arg2 = 0 ;
56822 wxGBSizerItem *result = 0 ;
56823 void *argp1 = 0 ;
56824 int res1 = 0 ;
56825 wxPoint temp2 ;
56826 PyObject * obj0 = 0 ;
56827 PyObject * obj1 = 0 ;
56828 char * kwnames[] = {
56829 (char *) "self",(char *) "pt", NULL
56830 };
56831
56832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
56833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56834 if (!SWIG_IsOK(res1)) {
56835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56836 }
56837 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56838 {
56839 arg2 = &temp2;
56840 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
56841 }
56842 {
56843 PyThreadState* __tstate = wxPyBeginAllowThreads();
56844 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
56845 wxPyEndAllowThreads(__tstate);
56846 if (PyErr_Occurred()) SWIG_fail;
56847 }
56848 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56849 return resultobj;
56850 fail:
56851 return NULL;
56852 }
56853
56854
56855 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56856 PyObject *resultobj = 0;
56857 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56858 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
56859 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
56860 bool result;
56861 void *argp1 = 0 ;
56862 int res1 = 0 ;
56863 void *argp2 = 0 ;
56864 int res2 = 0 ;
56865 void *argp3 = 0 ;
56866 int res3 = 0 ;
56867 PyObject * obj0 = 0 ;
56868 PyObject * obj1 = 0 ;
56869 PyObject * obj2 = 0 ;
56870 char * kwnames[] = {
56871 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
56872 };
56873
56874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56876 if (!SWIG_IsOK(res1)) {
56877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56878 }
56879 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56880 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56881 if (!SWIG_IsOK(res2)) {
56882 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
56883 }
56884 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
56885 if (obj2) {
56886 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56887 if (!SWIG_IsOK(res3)) {
56888 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
56889 }
56890 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
56891 }
56892 {
56893 PyThreadState* __tstate = wxPyBeginAllowThreads();
56894 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
56895 wxPyEndAllowThreads(__tstate);
56896 if (PyErr_Occurred()) SWIG_fail;
56897 }
56898 {
56899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56900 }
56901 return resultobj;
56902 fail:
56903 return NULL;
56904 }
56905
56906
56907 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56908 PyObject *resultobj = 0;
56909 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
56910 wxGBPosition *arg2 = 0 ;
56911 wxGBSpan *arg3 = 0 ;
56912 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
56913 bool result;
56914 void *argp1 = 0 ;
56915 int res1 = 0 ;
56916 wxGBPosition temp2 ;
56917 wxGBSpan temp3 ;
56918 void *argp4 = 0 ;
56919 int res4 = 0 ;
56920 PyObject * obj0 = 0 ;
56921 PyObject * obj1 = 0 ;
56922 PyObject * obj2 = 0 ;
56923 PyObject * obj3 = 0 ;
56924 char * kwnames[] = {
56925 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
56926 };
56927
56928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
56930 if (!SWIG_IsOK(res1)) {
56931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
56932 }
56933 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
56934 {
56935 arg2 = &temp2;
56936 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
56937 }
56938 {
56939 arg3 = &temp3;
56940 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
56941 }
56942 if (obj3) {
56943 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
56944 if (!SWIG_IsOK(res4)) {
56945 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
56946 }
56947 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
56948 }
56949 {
56950 PyThreadState* __tstate = wxPyBeginAllowThreads();
56951 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
56952 wxPyEndAllowThreads(__tstate);
56953 if (PyErr_Occurred()) SWIG_fail;
56954 }
56955 {
56956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56957 }
56958 return resultobj;
56959 fail:
56960 return NULL;
56961 }
56962
56963
56964 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56965 PyObject *obj;
56966 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56967 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
56968 return SWIG_Py_Void();
56969 }
56970
56971 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56972 return SWIG_Python_InitShadowInstance(args);
56973 }
56974
56975 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56976 PyObject *resultobj = 0;
56977 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56978 wxRelationship arg2 ;
56979 wxWindow *arg3 = (wxWindow *) 0 ;
56980 wxEdge arg4 ;
56981 int arg5 = (int) 0 ;
56982 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
56983 void *argp1 = 0 ;
56984 int res1 = 0 ;
56985 int val2 ;
56986 int ecode2 = 0 ;
56987 void *argp3 = 0 ;
56988 int res3 = 0 ;
56989 int val4 ;
56990 int ecode4 = 0 ;
56991 int val5 ;
56992 int ecode5 = 0 ;
56993 int val6 ;
56994 int ecode6 = 0 ;
56995 PyObject * obj0 = 0 ;
56996 PyObject * obj1 = 0 ;
56997 PyObject * obj2 = 0 ;
56998 PyObject * obj3 = 0 ;
56999 PyObject * obj4 = 0 ;
57000 PyObject * obj5 = 0 ;
57001 char * kwnames[] = {
57002 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
57003 };
57004
57005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
57006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57007 if (!SWIG_IsOK(res1)) {
57008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57009 }
57010 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57011 ecode2 = SWIG_AsVal_int(obj1, &val2);
57012 if (!SWIG_IsOK(ecode2)) {
57013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
57014 }
57015 arg2 = static_cast< wxRelationship >(val2);
57016 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57017 if (!SWIG_IsOK(res3)) {
57018 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
57019 }
57020 arg3 = reinterpret_cast< wxWindow * >(argp3);
57021 ecode4 = SWIG_AsVal_int(obj3, &val4);
57022 if (!SWIG_IsOK(ecode4)) {
57023 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
57024 }
57025 arg4 = static_cast< wxEdge >(val4);
57026 if (obj4) {
57027 ecode5 = SWIG_AsVal_int(obj4, &val5);
57028 if (!SWIG_IsOK(ecode5)) {
57029 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
57030 }
57031 arg5 = static_cast< int >(val5);
57032 }
57033 if (obj5) {
57034 ecode6 = SWIG_AsVal_int(obj5, &val6);
57035 if (!SWIG_IsOK(ecode6)) {
57036 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
57037 }
57038 arg6 = static_cast< int >(val6);
57039 }
57040 {
57041 PyThreadState* __tstate = wxPyBeginAllowThreads();
57042 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
57043 wxPyEndAllowThreads(__tstate);
57044 if (PyErr_Occurred()) SWIG_fail;
57045 }
57046 resultobj = SWIG_Py_Void();
57047 return resultobj;
57048 fail:
57049 return NULL;
57050 }
57051
57052
57053 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57054 PyObject *resultobj = 0;
57055 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57056 wxWindow *arg2 = (wxWindow *) 0 ;
57057 int arg3 = (int) 0 ;
57058 void *argp1 = 0 ;
57059 int res1 = 0 ;
57060 void *argp2 = 0 ;
57061 int res2 = 0 ;
57062 int val3 ;
57063 int ecode3 = 0 ;
57064 PyObject * obj0 = 0 ;
57065 PyObject * obj1 = 0 ;
57066 PyObject * obj2 = 0 ;
57067 char * kwnames[] = {
57068 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57069 };
57070
57071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57073 if (!SWIG_IsOK(res1)) {
57074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57075 }
57076 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57077 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57078 if (!SWIG_IsOK(res2)) {
57079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57080 }
57081 arg2 = reinterpret_cast< wxWindow * >(argp2);
57082 if (obj2) {
57083 ecode3 = SWIG_AsVal_int(obj2, &val3);
57084 if (!SWIG_IsOK(ecode3)) {
57085 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
57086 }
57087 arg3 = static_cast< int >(val3);
57088 }
57089 {
57090 PyThreadState* __tstate = wxPyBeginAllowThreads();
57091 (arg1)->LeftOf(arg2,arg3);
57092 wxPyEndAllowThreads(__tstate);
57093 if (PyErr_Occurred()) SWIG_fail;
57094 }
57095 resultobj = SWIG_Py_Void();
57096 return resultobj;
57097 fail:
57098 return NULL;
57099 }
57100
57101
57102 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57103 PyObject *resultobj = 0;
57104 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57105 wxWindow *arg2 = (wxWindow *) 0 ;
57106 int arg3 = (int) 0 ;
57107 void *argp1 = 0 ;
57108 int res1 = 0 ;
57109 void *argp2 = 0 ;
57110 int res2 = 0 ;
57111 int val3 ;
57112 int ecode3 = 0 ;
57113 PyObject * obj0 = 0 ;
57114 PyObject * obj1 = 0 ;
57115 PyObject * obj2 = 0 ;
57116 char * kwnames[] = {
57117 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57118 };
57119
57120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57122 if (!SWIG_IsOK(res1)) {
57123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57124 }
57125 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57126 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57127 if (!SWIG_IsOK(res2)) {
57128 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57129 }
57130 arg2 = reinterpret_cast< wxWindow * >(argp2);
57131 if (obj2) {
57132 ecode3 = SWIG_AsVal_int(obj2, &val3);
57133 if (!SWIG_IsOK(ecode3)) {
57134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
57135 }
57136 arg3 = static_cast< int >(val3);
57137 }
57138 {
57139 PyThreadState* __tstate = wxPyBeginAllowThreads();
57140 (arg1)->RightOf(arg2,arg3);
57141 wxPyEndAllowThreads(__tstate);
57142 if (PyErr_Occurred()) SWIG_fail;
57143 }
57144 resultobj = SWIG_Py_Void();
57145 return resultobj;
57146 fail:
57147 return NULL;
57148 }
57149
57150
57151 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57152 PyObject *resultobj = 0;
57153 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57154 wxWindow *arg2 = (wxWindow *) 0 ;
57155 int arg3 = (int) 0 ;
57156 void *argp1 = 0 ;
57157 int res1 = 0 ;
57158 void *argp2 = 0 ;
57159 int res2 = 0 ;
57160 int val3 ;
57161 int ecode3 = 0 ;
57162 PyObject * obj0 = 0 ;
57163 PyObject * obj1 = 0 ;
57164 PyObject * obj2 = 0 ;
57165 char * kwnames[] = {
57166 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57167 };
57168
57169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57171 if (!SWIG_IsOK(res1)) {
57172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57173 }
57174 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57176 if (!SWIG_IsOK(res2)) {
57177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
57178 }
57179 arg2 = reinterpret_cast< wxWindow * >(argp2);
57180 if (obj2) {
57181 ecode3 = SWIG_AsVal_int(obj2, &val3);
57182 if (!SWIG_IsOK(ecode3)) {
57183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
57184 }
57185 arg3 = static_cast< int >(val3);
57186 }
57187 {
57188 PyThreadState* __tstate = wxPyBeginAllowThreads();
57189 (arg1)->Above(arg2,arg3);
57190 wxPyEndAllowThreads(__tstate);
57191 if (PyErr_Occurred()) SWIG_fail;
57192 }
57193 resultobj = SWIG_Py_Void();
57194 return resultobj;
57195 fail:
57196 return NULL;
57197 }
57198
57199
57200 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57201 PyObject *resultobj = 0;
57202 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57203 wxWindow *arg2 = (wxWindow *) 0 ;
57204 int arg3 = (int) 0 ;
57205 void *argp1 = 0 ;
57206 int res1 = 0 ;
57207 void *argp2 = 0 ;
57208 int res2 = 0 ;
57209 int val3 ;
57210 int ecode3 = 0 ;
57211 PyObject * obj0 = 0 ;
57212 PyObject * obj1 = 0 ;
57213 PyObject * obj2 = 0 ;
57214 char * kwnames[] = {
57215 (char *) "self",(char *) "sibling",(char *) "marg", NULL
57216 };
57217
57218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57220 if (!SWIG_IsOK(res1)) {
57221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57222 }
57223 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57224 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57225 if (!SWIG_IsOK(res2)) {
57226 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
57227 }
57228 arg2 = reinterpret_cast< wxWindow * >(argp2);
57229 if (obj2) {
57230 ecode3 = SWIG_AsVal_int(obj2, &val3);
57231 if (!SWIG_IsOK(ecode3)) {
57232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
57233 }
57234 arg3 = static_cast< int >(val3);
57235 }
57236 {
57237 PyThreadState* __tstate = wxPyBeginAllowThreads();
57238 (arg1)->Below(arg2,arg3);
57239 wxPyEndAllowThreads(__tstate);
57240 if (PyErr_Occurred()) SWIG_fail;
57241 }
57242 resultobj = SWIG_Py_Void();
57243 return resultobj;
57244 fail:
57245 return NULL;
57246 }
57247
57248
57249 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57250 PyObject *resultobj = 0;
57251 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57252 wxWindow *arg2 = (wxWindow *) 0 ;
57253 wxEdge arg3 ;
57254 int arg4 = (int) 0 ;
57255 void *argp1 = 0 ;
57256 int res1 = 0 ;
57257 void *argp2 = 0 ;
57258 int res2 = 0 ;
57259 int val3 ;
57260 int ecode3 = 0 ;
57261 int val4 ;
57262 int ecode4 = 0 ;
57263 PyObject * obj0 = 0 ;
57264 PyObject * obj1 = 0 ;
57265 PyObject * obj2 = 0 ;
57266 PyObject * obj3 = 0 ;
57267 char * kwnames[] = {
57268 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
57269 };
57270
57271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57273 if (!SWIG_IsOK(res1)) {
57274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57275 }
57276 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57277 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57278 if (!SWIG_IsOK(res2)) {
57279 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
57280 }
57281 arg2 = reinterpret_cast< wxWindow * >(argp2);
57282 ecode3 = SWIG_AsVal_int(obj2, &val3);
57283 if (!SWIG_IsOK(ecode3)) {
57284 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
57285 }
57286 arg3 = static_cast< wxEdge >(val3);
57287 if (obj3) {
57288 ecode4 = SWIG_AsVal_int(obj3, &val4);
57289 if (!SWIG_IsOK(ecode4)) {
57290 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
57291 }
57292 arg4 = static_cast< int >(val4);
57293 }
57294 {
57295 PyThreadState* __tstate = wxPyBeginAllowThreads();
57296 (arg1)->SameAs(arg2,arg3,arg4);
57297 wxPyEndAllowThreads(__tstate);
57298 if (PyErr_Occurred()) SWIG_fail;
57299 }
57300 resultobj = SWIG_Py_Void();
57301 return resultobj;
57302 fail:
57303 return NULL;
57304 }
57305
57306
57307 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57308 PyObject *resultobj = 0;
57309 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57310 wxWindow *arg2 = (wxWindow *) 0 ;
57311 wxEdge arg3 ;
57312 int arg4 ;
57313 void *argp1 = 0 ;
57314 int res1 = 0 ;
57315 void *argp2 = 0 ;
57316 int res2 = 0 ;
57317 int val3 ;
57318 int ecode3 = 0 ;
57319 int val4 ;
57320 int ecode4 = 0 ;
57321 PyObject * obj0 = 0 ;
57322 PyObject * obj1 = 0 ;
57323 PyObject * obj2 = 0 ;
57324 PyObject * obj3 = 0 ;
57325 char * kwnames[] = {
57326 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
57327 };
57328
57329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57331 if (!SWIG_IsOK(res1)) {
57332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57333 }
57334 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57335 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57336 if (!SWIG_IsOK(res2)) {
57337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
57338 }
57339 arg2 = reinterpret_cast< wxWindow * >(argp2);
57340 ecode3 = SWIG_AsVal_int(obj2, &val3);
57341 if (!SWIG_IsOK(ecode3)) {
57342 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
57343 }
57344 arg3 = static_cast< wxEdge >(val3);
57345 ecode4 = SWIG_AsVal_int(obj3, &val4);
57346 if (!SWIG_IsOK(ecode4)) {
57347 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
57348 }
57349 arg4 = static_cast< int >(val4);
57350 {
57351 PyThreadState* __tstate = wxPyBeginAllowThreads();
57352 (arg1)->PercentOf(arg2,arg3,arg4);
57353 wxPyEndAllowThreads(__tstate);
57354 if (PyErr_Occurred()) SWIG_fail;
57355 }
57356 resultobj = SWIG_Py_Void();
57357 return resultobj;
57358 fail:
57359 return NULL;
57360 }
57361
57362
57363 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57364 PyObject *resultobj = 0;
57365 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57366 int arg2 ;
57367 void *argp1 = 0 ;
57368 int res1 = 0 ;
57369 int val2 ;
57370 int ecode2 = 0 ;
57371 PyObject * obj0 = 0 ;
57372 PyObject * obj1 = 0 ;
57373 char * kwnames[] = {
57374 (char *) "self",(char *) "val", NULL
57375 };
57376
57377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
57378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57379 if (!SWIG_IsOK(res1)) {
57380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57381 }
57382 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57383 ecode2 = SWIG_AsVal_int(obj1, &val2);
57384 if (!SWIG_IsOK(ecode2)) {
57385 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
57386 }
57387 arg2 = static_cast< int >(val2);
57388 {
57389 PyThreadState* __tstate = wxPyBeginAllowThreads();
57390 (arg1)->Absolute(arg2);
57391 wxPyEndAllowThreads(__tstate);
57392 if (PyErr_Occurred()) SWIG_fail;
57393 }
57394 resultobj = SWIG_Py_Void();
57395 return resultobj;
57396 fail:
57397 return NULL;
57398 }
57399
57400
57401 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57402 PyObject *resultobj = 0;
57403 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57404 void *argp1 = 0 ;
57405 int res1 = 0 ;
57406 PyObject *swig_obj[1] ;
57407
57408 if (!args) SWIG_fail;
57409 swig_obj[0] = args;
57410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57411 if (!SWIG_IsOK(res1)) {
57412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57413 }
57414 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57415 {
57416 PyThreadState* __tstate = wxPyBeginAllowThreads();
57417 (arg1)->Unconstrained();
57418 wxPyEndAllowThreads(__tstate);
57419 if (PyErr_Occurred()) SWIG_fail;
57420 }
57421 resultobj = SWIG_Py_Void();
57422 return resultobj;
57423 fail:
57424 return NULL;
57425 }
57426
57427
57428 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57429 PyObject *resultobj = 0;
57430 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57431 void *argp1 = 0 ;
57432 int res1 = 0 ;
57433 PyObject *swig_obj[1] ;
57434
57435 if (!args) SWIG_fail;
57436 swig_obj[0] = args;
57437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57438 if (!SWIG_IsOK(res1)) {
57439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57440 }
57441 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57442 {
57443 PyThreadState* __tstate = wxPyBeginAllowThreads();
57444 (arg1)->AsIs();
57445 wxPyEndAllowThreads(__tstate);
57446 if (PyErr_Occurred()) SWIG_fail;
57447 }
57448 resultobj = SWIG_Py_Void();
57449 return resultobj;
57450 fail:
57451 return NULL;
57452 }
57453
57454
57455 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57456 PyObject *resultobj = 0;
57457 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57458 wxWindow *result = 0 ;
57459 void *argp1 = 0 ;
57460 int res1 = 0 ;
57461 PyObject *swig_obj[1] ;
57462
57463 if (!args) SWIG_fail;
57464 swig_obj[0] = args;
57465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57466 if (!SWIG_IsOK(res1)) {
57467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57468 }
57469 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57470 {
57471 PyThreadState* __tstate = wxPyBeginAllowThreads();
57472 result = (wxWindow *)(arg1)->GetOtherWindow();
57473 wxPyEndAllowThreads(__tstate);
57474 if (PyErr_Occurred()) SWIG_fail;
57475 }
57476 {
57477 resultobj = wxPyMake_wxObject(result, 0);
57478 }
57479 return resultobj;
57480 fail:
57481 return NULL;
57482 }
57483
57484
57485 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57486 PyObject *resultobj = 0;
57487 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57488 wxEdge result;
57489 void *argp1 = 0 ;
57490 int res1 = 0 ;
57491 PyObject *swig_obj[1] ;
57492
57493 if (!args) SWIG_fail;
57494 swig_obj[0] = args;
57495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57496 if (!SWIG_IsOK(res1)) {
57497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57498 }
57499 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57500 {
57501 PyThreadState* __tstate = wxPyBeginAllowThreads();
57502 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
57503 wxPyEndAllowThreads(__tstate);
57504 if (PyErr_Occurred()) SWIG_fail;
57505 }
57506 resultobj = SWIG_From_int(static_cast< int >(result));
57507 return resultobj;
57508 fail:
57509 return NULL;
57510 }
57511
57512
57513 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57514 PyObject *resultobj = 0;
57515 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57516 wxEdge arg2 ;
57517 void *argp1 = 0 ;
57518 int res1 = 0 ;
57519 int val2 ;
57520 int ecode2 = 0 ;
57521 PyObject * obj0 = 0 ;
57522 PyObject * obj1 = 0 ;
57523 char * kwnames[] = {
57524 (char *) "self",(char *) "which", NULL
57525 };
57526
57527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
57528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57529 if (!SWIG_IsOK(res1)) {
57530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57531 }
57532 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57533 ecode2 = SWIG_AsVal_int(obj1, &val2);
57534 if (!SWIG_IsOK(ecode2)) {
57535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57536 }
57537 arg2 = static_cast< wxEdge >(val2);
57538 {
57539 PyThreadState* __tstate = wxPyBeginAllowThreads();
57540 (arg1)->SetEdge(arg2);
57541 wxPyEndAllowThreads(__tstate);
57542 if (PyErr_Occurred()) SWIG_fail;
57543 }
57544 resultobj = SWIG_Py_Void();
57545 return resultobj;
57546 fail:
57547 return NULL;
57548 }
57549
57550
57551 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57552 PyObject *resultobj = 0;
57553 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57554 int arg2 ;
57555 void *argp1 = 0 ;
57556 int res1 = 0 ;
57557 int val2 ;
57558 int ecode2 = 0 ;
57559 PyObject * obj0 = 0 ;
57560 PyObject * obj1 = 0 ;
57561 char * kwnames[] = {
57562 (char *) "self",(char *) "v", NULL
57563 };
57564
57565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
57566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57567 if (!SWIG_IsOK(res1)) {
57568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57569 }
57570 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57571 ecode2 = SWIG_AsVal_int(obj1, &val2);
57572 if (!SWIG_IsOK(ecode2)) {
57573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
57574 }
57575 arg2 = static_cast< int >(val2);
57576 {
57577 PyThreadState* __tstate = wxPyBeginAllowThreads();
57578 (arg1)->SetValue(arg2);
57579 wxPyEndAllowThreads(__tstate);
57580 if (PyErr_Occurred()) SWIG_fail;
57581 }
57582 resultobj = SWIG_Py_Void();
57583 return resultobj;
57584 fail:
57585 return NULL;
57586 }
57587
57588
57589 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57590 PyObject *resultobj = 0;
57591 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57592 int result;
57593 void *argp1 = 0 ;
57594 int res1 = 0 ;
57595 PyObject *swig_obj[1] ;
57596
57597 if (!args) SWIG_fail;
57598 swig_obj[0] = args;
57599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57600 if (!SWIG_IsOK(res1)) {
57601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57602 }
57603 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57604 {
57605 PyThreadState* __tstate = wxPyBeginAllowThreads();
57606 result = (int)(arg1)->GetMargin();
57607 wxPyEndAllowThreads(__tstate);
57608 if (PyErr_Occurred()) SWIG_fail;
57609 }
57610 resultobj = SWIG_From_int(static_cast< int >(result));
57611 return resultobj;
57612 fail:
57613 return NULL;
57614 }
57615
57616
57617 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57618 PyObject *resultobj = 0;
57619 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57620 int arg2 ;
57621 void *argp1 = 0 ;
57622 int res1 = 0 ;
57623 int val2 ;
57624 int ecode2 = 0 ;
57625 PyObject * obj0 = 0 ;
57626 PyObject * obj1 = 0 ;
57627 char * kwnames[] = {
57628 (char *) "self",(char *) "m", NULL
57629 };
57630
57631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
57632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57633 if (!SWIG_IsOK(res1)) {
57634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57635 }
57636 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57637 ecode2 = SWIG_AsVal_int(obj1, &val2);
57638 if (!SWIG_IsOK(ecode2)) {
57639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
57640 }
57641 arg2 = static_cast< int >(val2);
57642 {
57643 PyThreadState* __tstate = wxPyBeginAllowThreads();
57644 (arg1)->SetMargin(arg2);
57645 wxPyEndAllowThreads(__tstate);
57646 if (PyErr_Occurred()) SWIG_fail;
57647 }
57648 resultobj = SWIG_Py_Void();
57649 return resultobj;
57650 fail:
57651 return NULL;
57652 }
57653
57654
57655 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57656 PyObject *resultobj = 0;
57657 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57658 int result;
57659 void *argp1 = 0 ;
57660 int res1 = 0 ;
57661 PyObject *swig_obj[1] ;
57662
57663 if (!args) SWIG_fail;
57664 swig_obj[0] = args;
57665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57666 if (!SWIG_IsOK(res1)) {
57667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57668 }
57669 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57670 {
57671 PyThreadState* __tstate = wxPyBeginAllowThreads();
57672 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
57673 wxPyEndAllowThreads(__tstate);
57674 if (PyErr_Occurred()) SWIG_fail;
57675 }
57676 resultobj = SWIG_From_int(static_cast< int >(result));
57677 return resultobj;
57678 fail:
57679 return NULL;
57680 }
57681
57682
57683 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57684 PyObject *resultobj = 0;
57685 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57686 int result;
57687 void *argp1 = 0 ;
57688 int res1 = 0 ;
57689 PyObject *swig_obj[1] ;
57690
57691 if (!args) SWIG_fail;
57692 swig_obj[0] = args;
57693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57694 if (!SWIG_IsOK(res1)) {
57695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57696 }
57697 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57698 {
57699 PyThreadState* __tstate = wxPyBeginAllowThreads();
57700 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
57701 wxPyEndAllowThreads(__tstate);
57702 if (PyErr_Occurred()) SWIG_fail;
57703 }
57704 resultobj = SWIG_From_int(static_cast< int >(result));
57705 return resultobj;
57706 fail:
57707 return NULL;
57708 }
57709
57710
57711 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57712 PyObject *resultobj = 0;
57713 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57714 int result;
57715 void *argp1 = 0 ;
57716 int res1 = 0 ;
57717 PyObject *swig_obj[1] ;
57718
57719 if (!args) SWIG_fail;
57720 swig_obj[0] = args;
57721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57722 if (!SWIG_IsOK(res1)) {
57723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57724 }
57725 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57726 {
57727 PyThreadState* __tstate = wxPyBeginAllowThreads();
57728 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
57729 wxPyEndAllowThreads(__tstate);
57730 if (PyErr_Occurred()) SWIG_fail;
57731 }
57732 resultobj = SWIG_From_int(static_cast< int >(result));
57733 return resultobj;
57734 fail:
57735 return NULL;
57736 }
57737
57738
57739 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57740 PyObject *resultobj = 0;
57741 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57742 bool result;
57743 void *argp1 = 0 ;
57744 int res1 = 0 ;
57745 PyObject *swig_obj[1] ;
57746
57747 if (!args) SWIG_fail;
57748 swig_obj[0] = args;
57749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57750 if (!SWIG_IsOK(res1)) {
57751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57752 }
57753 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57754 {
57755 PyThreadState* __tstate = wxPyBeginAllowThreads();
57756 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
57757 wxPyEndAllowThreads(__tstate);
57758 if (PyErr_Occurred()) SWIG_fail;
57759 }
57760 {
57761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57762 }
57763 return resultobj;
57764 fail:
57765 return NULL;
57766 }
57767
57768
57769 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57770 PyObject *resultobj = 0;
57771 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57772 bool arg2 ;
57773 void *argp1 = 0 ;
57774 int res1 = 0 ;
57775 bool val2 ;
57776 int ecode2 = 0 ;
57777 PyObject * obj0 = 0 ;
57778 PyObject * obj1 = 0 ;
57779 char * kwnames[] = {
57780 (char *) "self",(char *) "d", NULL
57781 };
57782
57783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
57784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57785 if (!SWIG_IsOK(res1)) {
57786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57787 }
57788 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57789 ecode2 = SWIG_AsVal_bool(obj1, &val2);
57790 if (!SWIG_IsOK(ecode2)) {
57791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
57792 }
57793 arg2 = static_cast< bool >(val2);
57794 {
57795 PyThreadState* __tstate = wxPyBeginAllowThreads();
57796 (arg1)->SetDone(arg2);
57797 wxPyEndAllowThreads(__tstate);
57798 if (PyErr_Occurred()) SWIG_fail;
57799 }
57800 resultobj = SWIG_Py_Void();
57801 return resultobj;
57802 fail:
57803 return NULL;
57804 }
57805
57806
57807 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
57808 PyObject *resultobj = 0;
57809 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57810 wxRelationship result;
57811 void *argp1 = 0 ;
57812 int res1 = 0 ;
57813 PyObject *swig_obj[1] ;
57814
57815 if (!args) SWIG_fail;
57816 swig_obj[0] = args;
57817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57818 if (!SWIG_IsOK(res1)) {
57819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57820 }
57821 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57822 {
57823 PyThreadState* __tstate = wxPyBeginAllowThreads();
57824 result = (wxRelationship)(arg1)->GetRelationship();
57825 wxPyEndAllowThreads(__tstate);
57826 if (PyErr_Occurred()) SWIG_fail;
57827 }
57828 resultobj = SWIG_From_int(static_cast< int >(result));
57829 return resultobj;
57830 fail:
57831 return NULL;
57832 }
57833
57834
57835 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57836 PyObject *resultobj = 0;
57837 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57838 wxRelationship arg2 ;
57839 void *argp1 = 0 ;
57840 int res1 = 0 ;
57841 int val2 ;
57842 int ecode2 = 0 ;
57843 PyObject * obj0 = 0 ;
57844 PyObject * obj1 = 0 ;
57845 char * kwnames[] = {
57846 (char *) "self",(char *) "r", NULL
57847 };
57848
57849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
57850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57851 if (!SWIG_IsOK(res1)) {
57852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57853 }
57854 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57855 ecode2 = SWIG_AsVal_int(obj1, &val2);
57856 if (!SWIG_IsOK(ecode2)) {
57857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
57858 }
57859 arg2 = static_cast< wxRelationship >(val2);
57860 {
57861 PyThreadState* __tstate = wxPyBeginAllowThreads();
57862 (arg1)->SetRelationship(arg2);
57863 wxPyEndAllowThreads(__tstate);
57864 if (PyErr_Occurred()) SWIG_fail;
57865 }
57866 resultobj = SWIG_Py_Void();
57867 return resultobj;
57868 fail:
57869 return NULL;
57870 }
57871
57872
57873 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57874 PyObject *resultobj = 0;
57875 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57876 wxWindow *arg2 = (wxWindow *) 0 ;
57877 bool result;
57878 void *argp1 = 0 ;
57879 int res1 = 0 ;
57880 void *argp2 = 0 ;
57881 int res2 = 0 ;
57882 PyObject * obj0 = 0 ;
57883 PyObject * obj1 = 0 ;
57884 char * kwnames[] = {
57885 (char *) "self",(char *) "otherW", NULL
57886 };
57887
57888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
57889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57890 if (!SWIG_IsOK(res1)) {
57891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57892 }
57893 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
57895 if (!SWIG_IsOK(res2)) {
57896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
57897 }
57898 arg2 = reinterpret_cast< wxWindow * >(argp2);
57899 {
57900 PyThreadState* __tstate = wxPyBeginAllowThreads();
57901 result = (bool)(arg1)->ResetIfWin(arg2);
57902 wxPyEndAllowThreads(__tstate);
57903 if (PyErr_Occurred()) SWIG_fail;
57904 }
57905 {
57906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57907 }
57908 return resultobj;
57909 fail:
57910 return NULL;
57911 }
57912
57913
57914 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57915 PyObject *resultobj = 0;
57916 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57917 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
57918 wxWindow *arg3 = (wxWindow *) 0 ;
57919 bool result;
57920 void *argp1 = 0 ;
57921 int res1 = 0 ;
57922 void *argp2 = 0 ;
57923 int res2 = 0 ;
57924 void *argp3 = 0 ;
57925 int res3 = 0 ;
57926 PyObject * obj0 = 0 ;
57927 PyObject * obj1 = 0 ;
57928 PyObject * obj2 = 0 ;
57929 char * kwnames[] = {
57930 (char *) "self",(char *) "constraints",(char *) "win", NULL
57931 };
57932
57933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
57934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57935 if (!SWIG_IsOK(res1)) {
57936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
57937 }
57938 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57939 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
57940 if (!SWIG_IsOK(res2)) {
57941 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
57942 }
57943 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
57944 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57945 if (!SWIG_IsOK(res3)) {
57946 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
57947 }
57948 arg3 = reinterpret_cast< wxWindow * >(argp3);
57949 {
57950 PyThreadState* __tstate = wxPyBeginAllowThreads();
57951 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
57952 wxPyEndAllowThreads(__tstate);
57953 if (PyErr_Occurred()) SWIG_fail;
57954 }
57955 {
57956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
57957 }
57958 return resultobj;
57959 fail:
57960 return NULL;
57961 }
57962
57963
57964 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
57965 PyObject *resultobj = 0;
57966 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
57967 wxEdge arg2 ;
57968 wxWindow *arg3 = (wxWindow *) 0 ;
57969 wxWindow *arg4 = (wxWindow *) 0 ;
57970 int result;
57971 void *argp1 = 0 ;
57972 int res1 = 0 ;
57973 int val2 ;
57974 int ecode2 = 0 ;
57975 void *argp3 = 0 ;
57976 int res3 = 0 ;
57977 void *argp4 = 0 ;
57978 int res4 = 0 ;
57979 PyObject * obj0 = 0 ;
57980 PyObject * obj1 = 0 ;
57981 PyObject * obj2 = 0 ;
57982 PyObject * obj3 = 0 ;
57983 char * kwnames[] = {
57984 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
57985 };
57986
57987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
57988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
57989 if (!SWIG_IsOK(res1)) {
57990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
57991 }
57992 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
57993 ecode2 = SWIG_AsVal_int(obj1, &val2);
57994 if (!SWIG_IsOK(ecode2)) {
57995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
57996 }
57997 arg2 = static_cast< wxEdge >(val2);
57998 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
57999 if (!SWIG_IsOK(res3)) {
58000 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
58001 }
58002 arg3 = reinterpret_cast< wxWindow * >(argp3);
58003 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
58004 if (!SWIG_IsOK(res4)) {
58005 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
58006 }
58007 arg4 = reinterpret_cast< wxWindow * >(argp4);
58008 {
58009 PyThreadState* __tstate = wxPyBeginAllowThreads();
58010 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
58011 wxPyEndAllowThreads(__tstate);
58012 if (PyErr_Occurred()) SWIG_fail;
58013 }
58014 resultobj = SWIG_From_int(static_cast< int >(result));
58015 return resultobj;
58016 fail:
58017 return NULL;
58018 }
58019
58020
58021 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58022 PyObject *obj;
58023 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58024 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
58025 return SWIG_Py_Void();
58026 }
58027
58028 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58029 PyObject *resultobj = 0;
58030 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58031 wxIndividualLayoutConstraint *result = 0 ;
58032 void *argp1 = 0 ;
58033 int res1 = 0 ;
58034 PyObject *swig_obj[1] ;
58035
58036 if (!args) SWIG_fail;
58037 swig_obj[0] = args;
58038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58039 if (!SWIG_IsOK(res1)) {
58040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58041 }
58042 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58043 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
58044 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58045 return resultobj;
58046 fail:
58047 return NULL;
58048 }
58049
58050
58051 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58052 PyObject *resultobj = 0;
58053 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58054 wxIndividualLayoutConstraint *result = 0 ;
58055 void *argp1 = 0 ;
58056 int res1 = 0 ;
58057 PyObject *swig_obj[1] ;
58058
58059 if (!args) SWIG_fail;
58060 swig_obj[0] = args;
58061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58062 if (!SWIG_IsOK(res1)) {
58063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58064 }
58065 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58066 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
58067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58068 return resultobj;
58069 fail:
58070 return NULL;
58071 }
58072
58073
58074 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58075 PyObject *resultobj = 0;
58076 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58077 wxIndividualLayoutConstraint *result = 0 ;
58078 void *argp1 = 0 ;
58079 int res1 = 0 ;
58080 PyObject *swig_obj[1] ;
58081
58082 if (!args) SWIG_fail;
58083 swig_obj[0] = args;
58084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58085 if (!SWIG_IsOK(res1)) {
58086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58087 }
58088 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58089 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
58090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58091 return resultobj;
58092 fail:
58093 return NULL;
58094 }
58095
58096
58097 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58098 PyObject *resultobj = 0;
58099 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58100 wxIndividualLayoutConstraint *result = 0 ;
58101 void *argp1 = 0 ;
58102 int res1 = 0 ;
58103 PyObject *swig_obj[1] ;
58104
58105 if (!args) SWIG_fail;
58106 swig_obj[0] = args;
58107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58108 if (!SWIG_IsOK(res1)) {
58109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58110 }
58111 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58112 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
58113 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58114 return resultobj;
58115 fail:
58116 return NULL;
58117 }
58118
58119
58120 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58121 PyObject *resultobj = 0;
58122 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58123 wxIndividualLayoutConstraint *result = 0 ;
58124 void *argp1 = 0 ;
58125 int res1 = 0 ;
58126 PyObject *swig_obj[1] ;
58127
58128 if (!args) SWIG_fail;
58129 swig_obj[0] = args;
58130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58131 if (!SWIG_IsOK(res1)) {
58132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58133 }
58134 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58135 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
58136 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58137 return resultobj;
58138 fail:
58139 return NULL;
58140 }
58141
58142
58143 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58144 PyObject *resultobj = 0;
58145 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58146 wxIndividualLayoutConstraint *result = 0 ;
58147 void *argp1 = 0 ;
58148 int res1 = 0 ;
58149 PyObject *swig_obj[1] ;
58150
58151 if (!args) SWIG_fail;
58152 swig_obj[0] = args;
58153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58154 if (!SWIG_IsOK(res1)) {
58155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58156 }
58157 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58158 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
58159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58160 return resultobj;
58161 fail:
58162 return NULL;
58163 }
58164
58165
58166 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58167 PyObject *resultobj = 0;
58168 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58169 wxIndividualLayoutConstraint *result = 0 ;
58170 void *argp1 = 0 ;
58171 int res1 = 0 ;
58172 PyObject *swig_obj[1] ;
58173
58174 if (!args) SWIG_fail;
58175 swig_obj[0] = args;
58176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58177 if (!SWIG_IsOK(res1)) {
58178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58179 }
58180 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58181 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
58182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58183 return resultobj;
58184 fail:
58185 return NULL;
58186 }
58187
58188
58189 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58190 PyObject *resultobj = 0;
58191 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58192 wxIndividualLayoutConstraint *result = 0 ;
58193 void *argp1 = 0 ;
58194 int res1 = 0 ;
58195 PyObject *swig_obj[1] ;
58196
58197 if (!args) SWIG_fail;
58198 swig_obj[0] = args;
58199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58200 if (!SWIG_IsOK(res1)) {
58201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58202 }
58203 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58204 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
58205 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
58206 return resultobj;
58207 fail:
58208 return NULL;
58209 }
58210
58211
58212 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58213 PyObject *resultobj = 0;
58214 wxLayoutConstraints *result = 0 ;
58215
58216 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
58217 {
58218 PyThreadState* __tstate = wxPyBeginAllowThreads();
58219 result = (wxLayoutConstraints *)new wxLayoutConstraints();
58220 wxPyEndAllowThreads(__tstate);
58221 if (PyErr_Occurred()) SWIG_fail;
58222 }
58223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
58224 return resultobj;
58225 fail:
58226 return NULL;
58227 }
58228
58229
58230 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58231 PyObject *resultobj = 0;
58232 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58233 void *argp1 = 0 ;
58234 int res1 = 0 ;
58235 PyObject *swig_obj[1] ;
58236
58237 if (!args) SWIG_fail;
58238 swig_obj[0] = args;
58239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
58240 if (!SWIG_IsOK(res1)) {
58241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58242 }
58243 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58244 {
58245 PyThreadState* __tstate = wxPyBeginAllowThreads();
58246 delete arg1;
58247
58248 wxPyEndAllowThreads(__tstate);
58249 if (PyErr_Occurred()) SWIG_fail;
58250 }
58251 resultobj = SWIG_Py_Void();
58252 return resultobj;
58253 fail:
58254 return NULL;
58255 }
58256
58257
58258 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
58259 PyObject *resultobj = 0;
58260 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58261 wxWindow *arg2 = (wxWindow *) 0 ;
58262 int *arg3 = (int *) 0 ;
58263 bool result;
58264 void *argp1 = 0 ;
58265 int res1 = 0 ;
58266 void *argp2 = 0 ;
58267 int res2 = 0 ;
58268 int temp3 ;
58269 int res3 = SWIG_TMPOBJ ;
58270 PyObject * obj0 = 0 ;
58271 PyObject * obj1 = 0 ;
58272 char * kwnames[] = {
58273 (char *) "self",(char *) "win", NULL
58274 };
58275
58276 arg3 = &temp3;
58277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
58278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58279 if (!SWIG_IsOK(res1)) {
58280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
58281 }
58282 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
58284 if (!SWIG_IsOK(res2)) {
58285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
58286 }
58287 arg2 = reinterpret_cast< wxWindow * >(argp2);
58288 {
58289 PyThreadState* __tstate = wxPyBeginAllowThreads();
58290 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
58291 wxPyEndAllowThreads(__tstate);
58292 if (PyErr_Occurred()) SWIG_fail;
58293 }
58294 {
58295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58296 }
58297 if (SWIG_IsTmpObj(res3)) {
58298 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
58299 } else {
58300 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
58301 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
58302 }
58303 return resultobj;
58304 fail:
58305 return NULL;
58306 }
58307
58308
58309 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58310 PyObject *resultobj = 0;
58311 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
58312 bool result;
58313 void *argp1 = 0 ;
58314 int res1 = 0 ;
58315 PyObject *swig_obj[1] ;
58316
58317 if (!args) SWIG_fail;
58318 swig_obj[0] = args;
58319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
58320 if (!SWIG_IsOK(res1)) {
58321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
58322 }
58323 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
58324 {
58325 PyThreadState* __tstate = wxPyBeginAllowThreads();
58326 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
58327 wxPyEndAllowThreads(__tstate);
58328 if (PyErr_Occurred()) SWIG_fail;
58329 }
58330 {
58331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
58332 }
58333 return resultobj;
58334 fail:
58335 return NULL;
58336 }
58337
58338
58339 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58340 PyObject *obj;
58341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
58342 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
58343 return SWIG_Py_Void();
58344 }
58345
58346 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
58347 return SWIG_Python_InitShadowInstance(args);
58348 }
58349
58350 static PyMethodDef SwigMethods[] = {
58351 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
58352 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
58353 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
58354 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58355 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
58356 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
58357 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
58358 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
58359 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
58360 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58361 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
58362 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58363 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58364 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58365 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58366 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
58367 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
58368 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
58369 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
58370 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58371 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58372 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58373 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58374 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
58375 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
58376 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
58377 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
58378 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
58379 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
58380 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
58381 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
58382 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
58383 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
58384 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
58385 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58386 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
58387 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58388 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58389 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58390 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58391 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58392 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
58393 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
58394 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
58395 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
58396 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
58397 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
58398 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
58399 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
58400 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
58401 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58402 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58403 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58404 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
58405 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58406 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58407 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58408 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
58409 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
58410 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
58411 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
58412 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
58413 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
58414 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
58415 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
58416 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
58417 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
58418 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
58419 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
58420 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
58421 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
58422 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
58423 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
58424 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
58425 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58426 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
58427 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
58428 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
58429 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
58430 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58431 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
58432 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
58433 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
58434 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
58435 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
58436 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58437 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
58438 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
58439 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
58440 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
58441 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58442 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58443 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58444 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58445 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
58446 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
58447 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
58448 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58449 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58450 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58451 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
58452 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58453 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58454 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58455 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
58456 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58457 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58458 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58459 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
58460 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
58461 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
58462 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
58463 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
58464 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
58465 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
58466 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
58467 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
58468 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58469 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
58470 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
58471 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
58472 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
58473 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
58474 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
58475 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58476 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
58477 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
58478 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
58479 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
58480 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
58481 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
58482 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
58483 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
58484 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
58485 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58486 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
58487 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
58488 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
58489 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
58490 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
58491 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
58492 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58493 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58494 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
58495 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
58496 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
58497 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
58498 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58499 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
58500 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
58501 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
58502 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
58503 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
58504 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
58505 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
58506 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
58507 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
58508 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
58509 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
58510 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
58511 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58512 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
58513 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58514 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58515 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
58516 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
58517 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
58518 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
58519 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
58520 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58521 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
58522 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58523 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58524 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
58525 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
58526 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
58527 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
58528 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
58529 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
58530 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
58531 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
58532 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
58533 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
58534 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
58535 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
58536 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
58537 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
58538 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
58539 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
58540 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
58541 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
58542 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
58543 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58544 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58545 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
58546 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
58547 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
58548 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58549 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58550 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
58551 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
58552 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
58553 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
58554 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
58555 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
58556 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
58557 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
58558 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58559 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
58560 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
58561 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
58562 { (char *)"new_Position", (PyCFunction) _wrap_new_Position, METH_VARARGS | METH_KEYWORDS, NULL},
58563 { (char *)"delete_Position", (PyCFunction)_wrap_delete_Position, METH_O, NULL},
58564 { (char *)"Position_GetRow", (PyCFunction)_wrap_Position_GetRow, METH_O, NULL},
58565 { (char *)"Position_GetColumn", (PyCFunction)_wrap_Position_GetColumn, METH_O, NULL},
58566 { (char *)"Position_GetCol", (PyCFunction)_wrap_Position_GetCol, METH_O, NULL},
58567 { (char *)"Position_SetRow", (PyCFunction) _wrap_Position_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58568 { (char *)"Position_SetColumn", (PyCFunction) _wrap_Position_SetColumn, METH_VARARGS | METH_KEYWORDS, NULL},
58569 { (char *)"Position_SetCol", (PyCFunction) _wrap_Position_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58570 { (char *)"Position___eq__", (PyCFunction) _wrap_Position___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58571 { (char *)"Position___ne__", (PyCFunction) _wrap_Position___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58572 { (char *)"Position___add__", _wrap_Position___add__, METH_VARARGS, NULL},
58573 { (char *)"Position___sub__", _wrap_Position___sub__, METH_VARARGS, NULL},
58574 { (char *)"Position_swigregister", Position_swigregister, METH_VARARGS, NULL},
58575 { (char *)"Position_swiginit", Position_swiginit, METH_VARARGS, NULL},
58576 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
58577 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
58578 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
58579 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
58580 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
58581 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
58582 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
58583 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
58584 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
58585 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
58586 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
58587 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
58588 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
58589 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
58590 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
58591 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
58592 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
58593 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
58594 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
58595 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
58596 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
58597 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
58598 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
58599 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
58600 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
58601 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
58602 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
58603 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
58604 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
58605 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
58606 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
58607 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
58608 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
58609 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
58610 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
58611 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
58612 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58613 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58614 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58615 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58616 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
58617 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
58618 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58619 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
58620 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
58621 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
58622 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
58623 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
58624 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
58625 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
58626 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
58627 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
58628 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58629 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58630 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
58631 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58632 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58633 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
58634 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
58635 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
58636 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
58637 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
58638 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
58639 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58640 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58641 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
58642 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
58643 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
58644 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58645 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58646 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58647 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
58648 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
58649 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
58650 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
58651 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58652 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
58653 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
58654 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58655 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
58656 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
58657 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
58658 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
58659 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
58660 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
58661 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
58662 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
58663 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
58664 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
58665 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58666 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58667 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
58668 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
58669 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
58670 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
58671 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
58672 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
58673 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
58674 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
58675 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
58676 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
58677 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58678 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58679 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
58680 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58681 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
58682 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
58683 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
58684 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
58685 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
58686 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
58687 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
58688 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
58689 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
58690 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
58691 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
58692 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
58693 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
58694 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
58695 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
58696 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
58697 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
58698 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
58699 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
58700 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
58701 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
58702 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
58703 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
58704 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
58705 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
58706 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
58707 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
58708 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58709 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
58710 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58711 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
58712 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
58713 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
58714 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
58715 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
58716 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
58717 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
58718 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
58719 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
58720 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
58721 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
58722 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58723 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
58724 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
58725 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
58726 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
58727 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58728 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58729 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
58730 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
58731 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
58732 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
58733 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
58734 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
58735 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
58736 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
58737 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
58738 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
58739 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58740 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
58741 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
58742 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58743 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
58744 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
58745 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
58746 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
58747 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
58748 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
58749 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
58750 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
58751 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
58752 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
58753 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
58754 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
58755 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
58756 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58757 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
58758 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
58759 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
58760 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58761 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
58762 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
58763 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
58764 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
58765 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
58766 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
58767 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
58768 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
58769 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
58770 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
58771 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
58772 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
58773 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
58774 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58775 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58776 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
58777 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
58778 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
58779 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
58780 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
58781 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58782 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58783 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58784 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
58785 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
58786 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58787 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
58788 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
58789 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
58790 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
58791 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
58792 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
58793 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
58794 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
58795 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
58796 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
58797 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
58798 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
58799 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
58800 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
58801 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
58802 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
58803 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
58804 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
58805 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
58806 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
58807 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
58808 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
58809 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
58810 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
58811 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
58812 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
58813 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
58814 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
58815 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
58816 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
58817 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
58818 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
58819 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
58820 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
58821 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
58822 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
58823 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
58824 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
58825 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
58826 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
58827 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
58828 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
58829 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
58830 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
58831 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
58832 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
58833 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
58834 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
58835 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58836 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
58837 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
58838 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
58839 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58840 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58841 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
58842 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
58843 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
58844 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58845 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
58846 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
58847 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
58848 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
58849 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
58850 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
58851 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
58852 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
58853 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
58854 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
58855 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
58856 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
58857 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
58858 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
58859 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
58860 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
58861 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
58862 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
58863 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
58864 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
58865 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
58866 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
58867 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
58868 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
58869 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
58870 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
58871 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
58872 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
58873 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58874 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
58875 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
58876 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
58877 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
58878 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
58879 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
58880 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
58881 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
58882 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
58883 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
58884 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
58885 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
58886 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
58887 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
58888 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58889 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
58890 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
58891 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
58892 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
58893 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
58894 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58895 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
58896 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
58897 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58898 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58899 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
58900 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
58901 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58902 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
58903 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
58904 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58905 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58906 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
58907 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
58908 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58909 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
58910 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
58911 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
58912 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
58913 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
58914 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
58915 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
58916 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
58917 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
58918 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
58919 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
58920 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
58921 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
58922 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
58923 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
58924 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
58925 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
58926 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
58927 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
58928 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
58929 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
58930 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
58931 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
58932 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
58933 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
58934 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
58935 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
58936 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
58937 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
58938 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
58939 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58940 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
58941 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
58942 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
58943 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
58944 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
58945 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
58946 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
58947 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
58948 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
58949 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
58950 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
58951 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
58952 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
58953 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
58954 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
58955 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
58956 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
58957 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
58958 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
58959 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
58960 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
58961 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
58962 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
58963 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
58964 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
58965 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
58966 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
58967 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
58968 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
58969 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
58970 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
58971 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
58972 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
58973 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58974 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
58975 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
58976 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
58977 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
58978 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
58979 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
58980 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
58981 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
58982 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
58983 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
58984 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
58985 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
58986 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
58987 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
58988 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
58989 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
58990 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
58991 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
58992 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
58993 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
58994 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
58995 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
58996 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
58997 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
58998 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
58999 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
59000 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
59001 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
59002 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
59003 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
59004 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
59005 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
59006 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
59007 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
59008 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
59009 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
59010 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
59011 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
59012 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
59013 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
59014 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
59015 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
59016 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
59017 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
59018 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
59019 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
59020 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59021 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
59022 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
59023 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59024 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59025 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
59026 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
59027 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
59028 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
59029 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
59030 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
59031 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59032 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
59033 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
59034 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59035 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59036 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
59037 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
59038 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59039 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
59040 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
59041 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59042 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
59043 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
59044 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59045 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
59046 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
59047 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
59048 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59049 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
59050 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59051 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
59052 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
59053 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59054 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
59055 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
59056 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
59057 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59058 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
59059 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
59060 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
59061 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59062 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
59063 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
59064 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59065 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
59066 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
59067 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
59068 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
59069 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
59070 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59071 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
59072 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
59073 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
59074 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
59075 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
59076 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
59077 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
59078 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
59079 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59080 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
59081 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
59082 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
59083 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
59084 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59085 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
59086 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
59087 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
59088 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59089 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
59090 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
59091 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
59092 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
59093 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
59094 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
59095 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59096 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
59097 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
59098 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
59099 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
59100 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
59101 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
59102 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
59103 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
59104 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59105 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59106 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59107 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59108 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
59109 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
59110 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
59111 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
59112 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59113 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
59114 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
59115 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
59116 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
59117 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
59118 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
59119 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59120 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
59121 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
59122 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
59123 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59124 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
59125 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
59126 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
59127 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
59128 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
59129 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59130 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59131 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
59132 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
59133 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
59134 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59135 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
59136 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
59137 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
59138 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
59139 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
59140 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
59141 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59142 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
59143 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
59144 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
59145 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
59146 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59147 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
59148 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59149 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
59150 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
59151 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59152 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
59153 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
59154 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
59155 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59156 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
59157 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
59158 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
59159 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59160 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
59161 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59162 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
59163 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
59164 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
59165 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
59166 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
59167 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
59168 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
59169 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
59170 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
59171 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
59172 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59173 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
59174 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
59175 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59176 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
59177 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59178 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
59179 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
59180 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
59181 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59182 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
59183 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
59184 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
59185 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
59186 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
59187 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59188 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
59189 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
59190 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
59191 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
59192 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
59193 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
59194 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
59195 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
59196 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
59197 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
59198 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
59199 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59200 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
59201 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
59202 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
59203 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
59204 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
59205 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
59206 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
59207 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
59208 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
59209 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
59210 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
59211 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
59212 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
59213 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
59214 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
59215 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
59216 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
59217 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
59218 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
59219 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
59220 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59221 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
59222 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
59223 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
59224 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
59225 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
59226 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
59227 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
59228 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
59229 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
59230 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
59231 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
59232 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
59233 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
59234 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
59235 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
59236 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59237 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59238 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
59239 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
59240 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
59241 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
59242 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
59243 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
59244 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
59245 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
59246 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
59247 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
59248 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
59249 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
59250 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
59251 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
59252 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
59253 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
59254 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
59255 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
59256 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
59257 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
59258 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
59259 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
59260 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
59261 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
59262 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
59263 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
59264 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
59265 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
59266 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
59267 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
59268 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
59269 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
59270 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
59271 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
59272 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59273 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59274 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
59275 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
59276 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
59277 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
59278 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
59279 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
59280 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
59281 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
59282 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59283 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
59284 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
59285 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
59286 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
59287 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
59288 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
59289 { (char *)"VisualAttributes__get_font", (PyCFunction)_wrap_VisualAttributes__get_font, METH_O, NULL},
59290 { (char *)"VisualAttributes__get_colFg", (PyCFunction)_wrap_VisualAttributes__get_colFg, METH_O, NULL},
59291 { (char *)"VisualAttributes__get_colBg", (PyCFunction)_wrap_VisualAttributes__get_colBg, METH_O, NULL},
59292 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
59293 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
59294 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
59295 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
59296 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59297 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
59298 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
59299 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
59300 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
59301 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59302 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
59303 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
59304 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
59305 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
59306 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
59307 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59308 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
59309 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
59310 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59311 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
59312 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
59313 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59314 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59315 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
59316 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
59317 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
59318 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59319 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
59320 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
59321 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
59322 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
59323 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
59324 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
59325 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59326 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
59327 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
59328 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
59329 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
59330 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
59331 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
59332 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
59333 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
59334 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
59335 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
59336 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
59337 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
59338 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
59339 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
59340 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
59341 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
59342 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
59343 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
59344 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
59345 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
59346 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
59347 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
59348 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59349 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59350 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59351 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
59352 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
59353 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
59354 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59355 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
59356 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
59357 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
59358 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
59359 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
59360 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
59361 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
59362 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
59363 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
59364 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
59365 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
59366 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59367 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
59368 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59369 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
59370 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
59371 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
59372 { (char *)"Window_IsThisEnabled", (PyCFunction)_wrap_Window_IsThisEnabled, METH_O, NULL},
59373 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
59374 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59375 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
59376 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59377 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
59378 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59379 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59380 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
59381 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
59382 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59383 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
59384 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
59385 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
59386 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
59387 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
59388 { (char *)"Window_CanAcceptFocus", (PyCFunction)_wrap_Window_CanAcceptFocus, METH_O, NULL},
59389 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
59390 { (char *)"Window_CanAcceptFocusFromKeyboard", (PyCFunction)_wrap_Window_CanAcceptFocusFromKeyboard, METH_O, NULL},
59391 { (char *)"Window_SetCanFocus", (PyCFunction) _wrap_Window_SetCanFocus, METH_VARARGS | METH_KEYWORDS, NULL},
59392 { (char *)"Window_NavigateIn", (PyCFunction) _wrap_Window_NavigateIn, METH_VARARGS | METH_KEYWORDS, NULL},
59393 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
59394 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59395 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
59396 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
59397 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
59398 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
59399 { (char *)"Window_GetTopLevelParent", (PyCFunction)_wrap_Window_GetTopLevelParent, METH_O, NULL},
59400 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
59401 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
59402 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
59403 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
59404 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
59405 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59406 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59407 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
59408 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59409 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59410 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59411 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59412 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
59413 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
59414 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
59415 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
59416 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
59417 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
59418 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
59419 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
59420 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59421 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
59422 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59423 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
59424 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
59425 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
59426 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59427 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
59428 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
59429 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
59430 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
59431 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
59432 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
59433 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
59434 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
59435 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
59436 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
59437 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
59438 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
59439 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
59440 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
59441 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
59442 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
59443 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
59444 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
59445 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59446 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
59447 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
59448 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59449 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59450 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59451 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59452 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59453 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
59454 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
59455 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
59456 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
59457 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
59458 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
59459 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
59460 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
59461 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
59462 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59463 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
59464 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
59465 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
59466 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
59467 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
59468 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
59469 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59470 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
59471 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
59472 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
59473 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
59474 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
59475 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
59476 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
59477 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
59478 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
59479 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
59480 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59481 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
59482 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
59483 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
59484 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
59485 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59486 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
59487 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59488 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
59489 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
59490 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
59491 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59492 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
59493 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
59494 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
59495 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
59496 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
59497 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
59498 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
59499 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
59500 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59501 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
59502 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
59503 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
59504 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
59505 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
59506 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
59507 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
59508 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59509 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
59510 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
59511 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
59512 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
59513 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59514 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
59515 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
59516 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59517 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
59518 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
59519 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
59520 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
59521 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
59522 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
59523 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
59524 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
59525 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
59526 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59527 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
59528 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
59529 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
59530 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
59531 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
59532 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
59533 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
59534 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
59535 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59536 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
59537 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
59538 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
59539 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
59540 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
59541 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59542 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
59543 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
59544 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
59545 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59546 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
59547 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59548 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59549 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59550 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59551 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
59552 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59553 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59554 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
59555 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59556 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
59557 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59558 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59559 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59560 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59561 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
59562 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
59563 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
59564 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59565 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59566 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
59567 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59568 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
59569 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
59570 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
59571 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
59572 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
59573 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
59574 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
59575 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59576 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59577 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59578 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59579 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59580 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59581 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59582 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59583 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59584 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59585 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
59586 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
59587 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
59588 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
59589 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59590 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
59591 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
59592 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
59593 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
59594 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59595 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
59596 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
59597 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
59598 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
59599 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
59600 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
59601 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
59602 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59603 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59604 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
59605 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59606 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
59607 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59608 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
59609 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
59610 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59611 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
59612 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59613 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
59614 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59615 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59616 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59617 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
59618 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
59619 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59620 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
59621 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59622 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
59623 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
59624 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
59625 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
59626 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
59627 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
59628 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59629 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
59630 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
59631 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
59632 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
59633 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
59634 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
59635 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59636 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
59637 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
59638 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
59639 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
59640 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
59641 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
59642 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
59643 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
59644 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
59645 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
59646 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
59647 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
59648 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
59649 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
59650 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
59651 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
59652 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
59653 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
59654 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
59655 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
59656 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
59657 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
59658 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
59659 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59660 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
59661 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
59662 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
59663 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
59664 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
59665 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
59666 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
59667 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
59668 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
59669 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
59670 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
59671 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
59672 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
59673 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
59674 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
59675 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
59676 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
59677 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
59678 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
59679 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
59680 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
59681 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
59682 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
59683 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
59684 { (char *)"Control_RemoveMnemonics", (PyCFunction) _wrap_Control_RemoveMnemonics, METH_VARARGS | METH_KEYWORDS, NULL},
59685 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
59686 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
59687 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
59688 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
59689 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
59690 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59691 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
59692 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
59693 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59694 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
59695 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
59696 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
59697 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
59698 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
59699 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
59700 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
59701 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59702 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
59703 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
59704 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
59705 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
59706 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
59707 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
59708 { (char *)"new_SizerFlags", (PyCFunction) _wrap_new_SizerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
59709 { (char *)"delete_SizerFlags", (PyCFunction)_wrap_delete_SizerFlags, METH_O, NULL},
59710 { (char *)"SizerFlags_Proportion", (PyCFunction) _wrap_SizerFlags_Proportion, METH_VARARGS | METH_KEYWORDS, NULL},
59711 { (char *)"SizerFlags_Align", (PyCFunction) _wrap_SizerFlags_Align, METH_VARARGS | METH_KEYWORDS, NULL},
59712 { (char *)"SizerFlags_Expand", (PyCFunction)_wrap_SizerFlags_Expand, METH_O, NULL},
59713 { (char *)"SizerFlags_Centre", (PyCFunction)_wrap_SizerFlags_Centre, METH_O, NULL},
59714 { (char *)"SizerFlags_Center", (PyCFunction)_wrap_SizerFlags_Center, METH_O, NULL},
59715 { (char *)"SizerFlags_Left", (PyCFunction)_wrap_SizerFlags_Left, METH_O, NULL},
59716 { (char *)"SizerFlags_Right", (PyCFunction)_wrap_SizerFlags_Right, METH_O, NULL},
59717 { (char *)"SizerFlags_Top", (PyCFunction)_wrap_SizerFlags_Top, METH_O, NULL},
59718 { (char *)"SizerFlags_Bottom", (PyCFunction)_wrap_SizerFlags_Bottom, METH_O, NULL},
59719 { (char *)"SizerFlags_Shaped", (PyCFunction)_wrap_SizerFlags_Shaped, METH_O, NULL},
59720 { (char *)"SizerFlags_FixedMinSize", (PyCFunction)_wrap_SizerFlags_FixedMinSize, METH_O, NULL},
59721 { (char *)"SizerFlags_Border", (PyCFunction) _wrap_SizerFlags_Border, METH_VARARGS | METH_KEYWORDS, NULL},
59722 { (char *)"SizerFlags_DoubleBorder", (PyCFunction) _wrap_SizerFlags_DoubleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59723 { (char *)"SizerFlags_TripleBorder", (PyCFunction) _wrap_SizerFlags_TripleBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59724 { (char *)"SizerFlags_HorzBorder", (PyCFunction)_wrap_SizerFlags_HorzBorder, METH_O, NULL},
59725 { (char *)"SizerFlags_DoubleHorzBorder", (PyCFunction)_wrap_SizerFlags_DoubleHorzBorder, METH_O, NULL},
59726 { (char *)"SizerFlags_GetDefaultBorder", (PyCFunction)_wrap_SizerFlags_GetDefaultBorder, METH_NOARGS, NULL},
59727 { (char *)"SizerFlags_GetProportion", (PyCFunction)_wrap_SizerFlags_GetProportion, METH_O, NULL},
59728 { (char *)"SizerFlags_GetFlags", (PyCFunction)_wrap_SizerFlags_GetFlags, METH_O, NULL},
59729 { (char *)"SizerFlags_GetBorderInPixels", (PyCFunction)_wrap_SizerFlags_GetBorderInPixels, METH_O, NULL},
59730 { (char *)"SizerFlags_swigregister", SizerFlags_swigregister, METH_VARARGS, NULL},
59731 { (char *)"SizerFlags_swiginit", SizerFlags_swiginit, METH_VARARGS, NULL},
59732 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
59733 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
59734 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59735 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59736 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59737 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
59738 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
59739 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
59740 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
59741 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59742 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
59743 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
59744 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
59745 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
59746 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
59747 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
59748 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
59749 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
59750 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
59751 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
59752 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
59753 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
59754 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
59755 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
59756 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
59757 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
59758 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
59759 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
59760 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
59761 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
59762 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59763 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59764 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59765 { (char *)"SizerItem_AssignWindow", (PyCFunction) _wrap_SizerItem_AssignWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59766 { (char *)"SizerItem_AssignSizer", (PyCFunction) _wrap_SizerItem_AssignSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59767 { (char *)"SizerItem_AssignSpacer", (PyCFunction) _wrap_SizerItem_AssignSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59768 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59769 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
59770 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
59771 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
59772 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
59773 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
59774 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
59775 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
59776 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59777 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59778 { (char *)"Sizer_AddF", (PyCFunction) _wrap_Sizer_AddF, METH_VARARGS | METH_KEYWORDS, NULL},
59779 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
59780 { (char *)"Sizer_InsertF", (PyCFunction) _wrap_Sizer_InsertF, METH_VARARGS | METH_KEYWORDS, NULL},
59781 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
59782 { (char *)"Sizer_PrependF", (PyCFunction) _wrap_Sizer_PrependF, METH_VARARGS | METH_KEYWORDS, NULL},
59783 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
59784 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
59785 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
59786 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59787 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
59788 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59789 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
59790 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59791 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
59792 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59793 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
59794 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
59795 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
59796 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
59797 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
59798 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
59799 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
59800 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
59801 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
59802 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
59803 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
59804 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
59805 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59806 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
59807 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
59808 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
59809 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
59810 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
59811 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
59812 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
59813 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
59814 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
59815 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
59816 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
59817 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
59818 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59819 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
59820 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
59821 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
59822 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
59823 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59824 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
59825 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
59826 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
59827 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59828 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
59829 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
59830 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
59831 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
59832 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
59833 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
59834 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
59835 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
59836 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
59837 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
59838 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59839 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59840 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
59841 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59842 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
59843 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
59844 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
59845 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
59846 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
59847 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
59848 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
59849 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
59850 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
59851 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
59852 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
59853 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
59854 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59855 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
59856 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
59857 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
59858 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
59859 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
59860 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
59861 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
59862 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
59863 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
59864 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59865 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
59866 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
59867 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
59868 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
59869 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
59870 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59871 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59872 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59873 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
59874 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
59875 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
59876 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59877 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
59878 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
59879 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
59880 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
59881 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
59882 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
59883 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
59884 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59885 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
59886 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
59887 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
59888 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
59889 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
59890 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
59891 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59892 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
59893 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
59894 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
59895 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
59896 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
59897 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
59898 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
59899 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
59900 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
59901 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59902 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
59903 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
59904 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
59905 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
59906 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
59907 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59908 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
59909 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
59910 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
59911 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
59912 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
59913 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
59914 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
59915 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
59916 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
59917 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
59918 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
59919 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
59920 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
59921 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
59922 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
59923 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
59924 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
59925 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
59926 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
59927 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
59928 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
59929 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
59930 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
59931 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
59932 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
59933 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59934 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
59935 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
59936 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
59937 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
59938 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
59939 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
59940 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
59941 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
59942 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
59943 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
59944 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
59945 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
59946 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
59947 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
59948 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
59949 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
59950 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
59951 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
59952 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
59953 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
59954 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
59955 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
59956 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
59957 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
59958 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
59959 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
59960 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
59961 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
59962 { NULL, NULL, 0, NULL }
59963 };
59964
59965
59966 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
59967
59968 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
59969 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
59970 }
59971 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
59972 return (void *)((wxEvent *) ((wxMenuEvent *) x));
59973 }
59974 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
59975 return (void *)((wxEvent *) ((wxCloseEvent *) x));
59976 }
59977 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
59978 return (void *)((wxEvent *) ((wxMouseEvent *) x));
59979 }
59980 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
59981 return (void *)((wxEvent *) ((wxEraseEvent *) x));
59982 }
59983 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
59984 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
59985 }
59986 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
59987 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
59988 }
59989 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
59990 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
59991 }
59992 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
59993 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
59994 }
59995 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
59996 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
59997 }
59998 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
59999 return (void *)((wxEvent *) ((wxPyEvent *) x));
60000 }
60001 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
60002 return (void *)((wxEvent *) ((wxIdleEvent *) x));
60003 }
60004 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
60005 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
60006 }
60007 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
60008 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
60009 }
60010 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
60011 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
60012 }
60013 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
60014 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
60015 }
60016 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
60017 return (void *)((wxEvent *) ((wxActivateEvent *) x));
60018 }
60019 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
60020 return (void *)((wxEvent *) ((wxSizeEvent *) x));
60021 }
60022 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
60023 return (void *)((wxEvent *) ((wxMoveEvent *) x));
60024 }
60025 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
60026 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
60027 }
60028 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
60029 return (void *)((wxEvent *) ((wxPaintEvent *) x));
60030 }
60031 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
60032 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
60033 }
60034 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
60035 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
60036 }
60037 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
60038 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
60039 }
60040 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
60041 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
60042 }
60043 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
60044 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
60045 }
60046 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
60047 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60048 }
60049 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
60050 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
60051 }
60052 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
60053 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
60054 }
60055 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
60056 return (void *)((wxEvent *) ((wxFocusEvent *) x));
60057 }
60058 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
60059 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
60060 }
60061 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
60062 return (void *)((wxEvent *) ((wxShowEvent *) x));
60063 }
60064 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
60065 return (void *)((wxEvent *) ((wxCommandEvent *) x));
60066 }
60067 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
60068 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
60069 }
60070 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
60071 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60072 }
60073 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
60074 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
60075 }
60076 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
60077 return (void *)((wxEvent *) ((wxKeyEvent *) x));
60078 }
60079 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
60080 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
60081 }
60082 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
60083 return (void *)((wxValidator *) ((wxPyValidator *) x));
60084 }
60085 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
60086 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
60087 }
60088 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
60089 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
60090 }
60091 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
60092 return (void *)((wxObject *) ((wxSizerItem *) x));
60093 }
60094 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
60095 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
60096 }
60097 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
60098 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
60099 }
60100 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
60101 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
60102 }
60103 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
60104 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
60105 }
60106 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
60107 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
60108 }
60109 static void *_p_wxSizerTo_p_wxObject(void *x) {
60110 return (void *)((wxObject *) ((wxSizer *) x));
60111 }
60112 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
60113 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60114 }
60115 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
60116 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
60117 }
60118 static void *_p_wxEventTo_p_wxObject(void *x) {
60119 return (void *)((wxObject *) ((wxEvent *) x));
60120 }
60121 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
60122 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
60123 }
60124 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
60125 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
60126 }
60127 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
60128 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
60129 }
60130 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
60131 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
60132 }
60133 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
60134 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
60135 }
60136 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
60137 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
60138 }
60139 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
60140 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
60141 }
60142 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
60143 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
60144 }
60145 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
60146 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
60147 }
60148 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
60149 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
60150 }
60151 static void *_p_wxControlTo_p_wxObject(void *x) {
60152 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
60153 }
60154 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
60155 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
60156 }
60157 static void *_p_wxFSFileTo_p_wxObject(void *x) {
60158 return (void *)((wxObject *) ((wxFSFile *) x));
60159 }
60160 static void *_p_wxPySizerTo_p_wxObject(void *x) {
60161 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
60162 }
60163 static void *_p_wxPyEventTo_p_wxObject(void *x) {
60164 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
60165 }
60166 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
60167 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
60168 }
60169 static void *_p_wxShowEventTo_p_wxObject(void *x) {
60170 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
60171 }
60172 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
60173 return (void *)((wxObject *) ((wxMenuItem *) x));
60174 }
60175 static void *_p_wxDateEventTo_p_wxObject(void *x) {
60176 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
60177 }
60178 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
60179 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
60180 }
60181 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
60182 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
60183 }
60184 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
60185 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
60186 }
60187 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
60188 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
60189 }
60190 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
60191 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
60192 }
60193 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
60194 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
60195 }
60196 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
60197 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
60198 }
60199 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
60200 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
60201 }
60202 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
60203 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
60204 }
60205 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
60206 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
60207 }
60208 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
60209 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
60210 }
60211 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
60212 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
60213 }
60214 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
60215 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
60216 }
60217 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
60218 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60219 }
60220 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
60221 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60222 }
60223 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
60224 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
60225 }
60226 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
60227 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
60228 }
60229 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
60230 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
60231 }
60232 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
60233 return (void *)((wxObject *) ((wxImageHandler *) x));
60234 }
60235 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
60236 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
60237 }
60238 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
60239 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
60240 }
60241 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
60242 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
60243 }
60244 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
60245 return (void *)((wxObject *) ((wxEvtHandler *) x));
60246 }
60247 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
60248 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
60249 }
60250 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
60251 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
60252 }
60253 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
60254 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60255 }
60256 static void *_p_wxImageTo_p_wxObject(void *x) {
60257 return (void *)((wxObject *) ((wxImage *) x));
60258 }
60259 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
60260 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
60261 }
60262 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
60263 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60264 }
60265 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
60266 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
60267 }
60268 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
60269 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
60270 }
60271 static void *_p_wxWindowTo_p_wxObject(void *x) {
60272 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
60273 }
60274 static void *_p_wxMenuTo_p_wxObject(void *x) {
60275 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
60276 }
60277 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
60278 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
60279 }
60280 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
60281 return (void *)((wxObject *) ((wxFileSystem *) x));
60282 }
60283 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
60284 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
60285 }
60286 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
60287 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
60288 }
60289 static void *_p_wxPyAppTo_p_wxObject(void *x) {
60290 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
60291 }
60292 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
60293 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
60294 }
60295 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
60296 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
60297 }
60298 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
60299 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
60300 }
60301 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
60302 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
60303 }
60304 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
60305 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
60306 }
60307 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
60308 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
60309 }
60310 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
60311 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
60312 }
60313 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
60314 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
60315 }
60316 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
60317 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60318 }
60319 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
60320 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
60321 }
60322 static void *_p_wxValidatorTo_p_wxObject(void *x) {
60323 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
60324 }
60325 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
60326 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
60327 }
60328 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
60329 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
60330 }
60331 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
60332 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
60333 }
60334 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
60335 return (void *)((wxControl *) ((wxControlWithItems *) x));
60336 }
60337 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
60338 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
60339 }
60340 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
60341 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
60342 }
60343 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
60344 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60345 }
60346 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
60347 return (void *)((wxSizer *) ((wxBoxSizer *) x));
60348 }
60349 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
60350 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
60351 }
60352 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
60353 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
60354 }
60355 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
60356 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
60357 }
60358 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
60359 return (void *)((wxSizer *) ((wxGridSizer *) x));
60360 }
60361 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
60362 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
60363 }
60364 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
60365 return (void *)((wxSizer *) ((wxPySizer *) x));
60366 }
60367 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
60368 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
60369 }
60370 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
60371 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
60372 }
60373 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
60374 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
60375 }
60376 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
60377 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
60378 }
60379 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
60380 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
60381 }
60382 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
60383 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
60384 }
60385 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
60386 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
60387 }
60388 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
60389 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
60390 }
60391 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
60392 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
60393 }
60394 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
60395 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60396 }
60397 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
60398 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
60399 }
60400 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
60401 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
60402 }
60403 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
60404 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
60405 }
60406 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
60407 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
60408 }
60409 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
60410 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
60411 }
60412 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
60413 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
60414 }
60415 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
60416 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
60417 }
60418 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
60419 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
60420 }
60421 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
60422 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
60423 }
60424 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
60425 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
60426 }
60427 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
60428 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
60429 }
60430 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
60431 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
60432 }
60433 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
60434 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
60435 }
60436 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
60437 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
60438 }
60439 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
60440 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
60441 }
60442 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
60443 return (void *)((wxEvtHandler *) ((wxWindow *) x));
60444 }
60445 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
60446 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
60447 }
60448 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
60449 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
60450 }
60451 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
60452 return (void *)((wxEvtHandler *) ((wxValidator *) x));
60453 }
60454 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
60455 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
60456 }
60457 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
60458 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
60459 }
60460 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
60461 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
60462 }
60463 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
60464 return (void *)((wxEvtHandler *) ((wxMenu *) x));
60465 }
60466 static void *_p_wxControlTo_p_wxWindow(void *x) {
60467 return (void *)((wxWindow *) ((wxControl *) x));
60468 }
60469 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
60470 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
60471 }
60472 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
60473 return (void *)((wxWindow *) ((wxMenuBar *) x));
60474 }
60475 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
60476 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
60477 }
60478 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
60479 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
60480 }
60481 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
60482 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
60483 }
60484 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
60485 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
60486 }
60487 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
60488 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
60489 }
60490 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
60491 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
60492 }
60493 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
60494 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
60495 }
60496 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
60497 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
60498 }
60499 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
60500 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
60501 }
60502 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
60503 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
60504 }
60505 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
60506 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
60507 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};
60508 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
60509 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
60510 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
60511 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
60512 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
60513 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
60514 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
60515 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
60516 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
60517 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
60518 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
60519 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
60520 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
60521 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
60522 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
60523 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
60524 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
60525 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
60526 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
60527 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
60528 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
60529 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
60530 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
60531 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
60532 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
60533 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
60534 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
60535 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
60536 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
60537 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
60538 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
60539 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
60540 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
60541 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
60542 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
60543 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
60544 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
60545 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
60546 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
60547 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
60548 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
60549 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
60550 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
60551 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
60552 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
60553 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
60554 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
60555 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
60556 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
60557 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
60558 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
60559 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
60560 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
60561 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
60562 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
60563 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
60564 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
60565 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
60566 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
60567 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
60568 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
60569 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
60570 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
60571 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
60572 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
60573 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
60574 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
60575 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
60576 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
60577 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
60578 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
60579 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
60580 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
60581 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
60582 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
60583 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
60584 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
60585 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
60586 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
60587 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
60588 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
60589 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
60590 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
60591 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
60592 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
60593 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
60594 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
60595 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
60596 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
60597 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
60598 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
60599 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
60600 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
60601 static swig_type_info _swigt__p_wxPosition = {"_p_wxPosition", "wxPosition *", 0, 0, (void*)0, 0};
60602 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
60603 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
60604 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
60605 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
60606 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
60607 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
60608 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
60609 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
60610 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
60611 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
60612 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
60613 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
60614 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
60615 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
60616 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
60617 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
60618 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
60619 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
60620 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
60621 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
60622 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
60623 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
60624 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
60625 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
60626 static swig_type_info _swigt__p_wxSizerFlags = {"_p_wxSizerFlags", "wxSizerFlags *", 0, 0, (void*)0, 0};
60627 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
60628 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
60629 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
60630 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
60631 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
60632 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
60633 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
60634 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
60635 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
60636 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
60637 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
60638 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
60639 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
60640 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
60641 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
60642 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
60643
60644 static swig_type_info *swig_type_initial[] = {
60645 &_swigt__p_buffer,
60646 &_swigt__p_char,
60647 &_swigt__p_form_ops_t,
60648 &_swigt__p_int,
60649 &_swigt__p_long,
60650 &_swigt__p_unsigned_char,
60651 &_swigt__p_unsigned_int,
60652 &_swigt__p_unsigned_long,
60653 &_swigt__p_wxANIHandler,
60654 &_swigt__p_wxAcceleratorEntry,
60655 &_swigt__p_wxAcceleratorTable,
60656 &_swigt__p_wxActivateEvent,
60657 &_swigt__p_wxAppTraits,
60658 &_swigt__p_wxArrayString,
60659 &_swigt__p_wxBMPHandler,
60660 &_swigt__p_wxBitmap,
60661 &_swigt__p_wxBoxSizer,
60662 &_swigt__p_wxButton,
60663 &_swigt__p_wxCURHandler,
60664 &_swigt__p_wxCaret,
60665 &_swigt__p_wxChildFocusEvent,
60666 &_swigt__p_wxClipboardTextEvent,
60667 &_swigt__p_wxCloseEvent,
60668 &_swigt__p_wxColour,
60669 &_swigt__p_wxCommandEvent,
60670 &_swigt__p_wxContextMenuEvent,
60671 &_swigt__p_wxControl,
60672 &_swigt__p_wxControlWithItems,
60673 &_swigt__p_wxCursor,
60674 &_swigt__p_wxDC,
60675 &_swigt__p_wxDateEvent,
60676 &_swigt__p_wxDateTime,
60677 &_swigt__p_wxDisplayChangedEvent,
60678 &_swigt__p_wxDouble,
60679 &_swigt__p_wxDropFilesEvent,
60680 &_swigt__p_wxDuplexMode,
60681 &_swigt__p_wxEraseEvent,
60682 &_swigt__p_wxEvent,
60683 &_swigt__p_wxEventBlocker,
60684 &_swigt__p_wxEventLoop,
60685 &_swigt__p_wxEventLoopActivator,
60686 &_swigt__p_wxEvtHandler,
60687 &_swigt__p_wxFSFile,
60688 &_swigt__p_wxFileSystem,
60689 &_swigt__p_wxFileSystemHandler,
60690 &_swigt__p_wxFlexGridSizer,
60691 &_swigt__p_wxFocusEvent,
60692 &_swigt__p_wxFont,
60693 &_swigt__p_wxFrame,
60694 &_swigt__p_wxGBPosition,
60695 &_swigt__p_wxGBSizerItem,
60696 &_swigt__p_wxGBSpan,
60697 &_swigt__p_wxGIFHandler,
60698 &_swigt__p_wxGridBagSizer,
60699 &_swigt__p_wxGridSizer,
60700 &_swigt__p_wxHelpEvent__Origin,
60701 &_swigt__p_wxICOHandler,
60702 &_swigt__p_wxIconizeEvent,
60703 &_swigt__p_wxIdleEvent,
60704 &_swigt__p_wxImage,
60705 &_swigt__p_wxImageHandler,
60706 &_swigt__p_wxImageHistogram,
60707 &_swigt__p_wxImage_HSVValue,
60708 &_swigt__p_wxImage_RGBValue,
60709 &_swigt__p_wxIndividualLayoutConstraint,
60710 &_swigt__p_wxInitDialogEvent,
60711 &_swigt__p_wxInputStream,
60712 &_swigt__p_wxInternetFSHandler,
60713 &_swigt__p_wxItemContainer,
60714 &_swigt__p_wxJPEGHandler,
60715 &_swigt__p_wxKeyEvent,
60716 &_swigt__p_wxLayoutConstraints,
60717 &_swigt__p_wxMaximizeEvent,
60718 &_swigt__p_wxMemoryFSHandler,
60719 &_swigt__p_wxMenu,
60720 &_swigt__p_wxMenuBar,
60721 &_swigt__p_wxMenuBarBase,
60722 &_swigt__p_wxMenuEvent,
60723 &_swigt__p_wxMenuItem,
60724 &_swigt__p_wxMouseCaptureChangedEvent,
60725 &_swigt__p_wxMouseCaptureLostEvent,
60726 &_swigt__p_wxMouseEvent,
60727 &_swigt__p_wxMoveEvent,
60728 &_swigt__p_wxNavigationKeyEvent,
60729 &_swigt__p_wxNcPaintEvent,
60730 &_swigt__p_wxNotifyEvent,
60731 &_swigt__p_wxObject,
60732 &_swigt__p_wxOutputStream,
60733 &_swigt__p_wxPCXHandler,
60734 &_swigt__p_wxPNGHandler,
60735 &_swigt__p_wxPNMHandler,
60736 &_swigt__p_wxPaintEvent,
60737 &_swigt__p_wxPaletteChangedEvent,
60738 &_swigt__p_wxPaperSize,
60739 &_swigt__p_wxPoint,
60740 &_swigt__p_wxPoint2D,
60741 &_swigt__p_wxPosition,
60742 &_swigt__p_wxPropagateOnce,
60743 &_swigt__p_wxPropagationDisabler,
60744 &_swigt__p_wxPyApp,
60745 &_swigt__p_wxPyCommandEvent,
60746 &_swigt__p_wxPyDropTarget,
60747 &_swigt__p_wxPyEvent,
60748 &_swigt__p_wxPyFileSystemHandler,
60749 &_swigt__p_wxPyImageHandler,
60750 &_swigt__p_wxPyInputStream,
60751 &_swigt__p_wxPySizer,
60752 &_swigt__p_wxPyValidator,
60753 &_swigt__p_wxQuantize,
60754 &_swigt__p_wxQueryNewPaletteEvent,
60755 &_swigt__p_wxRealPoint,
60756 &_swigt__p_wxRect,
60757 &_swigt__p_wxRect2D,
60758 &_swigt__p_wxRegion,
60759 &_swigt__p_wxScrollEvent,
60760 &_swigt__p_wxScrollWinEvent,
60761 &_swigt__p_wxSetCursorEvent,
60762 &_swigt__p_wxShowEvent,
60763 &_swigt__p_wxSize,
60764 &_swigt__p_wxSizeEvent,
60765 &_swigt__p_wxSizer,
60766 &_swigt__p_wxSizerFlags,
60767 &_swigt__p_wxSizerItem,
60768 &_swigt__p_wxStaticBox,
60769 &_swigt__p_wxStaticBoxSizer,
60770 &_swigt__p_wxStdDialogButtonSizer,
60771 &_swigt__p_wxSysColourChangedEvent,
60772 &_swigt__p_wxTGAHandler,
60773 &_swigt__p_wxTIFFHandler,
60774 &_swigt__p_wxToolTip,
60775 &_swigt__p_wxUpdateUIEvent,
60776 &_swigt__p_wxValidator,
60777 &_swigt__p_wxVisualAttributes,
60778 &_swigt__p_wxWindow,
60779 &_swigt__p_wxWindowCreateEvent,
60780 &_swigt__p_wxWindowDestroyEvent,
60781 &_swigt__p_wxXPMHandler,
60782 &_swigt__p_wxZipFSHandler,
60783 };
60784
60785 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
60786 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
60787 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
60788 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
60789 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
60790 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
60791 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
60792 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
60793 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
60794 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
60795 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
60796 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
60797 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
60798 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
60799 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}};
60800 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
60801 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}};
60802 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
60803 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}};
60804 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
60805 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60806 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
60807 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
60808 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
60809 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}};
60810 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60811 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}};
60812 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
60813 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
60814 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
60815 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
60816 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
60817 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60818 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
60819 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
60820 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
60821 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
60822 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}};
60823 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
60824 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
60825 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
60826 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}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
60827 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
60828 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
60829 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}};
60830 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}};
60831 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
60832 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
60833 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
60834 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
60835 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
60836 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
60837 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
60838 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
60839 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}};
60840 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
60841 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}};
60842 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60843 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
60844 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
60845 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_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}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60846 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
60847 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
60848 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
60849 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
60850 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
60851 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
60852 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60853 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}};
60854 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
60855 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60856 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
60857 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60858 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60859 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
60860 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
60861 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
60862 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
60863 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
60864 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60865 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
60866 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
60867 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
60868 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
60869 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60870 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
60871 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_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_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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_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}};
60872 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
60873 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
60874 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
60875 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
60876 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
60877 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60878 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
60879 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
60880 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
60881 static swig_cast_info _swigc__p_wxPosition[] = { {&_swigt__p_wxPosition, 0, 0, 0},{0, 0, 0, 0}};
60882 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
60883 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
60884 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
60885 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
60886 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
60887 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
60888 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
60889 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
60890 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
60891 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
60892 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
60893 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
60894 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
60895 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
60896 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
60897 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
60898 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
60899 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
60900 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
60901 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
60902 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
60903 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
60904 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
60905 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}};
60906 static swig_cast_info _swigc__p_wxSizerFlags[] = { {&_swigt__p_wxSizerFlags, 0, 0, 0},{0, 0, 0, 0}};
60907 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}};
60908 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
60909 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
60910 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
60911 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
60912 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
60913 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
60914 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
60915 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
60916 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}};
60917 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
60918 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}};
60919 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
60920 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
60921 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
60922 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
60923
60924 static swig_cast_info *swig_cast_initial[] = {
60925 _swigc__p_buffer,
60926 _swigc__p_char,
60927 _swigc__p_form_ops_t,
60928 _swigc__p_int,
60929 _swigc__p_long,
60930 _swigc__p_unsigned_char,
60931 _swigc__p_unsigned_int,
60932 _swigc__p_unsigned_long,
60933 _swigc__p_wxANIHandler,
60934 _swigc__p_wxAcceleratorEntry,
60935 _swigc__p_wxAcceleratorTable,
60936 _swigc__p_wxActivateEvent,
60937 _swigc__p_wxAppTraits,
60938 _swigc__p_wxArrayString,
60939 _swigc__p_wxBMPHandler,
60940 _swigc__p_wxBitmap,
60941 _swigc__p_wxBoxSizer,
60942 _swigc__p_wxButton,
60943 _swigc__p_wxCURHandler,
60944 _swigc__p_wxCaret,
60945 _swigc__p_wxChildFocusEvent,
60946 _swigc__p_wxClipboardTextEvent,
60947 _swigc__p_wxCloseEvent,
60948 _swigc__p_wxColour,
60949 _swigc__p_wxCommandEvent,
60950 _swigc__p_wxContextMenuEvent,
60951 _swigc__p_wxControl,
60952 _swigc__p_wxControlWithItems,
60953 _swigc__p_wxCursor,
60954 _swigc__p_wxDC,
60955 _swigc__p_wxDateEvent,
60956 _swigc__p_wxDateTime,
60957 _swigc__p_wxDisplayChangedEvent,
60958 _swigc__p_wxDouble,
60959 _swigc__p_wxDropFilesEvent,
60960 _swigc__p_wxDuplexMode,
60961 _swigc__p_wxEraseEvent,
60962 _swigc__p_wxEvent,
60963 _swigc__p_wxEventBlocker,
60964 _swigc__p_wxEventLoop,
60965 _swigc__p_wxEventLoopActivator,
60966 _swigc__p_wxEvtHandler,
60967 _swigc__p_wxFSFile,
60968 _swigc__p_wxFileSystem,
60969 _swigc__p_wxFileSystemHandler,
60970 _swigc__p_wxFlexGridSizer,
60971 _swigc__p_wxFocusEvent,
60972 _swigc__p_wxFont,
60973 _swigc__p_wxFrame,
60974 _swigc__p_wxGBPosition,
60975 _swigc__p_wxGBSizerItem,
60976 _swigc__p_wxGBSpan,
60977 _swigc__p_wxGIFHandler,
60978 _swigc__p_wxGridBagSizer,
60979 _swigc__p_wxGridSizer,
60980 _swigc__p_wxHelpEvent__Origin,
60981 _swigc__p_wxICOHandler,
60982 _swigc__p_wxIconizeEvent,
60983 _swigc__p_wxIdleEvent,
60984 _swigc__p_wxImage,
60985 _swigc__p_wxImageHandler,
60986 _swigc__p_wxImageHistogram,
60987 _swigc__p_wxImage_HSVValue,
60988 _swigc__p_wxImage_RGBValue,
60989 _swigc__p_wxIndividualLayoutConstraint,
60990 _swigc__p_wxInitDialogEvent,
60991 _swigc__p_wxInputStream,
60992 _swigc__p_wxInternetFSHandler,
60993 _swigc__p_wxItemContainer,
60994 _swigc__p_wxJPEGHandler,
60995 _swigc__p_wxKeyEvent,
60996 _swigc__p_wxLayoutConstraints,
60997 _swigc__p_wxMaximizeEvent,
60998 _swigc__p_wxMemoryFSHandler,
60999 _swigc__p_wxMenu,
61000 _swigc__p_wxMenuBar,
61001 _swigc__p_wxMenuBarBase,
61002 _swigc__p_wxMenuEvent,
61003 _swigc__p_wxMenuItem,
61004 _swigc__p_wxMouseCaptureChangedEvent,
61005 _swigc__p_wxMouseCaptureLostEvent,
61006 _swigc__p_wxMouseEvent,
61007 _swigc__p_wxMoveEvent,
61008 _swigc__p_wxNavigationKeyEvent,
61009 _swigc__p_wxNcPaintEvent,
61010 _swigc__p_wxNotifyEvent,
61011 _swigc__p_wxObject,
61012 _swigc__p_wxOutputStream,
61013 _swigc__p_wxPCXHandler,
61014 _swigc__p_wxPNGHandler,
61015 _swigc__p_wxPNMHandler,
61016 _swigc__p_wxPaintEvent,
61017 _swigc__p_wxPaletteChangedEvent,
61018 _swigc__p_wxPaperSize,
61019 _swigc__p_wxPoint,
61020 _swigc__p_wxPoint2D,
61021 _swigc__p_wxPosition,
61022 _swigc__p_wxPropagateOnce,
61023 _swigc__p_wxPropagationDisabler,
61024 _swigc__p_wxPyApp,
61025 _swigc__p_wxPyCommandEvent,
61026 _swigc__p_wxPyDropTarget,
61027 _swigc__p_wxPyEvent,
61028 _swigc__p_wxPyFileSystemHandler,
61029 _swigc__p_wxPyImageHandler,
61030 _swigc__p_wxPyInputStream,
61031 _swigc__p_wxPySizer,
61032 _swigc__p_wxPyValidator,
61033 _swigc__p_wxQuantize,
61034 _swigc__p_wxQueryNewPaletteEvent,
61035 _swigc__p_wxRealPoint,
61036 _swigc__p_wxRect,
61037 _swigc__p_wxRect2D,
61038 _swigc__p_wxRegion,
61039 _swigc__p_wxScrollEvent,
61040 _swigc__p_wxScrollWinEvent,
61041 _swigc__p_wxSetCursorEvent,
61042 _swigc__p_wxShowEvent,
61043 _swigc__p_wxSize,
61044 _swigc__p_wxSizeEvent,
61045 _swigc__p_wxSizer,
61046 _swigc__p_wxSizerFlags,
61047 _swigc__p_wxSizerItem,
61048 _swigc__p_wxStaticBox,
61049 _swigc__p_wxStaticBoxSizer,
61050 _swigc__p_wxStdDialogButtonSizer,
61051 _swigc__p_wxSysColourChangedEvent,
61052 _swigc__p_wxTGAHandler,
61053 _swigc__p_wxTIFFHandler,
61054 _swigc__p_wxToolTip,
61055 _swigc__p_wxUpdateUIEvent,
61056 _swigc__p_wxValidator,
61057 _swigc__p_wxVisualAttributes,
61058 _swigc__p_wxWindow,
61059 _swigc__p_wxWindowCreateEvent,
61060 _swigc__p_wxWindowDestroyEvent,
61061 _swigc__p_wxXPMHandler,
61062 _swigc__p_wxZipFSHandler,
61063 };
61064
61065
61066 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
61067
61068 static swig_const_info swig_const_table[] = {
61069 {0, 0, 0, 0.0, 0, 0}};
61070
61071 #ifdef __cplusplus
61072 }
61073 #endif
61074 /* -----------------------------------------------------------------------------
61075 * Type initialization:
61076 * This problem is tough by the requirement that no dynamic
61077 * memory is used. Also, since swig_type_info structures store pointers to
61078 * swig_cast_info structures and swig_cast_info structures store pointers back
61079 * to swig_type_info structures, we need some lookup code at initialization.
61080 * The idea is that swig generates all the structures that are needed.
61081 * The runtime then collects these partially filled structures.
61082 * The SWIG_InitializeModule function takes these initial arrays out of
61083 * swig_module, and does all the lookup, filling in the swig_module.types
61084 * array with the correct data and linking the correct swig_cast_info
61085 * structures together.
61086 *
61087 * The generated swig_type_info structures are assigned staticly to an initial
61088 * array. We just loop though that array, and handle each type individually.
61089 * First we lookup if this type has been already loaded, and if so, use the
61090 * loaded structure instead of the generated one. Then we have to fill in the
61091 * cast linked list. The cast data is initially stored in something like a
61092 * two-dimensional array. Each row corresponds to a type (there are the same
61093 * number of rows as there are in the swig_type_initial array). Each entry in
61094 * a column is one of the swig_cast_info structures for that type.
61095 * The cast_initial array is actually an array of arrays, because each row has
61096 * a variable number of columns. So to actually build the cast linked list,
61097 * we find the array of casts associated with the type, and loop through it
61098 * adding the casts to the list. The one last trick we need to do is making
61099 * sure the type pointer in the swig_cast_info struct is correct.
61100 *
61101 * First off, we lookup the cast->type name to see if it is already loaded.
61102 * There are three cases to handle:
61103 * 1) If the cast->type has already been loaded AND the type we are adding
61104 * casting info to has not been loaded (it is in this module), THEN we
61105 * replace the cast->type pointer with the type pointer that has already
61106 * been loaded.
61107 * 2) If BOTH types (the one we are adding casting info to, and the
61108 * cast->type) are loaded, THEN the cast info has already been loaded by
61109 * the previous module so we just ignore it.
61110 * 3) Finally, if cast->type has not already been loaded, then we add that
61111 * swig_cast_info to the linked list (because the cast->type) pointer will
61112 * be correct.
61113 * ----------------------------------------------------------------------------- */
61114
61115 #ifdef __cplusplus
61116 extern "C" {
61117 #if 0
61118 } /* c-mode */
61119 #endif
61120 #endif
61121
61122 #if 0
61123 #define SWIGRUNTIME_DEBUG
61124 #endif
61125
61126 SWIGRUNTIME void
61127 SWIG_InitializeModule(void *clientdata) {
61128 size_t i;
61129 swig_module_info *module_head;
61130 static int init_run = 0;
61131
61132 clientdata = clientdata;
61133
61134 if (init_run) return;
61135 init_run = 1;
61136
61137 /* Initialize the swig_module */
61138 swig_module.type_initial = swig_type_initial;
61139 swig_module.cast_initial = swig_cast_initial;
61140
61141 /* Try and load any already created modules */
61142 module_head = SWIG_GetModule(clientdata);
61143 if (module_head) {
61144 swig_module.next = module_head->next;
61145 module_head->next = &swig_module;
61146 } else {
61147 /* This is the first module loaded */
61148 swig_module.next = &swig_module;
61149 SWIG_SetModule(clientdata, &swig_module);
61150 }
61151
61152 /* Now work on filling in swig_module.types */
61153 #ifdef SWIGRUNTIME_DEBUG
61154 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
61155 #endif
61156 for (i = 0; i < swig_module.size; ++i) {
61157 swig_type_info *type = 0;
61158 swig_type_info *ret;
61159 swig_cast_info *cast;
61160
61161 #ifdef SWIGRUNTIME_DEBUG
61162 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61163 #endif
61164
61165 /* if there is another module already loaded */
61166 if (swig_module.next != &swig_module) {
61167 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
61168 }
61169 if (type) {
61170 /* Overwrite clientdata field */
61171 #ifdef SWIGRUNTIME_DEBUG
61172 printf("SWIG_InitializeModule: found type %s\n", type->name);
61173 #endif
61174 if (swig_module.type_initial[i]->clientdata) {
61175 type->clientdata = swig_module.type_initial[i]->clientdata;
61176 #ifdef SWIGRUNTIME_DEBUG
61177 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
61178 #endif
61179 }
61180 } else {
61181 type = swig_module.type_initial[i];
61182 }
61183
61184 /* Insert casting types */
61185 cast = swig_module.cast_initial[i];
61186 while (cast->type) {
61187 /* Don't need to add information already in the list */
61188 ret = 0;
61189 #ifdef SWIGRUNTIME_DEBUG
61190 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
61191 #endif
61192 if (swig_module.next != &swig_module) {
61193 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
61194 #ifdef SWIGRUNTIME_DEBUG
61195 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
61196 #endif
61197 }
61198 if (ret) {
61199 if (type == swig_module.type_initial[i]) {
61200 #ifdef SWIGRUNTIME_DEBUG
61201 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
61202 #endif
61203 cast->type = ret;
61204 ret = 0;
61205 } else {
61206 /* Check for casting already in the list */
61207 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
61208 #ifdef SWIGRUNTIME_DEBUG
61209 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
61210 #endif
61211 if (!ocast) ret = 0;
61212 }
61213 }
61214
61215 if (!ret) {
61216 #ifdef SWIGRUNTIME_DEBUG
61217 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
61218 #endif
61219 if (type->cast) {
61220 type->cast->prev = cast;
61221 cast->next = type->cast;
61222 }
61223 type->cast = cast;
61224 }
61225 cast++;
61226 }
61227 /* Set entry in modules->types array equal to the type */
61228 swig_module.types[i] = type;
61229 }
61230 swig_module.types[i] = 0;
61231
61232 #ifdef SWIGRUNTIME_DEBUG
61233 printf("**** SWIG_InitializeModule: Cast List ******\n");
61234 for (i = 0; i < swig_module.size; ++i) {
61235 int j = 0;
61236 swig_cast_info *cast = swig_module.cast_initial[i];
61237 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
61238 while (cast->type) {
61239 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
61240 cast++;
61241 ++j;
61242 }
61243 printf("---- Total casts: %d\n",j);
61244 }
61245 printf("**** SWIG_InitializeModule: Cast List ******\n");
61246 #endif
61247 }
61248
61249 /* This function will propagate the clientdata field of type to
61250 * any new swig_type_info structures that have been added into the list
61251 * of equivalent types. It is like calling
61252 * SWIG_TypeClientData(type, clientdata) a second time.
61253 */
61254 SWIGRUNTIME void
61255 SWIG_PropagateClientData(void) {
61256 size_t i;
61257 swig_cast_info *equiv;
61258 static int init_run = 0;
61259
61260 if (init_run) return;
61261 init_run = 1;
61262
61263 for (i = 0; i < swig_module.size; i++) {
61264 if (swig_module.types[i]->clientdata) {
61265 equiv = swig_module.types[i]->cast;
61266 while (equiv) {
61267 if (!equiv->converter) {
61268 if (equiv->type && !equiv->type->clientdata)
61269 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
61270 }
61271 equiv = equiv->next;
61272 }
61273 }
61274 }
61275 }
61276
61277 #ifdef __cplusplus
61278 #if 0
61279 {
61280 /* c-mode */
61281 #endif
61282 }
61283 #endif
61284
61285
61286
61287 #ifdef __cplusplus
61288 extern "C" {
61289 #endif
61290
61291 /* Python-specific SWIG API */
61292 #define SWIG_newvarlink() SWIG_Python_newvarlink()
61293 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
61294 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
61295
61296 /* -----------------------------------------------------------------------------
61297 * global variable support code.
61298 * ----------------------------------------------------------------------------- */
61299
61300 typedef struct swig_globalvar {
61301 char *name; /* Name of global variable */
61302 PyObject *(*get_attr)(void); /* Return the current value */
61303 int (*set_attr)(PyObject *); /* Set the value */
61304 struct swig_globalvar *next;
61305 } swig_globalvar;
61306
61307 typedef struct swig_varlinkobject {
61308 PyObject_HEAD
61309 swig_globalvar *vars;
61310 } swig_varlinkobject;
61311
61312 SWIGINTERN PyObject *
61313 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
61314 return PyString_FromString("<Swig global variables>");
61315 }
61316
61317 SWIGINTERN PyObject *
61318 swig_varlink_str(swig_varlinkobject *v) {
61319 PyObject *str = PyString_FromString("(");
61320 swig_globalvar *var;
61321 for (var = v->vars; var; var=var->next) {
61322 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
61323 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
61324 }
61325 PyString_ConcatAndDel(&str,PyString_FromString(")"));
61326 return str;
61327 }
61328
61329 SWIGINTERN int
61330 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
61331 PyObject *str = swig_varlink_str(v);
61332 fprintf(fp,"Swig global variables ");
61333 fprintf(fp,"%s\n", PyString_AsString(str));
61334 Py_DECREF(str);
61335 return 0;
61336 }
61337
61338 SWIGINTERN void
61339 swig_varlink_dealloc(swig_varlinkobject *v) {
61340 swig_globalvar *var = v->vars;
61341 while (var) {
61342 swig_globalvar *n = var->next;
61343 free(var->name);
61344 free(var);
61345 var = n;
61346 }
61347 }
61348
61349 SWIGINTERN PyObject *
61350 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
61351 PyObject *res = NULL;
61352 swig_globalvar *var = v->vars;
61353 while (var) {
61354 if (strcmp(var->name,n) == 0) {
61355 res = (*var->get_attr)();
61356 break;
61357 }
61358 var = var->next;
61359 }
61360 if (res == NULL && !PyErr_Occurred()) {
61361 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61362 }
61363 return res;
61364 }
61365
61366 SWIGINTERN int
61367 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
61368 int res = 1;
61369 swig_globalvar *var = v->vars;
61370 while (var) {
61371 if (strcmp(var->name,n) == 0) {
61372 res = (*var->set_attr)(p);
61373 break;
61374 }
61375 var = var->next;
61376 }
61377 if (res == 1 && !PyErr_Occurred()) {
61378 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
61379 }
61380 return res;
61381 }
61382
61383 SWIGINTERN PyTypeObject*
61384 swig_varlink_type(void) {
61385 static char varlink__doc__[] = "Swig var link object";
61386 static PyTypeObject varlink_type;
61387 static int type_init = 0;
61388 if (!type_init) {
61389 const PyTypeObject tmp
61390 = {
61391 PyObject_HEAD_INIT(NULL)
61392 0, /* Number of items in variable part (ob_size) */
61393 (char *)"swigvarlink", /* Type name (tp_name) */
61394 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
61395 0, /* Itemsize (tp_itemsize) */
61396 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
61397 (printfunc) swig_varlink_print, /* Print (tp_print) */
61398 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
61399 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
61400 0, /* tp_compare */
61401 (reprfunc) swig_varlink_repr, /* tp_repr */
61402 0, /* tp_as_number */
61403 0, /* tp_as_sequence */
61404 0, /* tp_as_mapping */
61405 0, /* tp_hash */
61406 0, /* tp_call */
61407 (reprfunc)swig_varlink_str, /* tp_str */
61408 0, /* tp_getattro */
61409 0, /* tp_setattro */
61410 0, /* tp_as_buffer */
61411 0, /* tp_flags */
61412 varlink__doc__, /* tp_doc */
61413 0, /* tp_traverse */
61414 0, /* tp_clear */
61415 0, /* tp_richcompare */
61416 0, /* tp_weaklistoffset */
61417 #if PY_VERSION_HEX >= 0x02020000
61418 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
61419 #endif
61420 #if PY_VERSION_HEX >= 0x02030000
61421 0, /* tp_del */
61422 #endif
61423 #ifdef COUNT_ALLOCS
61424 0,0,0,0 /* tp_alloc -> tp_next */
61425 #endif
61426 };
61427 varlink_type = tmp;
61428 varlink_type.ob_type = &PyType_Type;
61429 type_init = 1;
61430 }
61431 return &varlink_type;
61432 }
61433
61434 /* Create a variable linking object for use later */
61435 SWIGINTERN PyObject *
61436 SWIG_Python_newvarlink(void) {
61437 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
61438 if (result) {
61439 result->vars = 0;
61440 }
61441 return ((PyObject*) result);
61442 }
61443
61444 SWIGINTERN void
61445 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
61446 swig_varlinkobject *v = (swig_varlinkobject *) p;
61447 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
61448 if (gv) {
61449 size_t size = strlen(name)+1;
61450 gv->name = (char *)malloc(size);
61451 if (gv->name) {
61452 strncpy(gv->name,name,size);
61453 gv->get_attr = get_attr;
61454 gv->set_attr = set_attr;
61455 gv->next = v->vars;
61456 }
61457 }
61458 v->vars = gv;
61459 }
61460
61461 SWIGINTERN PyObject *
61462 SWIG_globals() {
61463 static PyObject *_SWIG_globals = 0;
61464 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
61465 return _SWIG_globals;
61466 }
61467
61468 /* -----------------------------------------------------------------------------
61469 * constants/methods manipulation
61470 * ----------------------------------------------------------------------------- */
61471
61472 /* Install Constants */
61473 SWIGINTERN void
61474 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
61475 PyObject *obj = 0;
61476 size_t i;
61477 for (i = 0; constants[i].type; ++i) {
61478 switch(constants[i].type) {
61479 case SWIG_PY_POINTER:
61480 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
61481 break;
61482 case SWIG_PY_BINARY:
61483 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
61484 break;
61485 default:
61486 obj = 0;
61487 break;
61488 }
61489 if (obj) {
61490 PyDict_SetItemString(d, constants[i].name, obj);
61491 Py_DECREF(obj);
61492 }
61493 }
61494 }
61495
61496 /* -----------------------------------------------------------------------------*/
61497 /* Fix SwigMethods to carry the callback ptrs when needed */
61498 /* -----------------------------------------------------------------------------*/
61499
61500 SWIGINTERN void
61501 SWIG_Python_FixMethods(PyMethodDef *methods,
61502 swig_const_info *const_table,
61503 swig_type_info **types,
61504 swig_type_info **types_initial) {
61505 size_t i;
61506 for (i = 0; methods[i].ml_name; ++i) {
61507 const char *c = methods[i].ml_doc;
61508 if (c && (c = strstr(c, "swig_ptr: "))) {
61509 int j;
61510 swig_const_info *ci = 0;
61511 const char *name = c + 10;
61512 for (j = 0; const_table[j].type; ++j) {
61513 if (strncmp(const_table[j].name, name,
61514 strlen(const_table[j].name)) == 0) {
61515 ci = &(const_table[j]);
61516 break;
61517 }
61518 }
61519 if (ci) {
61520 size_t shift = (ci->ptype) - types;
61521 swig_type_info *ty = types_initial[shift];
61522 size_t ldoc = (c - methods[i].ml_doc);
61523 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
61524 char *ndoc = (char*)malloc(ldoc + lptr + 10);
61525 if (ndoc) {
61526 char *buff = ndoc;
61527 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
61528 if (ptr) {
61529 strncpy(buff, methods[i].ml_doc, ldoc);
61530 buff += ldoc;
61531 strncpy(buff, "swig_ptr: ", 10);
61532 buff += 10;
61533 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
61534 methods[i].ml_doc = ndoc;
61535 }
61536 }
61537 }
61538 }
61539 }
61540 }
61541
61542 #ifdef __cplusplus
61543 }
61544 #endif
61545
61546 /* -----------------------------------------------------------------------------*
61547 * Partial Init method
61548 * -----------------------------------------------------------------------------*/
61549
61550 #ifdef __cplusplus
61551 extern "C"
61552 #endif
61553 SWIGEXPORT void SWIG_init(void) {
61554 PyObject *m, *d;
61555
61556 /* Fix SwigMethods to carry the callback ptrs when needed */
61557 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
61558
61559 m = Py_InitModule((char *) SWIG_name, SwigMethods);
61560 d = PyModule_GetDict(m);
61561
61562 SWIG_InitializeModule(0);
61563 SWIG_InstallConstants(d,swig_const_table);
61564
61565
61566
61567 #ifndef wxPyUSE_EXPORT
61568 // Make our API structure a CObject so other modules can import it
61569 // from this module.
61570 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
61571 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
61572 Py_XDECREF(cobj);
61573 #endif
61574
61575 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
61576 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
61577 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
61578 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
61579 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
61580 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
61581 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
61582 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
61583 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
61584 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
61585 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
61586 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
61587 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
61588 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
61589 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
61590 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
61591 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
61592 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
61593 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
61594 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
61595 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
61596 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
61597 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
61598 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
61599 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
61600 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
61601 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
61602 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
61603 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
61604 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
61605 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
61606 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
61607 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
61608 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
61609 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
61610 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
61611 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
61612 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
61613 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
61614 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
61615 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
61616 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
61617 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
61618 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
61619 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
61620 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
61621 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
61622 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
61623 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
61624 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
61625 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
61626 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
61627 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
61628 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
61629 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
61630 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
61631 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
61632 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
61633 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
61634 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
61635 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
61636 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
61637 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
61638 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
61639 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
61640 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
61641 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
61642 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
61643 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
61644 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
61645 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
61646 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
61647 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
61648 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
61649 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
61650 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
61651 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
61652 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
61653 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
61654 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
61655 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
61656 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
61657 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
61658 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
61659 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
61660 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
61661 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
61662 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
61663 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
61664 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
61665 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
61666 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
61667 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
61668 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
61669 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
61670 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
61671 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
61672 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
61673 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
61674 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
61675 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
61676 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
61677 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
61678 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
61679 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
61680 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
61681 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
61682 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
61683 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
61684 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
61685 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
61686 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
61687 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
61688 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
61689 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
61690 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
61691 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
61692 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
61693 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
61694 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
61695 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
61696 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
61697 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
61698 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
61699 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
61700 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
61701 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
61702 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
61703 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
61704 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
61705 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
61706 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
61707 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
61708 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
61709 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
61710 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
61711 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
61712 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
61713 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
61714 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
61715 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
61716 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
61717 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
61718 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
61719 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
61720 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
61721 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
61722 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
61723 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
61724 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
61725 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
61726 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
61727 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
61728 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
61729 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
61730 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
61731 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
61732 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
61733 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
61734 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
61735 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
61736 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
61737 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
61738 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
61739 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
61740 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
61741 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
61742 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
61743 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
61744 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
61745 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
61746 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
61747 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
61748 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
61749 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
61750 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
61751 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
61752 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
61753 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
61754 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
61755 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
61756 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
61757 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
61758 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
61759 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
61760 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
61761 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
61762 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
61763 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
61764 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
61765 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
61766 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
61767 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
61768 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
61769 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
61770 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
61771 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
61772 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
61773 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
61774 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
61775 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
61776 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
61777 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
61778 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
61779 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
61780 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
61781 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
61782 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
61783 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
61784 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
61785 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
61786 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
61787 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
61788 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
61789 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
61790 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
61791 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
61792 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
61793 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
61794 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
61795 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
61796 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
61797 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
61798 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
61799 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
61800 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
61801 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
61802 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
61803 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
61804 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
61805 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
61806 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
61807 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
61808 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
61809 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
61810 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
61811 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
61812 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
61813 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
61814 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
61815 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
61816 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
61817 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
61818 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
61819 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
61820 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
61821 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
61822 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
61823 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
61824 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
61825 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
61826 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
61827 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
61828 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
61829 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
61830 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
61831 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
61832 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
61833 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
61834 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
61835 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
61836 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
61837 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
61838 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
61839 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
61840 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
61841 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
61842 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
61843 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
61844 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
61845 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
61846 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
61847 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
61848 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
61849 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
61850 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
61851 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
61852 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
61853 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
61854 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
61855 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
61856 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
61857 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
61858 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
61859 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
61860 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
61861 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
61862 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
61863 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
61864 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
61865 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
61866 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
61867 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
61868 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
61869 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
61870 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
61871 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
61872 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
61873 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
61874 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
61875 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
61876 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
61877 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
61878 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
61879 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
61880 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
61881 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
61882 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
61883 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
61884 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
61885 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
61886 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
61887 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
61888 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
61889 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
61890 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
61891 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
61892 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
61893 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
61894 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
61895 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
61896 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
61897 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
61898 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
61899 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
61900 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
61901 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
61902 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
61903 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
61904 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
61905 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
61906 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
61907 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
61908 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
61909 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
61910 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
61911 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
61912 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
61913 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
61914 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
61915 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
61916 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
61917 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
61918 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
61919 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
61920 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
61921 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
61922 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
61923 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
61924 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
61925 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
61926 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
61927 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
61928 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
61929 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
61930 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
61931 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
61932 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
61933 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
61934 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
61935 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
61936 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
61937 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
61938 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
61939 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
61940 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
61941 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
61942 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
61943 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
61944 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
61945 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
61946 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
61947 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
61948 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
61949 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
61950 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
61951 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
61952 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
61953 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
61954 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
61955 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
61956 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
61957 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
61958 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
61959 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
61960 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
61961 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
61962 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
61963 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
61964 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
61965 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
61966 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
61967 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
61968 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
61969 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
61970 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
61971 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
61972 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
61973 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
61974 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
61975 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
61976 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
61977 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
61978 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
61979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
61980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
61981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
61982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
61983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
61984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
61985 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
61986 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
61987 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
61988 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
61989 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
61990 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
61991 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
61992 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
61993 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
61994 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
61995 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
61996 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
61997 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
61998 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
61999 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
62000 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
62001 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
62002 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
62003 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
62004 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
62005 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
62006 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
62007 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
62008 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
62009 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
62010 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
62011 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
62012 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
62013 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
62014 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
62015 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
62016 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
62017 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
62018 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
62019 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
62020 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
62021 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
62022 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
62023 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
62024 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
62025 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
62026 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
62027 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
62028 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
62029 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
62030 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
62031 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
62032 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
62033 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
62034 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
62035 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
62036 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
62037 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
62038 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
62039 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
62040 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
62041 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
62042 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
62043 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
62044 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
62045 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
62046 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
62047 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
62048 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
62049 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
62050 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
62051 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
62052 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
62053 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
62054 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
62055 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
62056 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
62057 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
62058 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
62059 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
62060 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
62061 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
62062 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
62063 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
62064 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
62065 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
62066 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
62067 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
62068 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
62069 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
62070 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
62071 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
62072 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
62073 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
62074 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
62075 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
62076 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
62077 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
62078 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
62079 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
62080 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
62081 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
62082 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
62083 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
62084 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
62085 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
62086 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
62087 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
62088 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
62089 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
62090 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
62091 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
62092 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
62093 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
62094 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
62095 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
62096 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
62097 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
62098 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
62099 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
62100 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
62101 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
62102 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
62103 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
62104 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
62105 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
62106 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
62107 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
62108 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
62109 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
62110 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
62111 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
62112 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
62113 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
62114 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
62115 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
62116 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
62117 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
62118 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
62119 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
62120 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
62121 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
62122 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
62123 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
62124 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
62125 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
62126 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
62127 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
62128 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
62129 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
62130 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
62131 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
62132 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
62133 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
62134 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
62135 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
62136 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
62137 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
62138 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
62139 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
62140 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
62141 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
62142 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
62143 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
62144 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
62145 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
62146 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
62147 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
62148 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
62149 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
62150 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
62151 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
62152 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
62153 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
62154 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
62155 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
62156 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
62157 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
62158 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
62159 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
62160 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
62161 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
62162 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
62163 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
62164 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
62165 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
62166 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
62167 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
62168 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
62169 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
62170 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
62171 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
62172 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
62173 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
62174 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
62175 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
62176 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
62177 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
62178 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
62179 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
62180 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
62181 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
62182 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
62183 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
62184 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
62185 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
62186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
62187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
62188 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
62189 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
62190 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
62191 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
62192 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
62193 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
62194 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
62195 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
62196 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
62197 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
62198 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
62199 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
62200 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
62201 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
62202 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
62203 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
62204 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
62205 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
62206 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
62207 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
62208 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
62209 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
62210 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
62211 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
62212 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
62213 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
62214 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
62215 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
62216 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
62217 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
62218 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
62219 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
62220 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
62221 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
62222 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
62223 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
62224 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
62225 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
62226 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
62227 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
62228 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
62229 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
62230
62231 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
62232
62233
62234 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
62235
62236 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
62237 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
62238 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
62239 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
62240 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
62241 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
62242 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
62243 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
62244 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
62245 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
62246 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
62247 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
62248 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
62249 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
62250 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
62251 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
62252 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
62253 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
62254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
62255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
62256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
62257 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
62258 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
62259 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
62260 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
62261 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
62262 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
62263 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
62264 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
62265 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
62266 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
62267 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
62268 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
62269 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
62270 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
62271 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
62272 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
62273 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
62274 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
62275 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
62276 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
62277 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
62278 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
62279 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
62280 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
62281 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
62282 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
62283 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
62284 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
62285 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
62286 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
62287 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
62288 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
62289 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
62290 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
62291 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
62292 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
62293 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
62294 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
62295 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
62296 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
62297 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
62298 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
62299 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
62300 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
62301 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
62302 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
62303 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
62304 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
62305 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
62306 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
62307 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
62308 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
62309 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
62310 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
62311 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
62312 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
62313 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
62314 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
62315 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
62316 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
62317 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
62318 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
62319 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
62320 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
62321 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
62322 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
62323 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
62324 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
62325 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
62326 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
62327 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
62328 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
62329 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
62330 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
62331 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
62332 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
62333 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
62334 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
62335 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
62336 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
62337 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
62338 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
62339 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
62340 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
62341 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
62342 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
62343 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
62344 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
62345 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
62346 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
62347 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
62348 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
62349 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
62350 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
62351 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
62352 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
62353 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
62354 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
62355 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
62356 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
62357 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
62358 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
62359 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
62360 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
62361 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
62362 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
62363 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
62364 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
62365 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
62366 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
62367 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
62368 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
62369 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
62370 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
62371 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
62372 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
62373 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
62374 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
62375 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
62376 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
62377 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
62378 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
62379 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
62380 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
62381 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
62382 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
62383 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
62384 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
62385 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
62386 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
62387 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
62388 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
62389 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
62390 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
62391 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
62392 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
62393 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
62394 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
62395 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
62396 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
62397 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
62398 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
62399 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
62400 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
62401 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
62402 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
62403 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
62404 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
62405 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
62406 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
62407 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
62408 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
62409 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
62410 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
62411 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
62412 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
62413 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
62414 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
62415 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
62416 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
62417 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
62418 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
62419 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
62420 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
62421 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
62422 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
62423 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
62424 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
62425 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
62426 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
62427 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
62428 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
62429 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
62430 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
62431 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
62432 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
62433 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
62434 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
62435 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
62436 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
62437 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
62438 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
62439 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
62440 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
62441 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
62442 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
62443 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
62444 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
62445 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
62446 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
62447 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
62448 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
62449 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
62450 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
62451
62452 // Initialize threading, some globals and such
62453 __wxPyPreStart(d);
62454
62455
62456 // Although these are defined in __version__ they need to be here too so
62457 // that an assert can be done to ensure that the wxPython and the wxWindows
62458 // versions match.
62459 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
62460 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
62461 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
62462
62463 }
62464
wxWidgets (Impactor)