]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoop swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoopActivator swig_types[39]
2506 #define SWIGTYPE_p_wxEvtHandler swig_types[40]
2507 #define SWIGTYPE_p_wxFSFile swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystem swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystemHandler swig_types[43]
2510 #define SWIGTYPE_p_wxFlexGridSizer swig_types[44]
2511 #define SWIGTYPE_p_wxFocusEvent swig_types[45]
2512 #define SWIGTYPE_p_wxFont swig_types[46]
2513 #define SWIGTYPE_p_wxFrame swig_types[47]
2514 #define SWIGTYPE_p_wxGBPosition swig_types[48]
2515 #define SWIGTYPE_p_wxGBSizerItem swig_types[49]
2516 #define SWIGTYPE_p_wxGBSpan swig_types[50]
2517 #define SWIGTYPE_p_wxGIFHandler swig_types[51]
2518 #define SWIGTYPE_p_wxGridBagSizer swig_types[52]
2519 #define SWIGTYPE_p_wxGridSizer swig_types[53]
2520 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[54]
2521 #define SWIGTYPE_p_wxICOHandler swig_types[55]
2522 #define SWIGTYPE_p_wxIconizeEvent swig_types[56]
2523 #define SWIGTYPE_p_wxIdleEvent swig_types[57]
2524 #define SWIGTYPE_p_wxImage swig_types[58]
2525 #define SWIGTYPE_p_wxImageHandler swig_types[59]
2526 #define SWIGTYPE_p_wxImageHistogram swig_types[60]
2527 #define SWIGTYPE_p_wxImage_HSVValue swig_types[61]
2528 #define SWIGTYPE_p_wxImage_RGBValue swig_types[62]
2529 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[63]
2530 #define SWIGTYPE_p_wxInitDialogEvent swig_types[64]
2531 #define SWIGTYPE_p_wxInputStream swig_types[65]
2532 #define SWIGTYPE_p_wxInternetFSHandler swig_types[66]
2533 #define SWIGTYPE_p_wxItemContainer swig_types[67]
2534 #define SWIGTYPE_p_wxJPEGHandler swig_types[68]
2535 #define SWIGTYPE_p_wxKeyEvent swig_types[69]
2536 #define SWIGTYPE_p_wxLayoutConstraints swig_types[70]
2537 #define SWIGTYPE_p_wxMaximizeEvent swig_types[71]
2538 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
2539 #define SWIGTYPE_p_wxMenu swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBar swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBarBase swig_types[75]
2542 #define SWIGTYPE_p_wxMenuEvent swig_types[76]
2543 #define SWIGTYPE_p_wxMenuItem swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMoveEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNcPaintEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNotifyEvent swig_types[84]
2551 #define SWIGTYPE_p_wxObject swig_types[85]
2552 #define SWIGTYPE_p_wxOutputStream swig_types[86]
2553 #define SWIGTYPE_p_wxPCXHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNGHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNMHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPaintEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaperSize swig_types[92]
2559 #define SWIGTYPE_p_wxPoint swig_types[93]
2560 #define SWIGTYPE_p_wxPoint2D swig_types[94]
2561 #define SWIGTYPE_p_wxPropagateOnce swig_types[95]
2562 #define SWIGTYPE_p_wxPropagationDisabler swig_types[96]
2563 #define SWIGTYPE_p_wxPyApp swig_types[97]
2564 #define SWIGTYPE_p_wxPyCommandEvent swig_types[98]
2565 #define SWIGTYPE_p_wxPyDropTarget swig_types[99]
2566 #define SWIGTYPE_p_wxPyEvent swig_types[100]
2567 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyImageHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyInputStream swig_types[103]
2570 #define SWIGTYPE_p_wxPySizer swig_types[104]
2571 #define SWIGTYPE_p_wxPyValidator swig_types[105]
2572 #define SWIGTYPE_p_wxQuantize swig_types[106]
2573 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[107]
2574 #define SWIGTYPE_p_wxRealPoint swig_types[108]
2575 #define SWIGTYPE_p_wxRect swig_types[109]
2576 #define SWIGTYPE_p_wxRect2D swig_types[110]
2577 #define SWIGTYPE_p_wxRegion swig_types[111]
2578 #define SWIGTYPE_p_wxScrollEvent swig_types[112]
2579 #define SWIGTYPE_p_wxScrollWinEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSetCursorEvent swig_types[114]
2581 #define SWIGTYPE_p_wxShowEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSize swig_types[116]
2583 #define SWIGTYPE_p_wxSizeEvent swig_types[117]
2584 #define SWIGTYPE_p_wxSizer swig_types[118]
2585 #define SWIGTYPE_p_wxSizerItem swig_types[119]
2586 #define SWIGTYPE_p_wxStaticBox swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[121]
2588 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[122]
2589 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[123]
2590 #define SWIGTYPE_p_wxTGAHandler swig_types[124]
2591 #define SWIGTYPE_p_wxTIFFHandler swig_types[125]
2592 #define SWIGTYPE_p_wxToolTip swig_types[126]
2593 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[127]
2594 #define SWIGTYPE_p_wxValidator swig_types[128]
2595 #define SWIGTYPE_p_wxVisualAttributes swig_types[129]
2596 #define SWIGTYPE_p_wxWindow swig_types[130]
2597 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[131]
2598 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[132]
2599 #define SWIGTYPE_p_wxXPMHandler swig_types[133]
2600 #define SWIGTYPE_p_wxZipFSHandler swig_types[134]
2601 static swig_type_info *swig_types[136];
2602 static swig_module_info swig_module = {swig_types, 135, 0, 0, 0, 0};
2603 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2604 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2605
2606 /* -------- TYPES TABLE (END) -------- */
2607
2608 #if (PY_VERSION_HEX <= 0x02000000)
2609 # if !defined(SWIG_PYTHON_CLASSIC)
2610 # error "This python version requires to use swig with the '-classic' option"
2611 # endif
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodern' option"
2615 #endif
2616 #if (PY_VERSION_HEX <= 0x02020000)
2617 # error "This python version requires to use swig with the '-nomodernargs' option"
2618 #endif
2619 #ifndef METH_O
2620 # error "This python version requires to use swig with the '-nofastunpack' option"
2621 #endif
2622
2623 /*-----------------------------------------------
2624 @(target):= _core_.so
2625 ------------------------------------------------*/
2626 #define SWIG_init init_core_
2627
2628 #define SWIG_name "_core_"
2629
2630 #define SWIGVERSION 0x010329
2631
2632
2633 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2634 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2635
2636
2637 #include <stdexcept>
2638
2639
2640 namespace swig {
2641 class PyObject_ptr {
2642 protected:
2643 PyObject *_obj;
2644
2645 public:
2646 PyObject_ptr() :_obj(0)
2647 {
2648 }
2649
2650 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2651 {
2652 Py_XINCREF(_obj);
2653 }
2654
2655 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2656 {
2657 if (initial_ref) Py_XINCREF(_obj);
2658 }
2659
2660 PyObject_ptr & operator=(const PyObject_ptr& item)
2661 {
2662 Py_XINCREF(item._obj);
2663 Py_XDECREF(_obj);
2664 _obj = item._obj;
2665 return *this;
2666 }
2667
2668 ~PyObject_ptr()
2669 {
2670 Py_XDECREF(_obj);
2671 }
2672
2673 operator PyObject *() const
2674 {
2675 return _obj;
2676 }
2677
2678 PyObject *operator->() const
2679 {
2680 return _obj;
2681 }
2682 };
2683 }
2684
2685
2686 namespace swig {
2687 struct PyObject_var : PyObject_ptr {
2688 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2689
2690 PyObject_var & operator = (PyObject* obj)
2691 {
2692 Py_XDECREF(_obj);
2693 _obj = obj;
2694 return *this;
2695 }
2696 };
2697 }
2698
2699
2700 #include "wx/wxPython/wxPython_int.h"
2701 #include "wx/wxPython/pyclasses.h"
2702 #include "wx/wxPython/twoitem.h"
2703
2704
2705 #ifndef wxPyUSE_EXPORT
2706 // Helper functions for dealing with SWIG objects and such. These are
2707 // located here so they know about the SWIG types and functions declared
2708 // in the wrapper code.
2709
2710 #include <wx/hashmap.h>
2711 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2712
2713
2714 // Maintains a hashmap of className to swig_type_info pointers. Given the
2715 // name of a class either looks up the type info in the cache, or scans the
2716 // SWIG tables for it.
2717 extern PyObject* wxPyPtrTypeMap;
2718 static
2719 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2720
2721 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2722
2723 if (typeInfoCache == NULL)
2724 typeInfoCache = new wxPyTypeInfoHashMap;
2725
2726 wxString name(className);
2727 swig_type_info* swigType = (*typeInfoCache)[name];
2728
2729 if (! swigType) {
2730 // it wasn't in the cache, so look it up from SWIG
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733
2734 // if it still wasn't found, try looking for a mapped name
2735 if (!swigType) {
2736 PyObject* item;
2737 name = className;
2738
2739 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2740 (char*)(const char*)name.mbc_str())) != NULL) {
2741 name = wxString(PyString_AsString(item), *wxConvCurrent);
2742 name.Append(wxT(" *"));
2743 swigType = SWIG_TypeQuery(name.mb_str());
2744 }
2745 }
2746 if (swigType) {
2747 // and add it to the map if found
2748 (*typeInfoCache)[className] = swigType;
2749 }
2750 }
2751 return swigType;
2752 }
2753
2754
2755 // Check if a class name is a type known to SWIG
2756 bool wxPyCheckSwigType(const wxChar* className) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 return swigType != NULL;
2760 }
2761
2762
2763 // Given a pointer to a C++ object and a class name, construct a Python proxy
2764 // object for it.
2765 PyObject* wxPyConstructObject(void* ptr,
2766 const wxChar* className,
2767 int setThisOwn) {
2768
2769 swig_type_info* swigType = wxPyFindSwigType(className);
2770 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2771
2772 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2773 }
2774
2775
2776 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2777 // Ensures that the proxy object is of the specified (or derived) type. If
2778 // not able to perform the conversion then a Python exception is set and the
2779 // error should be handled properly in the caller. Returns True on success.
2780 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2781 const wxChar* className) {
2782
2783 swig_type_info* swigType = wxPyFindSwigType(className);
2784 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2785
2786 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2787 }
2788
2789
2790
2791 // Make a SWIGified pointer object suitable for a .this attribute
2792 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2793
2794 PyObject* robj = NULL;
2795
2796 swig_type_info* swigType = wxPyFindSwigType(className);
2797 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2798
2799 robj = PySwigObject_New(ptr, swigType, 0);
2800 return robj;
2801 }
2802
2803
2804 // Python's PyInstance_Check does not return True for instances of new-style
2805 // classes. This should get close enough for both new and old classes but I
2806 // should re-evaluate the need for doing instance checks...
2807 bool wxPyInstance_Check(PyObject* obj) {
2808 return PyObject_HasAttrString(obj, "__class__") != 0;
2809 }
2810
2811
2812 // This one checks if the object is an instance of a SWIG proxy class (it has
2813 // a .this attribute, and the .this attribute is a PySwigObject.)
2814 bool wxPySwigInstance_Check(PyObject* obj) {
2815 static PyObject* this_str = NULL;
2816 if (this_str == NULL)
2817 this_str = PyString_FromString("this");
2818
2819 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2820 if (this_attr) {
2821 bool retval = (PySwigObject_Check(this_attr) != 0);
2822 Py_DECREF(this_attr);
2823 return retval;
2824 }
2825
2826 PyErr_Clear();
2827 return false;
2828 }
2829
2830
2831 // Export a C API in a struct. Other modules will be able to load this from
2832 // the wx._core_ module and will then have safe access to these functions,
2833 // even if they are located in another shared library.
2834 static wxPyCoreAPI API = {
2835
2836 wxPyCheckSwigType,
2837 wxPyConstructObject,
2838 wxPyConvertSwigPtr,
2839 wxPyMakeSwigPtr,
2840
2841 wxPyBeginAllowThreads,
2842 wxPyEndAllowThreads,
2843 wxPyBeginBlockThreads,
2844 wxPyEndBlockThreads,
2845
2846 wxPy_ConvertList,
2847
2848 wxString_in_helper,
2849 Py2wxString,
2850 wx2PyString,
2851
2852 byte_LIST_helper,
2853 int_LIST_helper,
2854 long_LIST_helper,
2855 string_LIST_helper,
2856 wxPoint_LIST_helper,
2857 wxBitmap_LIST_helper,
2858 wxString_LIST_helper,
2859 wxAcceleratorEntry_LIST_helper,
2860
2861 wxSize_helper,
2862 wxPoint_helper,
2863 wxRealPoint_helper,
2864 wxRect_helper,
2865 wxColour_helper,
2866 wxPoint2D_helper,
2867
2868 wxPySimple_typecheck,
2869 wxColour_typecheck,
2870
2871 wxPyCBH_setCallbackInfo,
2872 wxPyCBH_findCallback,
2873 wxPyCBH_callCallback,
2874 wxPyCBH_callCallbackObj,
2875 wxPyCBH_delete,
2876
2877 wxPyMake_wxObject,
2878 wxPyMake_wxSizer,
2879 wxPyPtrTypeMap_Add,
2880 wxPy2int_seq_helper,
2881 wxPy4int_seq_helper,
2882 wxArrayString2PyList_helper,
2883 wxArrayInt2PyList_helper,
2884
2885 wxPyClientData_dtor,
2886 wxPyUserData_dtor,
2887 wxPyOORClientData_dtor,
2888
2889 wxPyCBInputStream_create,
2890 wxPyCBInputStream_copy,
2891
2892 wxPyInstance_Check,
2893 wxPySwigInstance_Check,
2894
2895 wxPyCheckForApp,
2896
2897 wxArrayDouble2PyList_helper,
2898 wxPoint2D_LIST_helper,
2899 wxRect2D_helper,
2900
2901 };
2902
2903 #endif
2904
2905
2906 #if !WXWIN_COMPATIBILITY_2_4
2907 #define wxHIDE_READONLY 0
2908 #endif
2909
2910
2911 #define SWIG_From_long PyInt_FromLong
2912
2913
2914 SWIGINTERNINLINE PyObject *
2915 SWIG_From_int (int value)
2916 {
2917 return SWIG_From_long (value);
2918 }
2919
2920 static const wxString wxPyEmptyString(wxEmptyString);
2921 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2922 return self->GetClassInfo()->GetClassName();
2923 }
2924 SWIGINTERN void wxObject_Destroy(wxObject *self){
2925 delete self;
2926 }
2927
2928 #ifndef __WXMAC__
2929 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2930 #endif
2931
2932
2933 #include <limits.h>
2934 #ifndef LLONG_MIN
2935 # define LLONG_MIN LONG_LONG_MIN
2936 #endif
2937 #ifndef LLONG_MAX
2938 # define LLONG_MAX LONG_LONG_MAX
2939 #endif
2940 #ifndef ULLONG_MAX
2941 # define ULLONG_MAX ULONG_LONG_MAX
2942 #endif
2943
2944
2945 SWIGINTERN int
2946 SWIG_AsVal_long (PyObject* obj, long* val)
2947 {
2948 if (PyNumber_Check(obj)) {
2949 if (val) *val = PyInt_AsLong(obj);
2950 return SWIG_OK;
2951 }
2952 return SWIG_TypeError;
2953 }
2954
2955
2956 SWIGINTERN int
2957 SWIG_AsVal_int (PyObject * obj, int *val)
2958 {
2959 long v;
2960 int res = SWIG_AsVal_long (obj, &v);
2961 if (SWIG_IsOK(res)) {
2962 if ((v < INT_MIN || v > INT_MAX)) {
2963 return SWIG_OverflowError;
2964 } else {
2965 if (val) *val = static_cast< int >(v);
2966 }
2967 }
2968 return res;
2969 }
2970
2971 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2972 wxSize temp, *obj = &temp;
2973 if ( other == Py_None ) return false;
2974 if ( ! wxSize_helper(other, &obj) ) {
2975 PyErr_Clear();
2976 return false;
2977 }
2978 return self->operator==(*obj);
2979 }
2980 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2981 wxSize temp, *obj = &temp;
2982 if ( other == Py_None ) return true;
2983 if ( ! wxSize_helper(other, &obj)) {
2984 PyErr_Clear();
2985 return true;
2986 }
2987 return self->operator!=(*obj);
2988 }
2989
2990 #include <float.h>
2991
2992
2993 SWIGINTERN int
2994 SWIG_AsVal_double (PyObject *obj, double* val)
2995 {
2996 if (PyNumber_Check(obj)) {
2997 if (val) *val = PyFloat_AsDouble(obj);
2998 return SWIG_OK;
2999 }
3000 return SWIG_TypeError;
3001 }
3002
3003
3004 SWIGINTERN int
3005 SWIG_AsVal_float (PyObject * obj, float *val)
3006 {
3007 double v;
3008 int res = SWIG_AsVal_double (obj, &v);
3009 if (SWIG_IsOK(res)) {
3010 if ((v < -FLT_MAX || v > FLT_MAX)) {
3011 return SWIG_OverflowError;
3012 } else {
3013 if (val) *val = static_cast< float >(v);
3014 }
3015 }
3016 return res;
3017 }
3018
3019 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3020 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3021 PyObject* tup = PyTuple_New(2);
3022 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3023 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3024 //wxPyEndBlockThreads(blocked);
3025 return tup;
3026 }
3027
3028 #define SWIG_From_double PyFloat_FromDouble
3029
3030 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3031 wxRealPoint temp, *obj = &temp;
3032 if ( other == Py_None ) return false;
3033 if ( ! wxRealPoint_helper(other, &obj) ) {
3034 PyErr_Clear();
3035 return false;
3036 }
3037 return self->operator==(*obj);
3038 }
3039 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3040 wxRealPoint temp, *obj = &temp;
3041 if ( other == Py_None ) return true;
3042 if ( ! wxRealPoint_helper(other, &obj)) {
3043 PyErr_Clear();
3044 return true;
3045 }
3046 return self->operator!=(*obj);
3047 }
3048 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3049 self->x = x;
3050 self->y = y;
3051 }
3052 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3053 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3054 PyObject* tup = PyTuple_New(2);
3055 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3056 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3057 //PyEndBlockThreads(blocked);
3058 return tup;
3059 }
3060 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3061 wxPoint temp, *obj = &temp;
3062 if ( other == Py_None ) return false;
3063 if ( ! wxPoint_helper(other, &obj) ) {
3064 PyErr_Clear();
3065 return false;
3066 }
3067 return self->operator==(*obj);
3068 }
3069 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3070 wxPoint temp, *obj = &temp;
3071 if ( other == Py_None ) return true;
3072 if ( ! wxPoint_helper(other, &obj)) {
3073 PyErr_Clear();
3074 return true;
3075 }
3076 return self->operator!=(*obj);
3077 }
3078 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3079 self->x = x;
3080 self->y = y;
3081 }
3082 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3083 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3084 PyObject* tup = PyTuple_New(2);
3085 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3086 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3087 //wxPyEndBlockThreads(blocked);
3088 return tup;
3089 }
3090 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3091 wxRect temp, *obj = &temp;
3092 if ( other == Py_None ) return false;
3093 if ( ! wxRect_helper(other, &obj) ) {
3094 PyErr_Clear();
3095 return false;
3096 }
3097 return self->operator==(*obj);
3098 }
3099 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3100 wxRect temp, *obj = &temp;
3101 if ( other == Py_None ) return true;
3102 if ( ! wxRect_helper(other, &obj)) {
3103 PyErr_Clear();
3104 return true;
3105 }
3106 return self->operator!=(*obj);
3107 }
3108 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3109 self->x = x;
3110 self->y = y;
3111 self->width = width;
3112 self->height = height;
3113 }
3114 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3115 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3116 PyObject* tup = PyTuple_New(4);
3117 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3118 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3119 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3120 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3121 //wxPyEndBlockThreads(blocked);
3122 return tup;
3123 }
3124
3125 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3126 wxRegion reg1(*r1);
3127 wxRegion reg2(*r2);
3128 wxRect dest(0,0,0,0);
3129 PyObject* obj;
3130
3131 reg1.Intersect(reg2);
3132 dest = reg1.GetBox();
3133
3134 if (dest != wxRect(0,0,0,0)) {
3135 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3136 wxRect* newRect = new wxRect(dest);
3137 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3138 //wxPyEndBlockThreads(blocked);
3139 return obj;
3140 }
3141 Py_INCREF(Py_None);
3142 return Py_None;
3143 }
3144
3145 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3146 wxPoint2D temp, *obj = &temp;
3147 if ( other == Py_None ) return false;
3148 if ( ! wxPoint2D_helper(other, &obj) ) {
3149 PyErr_Clear();
3150 return false;
3151 }
3152 return self->operator==(*obj);
3153 }
3154 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3155 wxPoint2D temp, *obj = &temp;
3156 if ( other == Py_None ) return true;
3157 if ( ! wxPoint2D_helper(other, &obj)) {
3158 PyErr_Clear();
3159 return true;
3160 }
3161 return self->operator!=(*obj);
3162 }
3163 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3164 self->m_x = x;
3165 self->m_y = y;
3166 }
3167 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3168 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3169 PyObject* tup = PyTuple_New(2);
3170 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3171 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3172 //wxPyEndBlockThreads(blocked);
3173 return tup;
3174 }
3175 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3176 wxRect2D temp, *obj = &temp;
3177 if ( other == Py_None ) return false;
3178 if ( ! wxRect2D_helper(other, &obj) ) {
3179 PyErr_Clear();
3180 return false;
3181 }
3182 return self->operator==(*obj);
3183 }
3184 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3185 wxRect2D temp, *obj = &temp;
3186 if ( other == Py_None ) return true;
3187 if ( ! wxRect2D_helper(other, &obj)) {
3188 PyErr_Clear();
3189 return true;
3190 }
3191 return self->operator!=(*obj);
3192 }
3193 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3194 self->m_x = x;
3195 self->m_y = y;
3196 self->m_width = width;
3197 self->m_height = height;
3198 }
3199 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3200 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 PyObject* tup = PyTuple_New(4);
3202 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3203 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3204 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3205 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3206 //wxPyEndBlockThreads(blocked);
3207 return tup;
3208 }
3209
3210 #include "wx/wxPython/pyistream.h"
3211
3212 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3213 wxInputStream* wxis = wxPyCBInputStream::create(p);
3214 if (wxis)
3215 return new wxPyInputStream(wxis);
3216 else
3217 return NULL;
3218 }
3219
3220 SWIGINTERN swig_type_info*
3221 SWIG_pchar_descriptor()
3222 {
3223 static int init = 0;
3224 static swig_type_info* info = 0;
3225 if (!init) {
3226 info = SWIG_TypeQuery("_p_char");
3227 init = 1;
3228 }
3229 return info;
3230 }
3231
3232
3233 SWIGINTERNINLINE PyObject *
3234 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3235 {
3236 if (carray) {
3237 if (size > INT_MAX) {
3238 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3239 return pchar_descriptor ?
3240 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3241 } else {
3242 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3243 }
3244 } else {
3245 return SWIG_Py_Void();
3246 }
3247 }
3248
3249
3250 SWIGINTERNINLINE PyObject *
3251 SWIG_From_char (char c)
3252 {
3253 return SWIG_FromCharPtrAndSize(&c,1);
3254 }
3255
3256
3257 SWIGINTERNINLINE PyObject*
3258 SWIG_From_unsigned_SS_long (unsigned long value)
3259 {
3260 return (value > LONG_MAX) ?
3261 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3262 }
3263
3264
3265 SWIGINTERNINLINE PyObject *
3266 SWIG_From_size_t (size_t value)
3267 {
3268 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3269 }
3270
3271
3272 SWIGINTERN int
3273 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3274 {
3275 if (PyString_Check(obj)) {
3276 char *cstr; Py_ssize_t len;
3277 PyString_AsStringAndSize(obj, &cstr, &len);
3278 if (cptr) {
3279 if (alloc) {
3280 /*
3281 In python the user should not be able to modify the inner
3282 string representation. To warranty that, if you define
3283 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3284 buffer is always returned.
3285
3286 The default behavior is just to return the pointer value,
3287 so, be careful.
3288 */
3289 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3290 if (*alloc != SWIG_OLDOBJ)
3291 #else
3292 if (*alloc == SWIG_NEWOBJ)
3293 #endif
3294 {
3295 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3296 *alloc = SWIG_NEWOBJ;
3297 }
3298 else {
3299 *cptr = cstr;
3300 *alloc = SWIG_OLDOBJ;
3301 }
3302 } else {
3303 *cptr = PyString_AsString(obj);
3304 }
3305 }
3306 if (psize) *psize = len + 1;
3307 return SWIG_OK;
3308 } else {
3309 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3310 if (pchar_descriptor) {
3311 void* vptr = 0;
3312 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3313 if (cptr) *cptr = (char *) vptr;
3314 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3315 if (alloc) *alloc = SWIG_OLDOBJ;
3316 return SWIG_OK;
3317 }
3318 }
3319 }
3320 return SWIG_TypeError;
3321 }
3322
3323
3324 SWIGINTERN int
3325 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3326 {
3327 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3328 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3329 if (SWIG_IsOK(res)) {
3330 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3331 if (csize <= size) {
3332 if (val) {
3333 if (csize) memcpy(val, cptr, csize*sizeof(char));
3334 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3335 }
3336 if (alloc == SWIG_NEWOBJ) {
3337 delete[] cptr;
3338 res = SWIG_DelNewMask(res);
3339 }
3340 return res;
3341 }
3342 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3343 }
3344 return SWIG_TypeError;
3345 }
3346
3347
3348 SWIGINTERN int
3349 SWIG_AsVal_char (PyObject * obj, char *val)
3350 {
3351 int res = SWIG_AsCharArray(obj, val, 1);
3352 if (!SWIG_IsOK(res)) {
3353 long v;
3354 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3355 if (SWIG_IsOK(res)) {
3356 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3357 if (val) *val = static_cast< char >(v);
3358 } else {
3359 res = SWIG_OverflowError;
3360 }
3361 }
3362 }
3363 return res;
3364 }
3365
3366 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3367 // We use only strings for the streams, not unicode
3368 PyObject* str = PyObject_Str(obj);
3369 if (! str) {
3370 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3371 return;
3372 }
3373 self->Write(PyString_AS_STRING(str),
3374 PyString_GET_SIZE(str));
3375 Py_DECREF(str);
3376 }
3377
3378 #include "wx/wxPython/pyistream.h"
3379
3380
3381 class wxPyFileSystemHandler : public wxFileSystemHandler
3382 {
3383 public:
3384 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3385
3386 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3387 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3388 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3389 DEC_PYCALLBACK_STRING__pure(FindNext);
3390
3391 wxString GetProtocol(const wxString& location) {
3392 return wxFileSystemHandler::GetProtocol(location);
3393 }
3394
3395 wxString GetLeftLocation(const wxString& location) {
3396 return wxFileSystemHandler::GetLeftLocation(location);
3397 }
3398
3399 wxString GetAnchor(const wxString& location) {
3400 return wxFileSystemHandler::GetAnchor(location);
3401 }
3402
3403 wxString GetRightLocation(const wxString& location) {
3404 return wxFileSystemHandler::GetRightLocation(location);
3405 }
3406
3407 wxString GetMimeTypeFromExt(const wxString& location) {
3408 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3409 }
3410
3411 PYPRIVATE;
3412 };
3413
3414
3415 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3416 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3417 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3418 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3419
3420
3421 SWIGINTERN int
3422 SWIG_AsVal_bool (PyObject *obj, bool *val)
3423 {
3424 if (obj == Py_True) {
3425 if (val) *val = true;
3426 return SWIG_OK;
3427 } else if (obj == Py_False) {
3428 if (val) *val = false;
3429 return SWIG_OK;
3430 } else {
3431 long v = 0;
3432 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3433 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3434 return res;
3435 }
3436 }
3437
3438 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3439 wxFileName fname = wxFileSystem::URLToFileName(url);
3440 return fname.GetFullPath();
3441 }
3442
3443 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3444 wxImage& image,
3445 long type) {
3446 wxMemoryFSHandler::AddFile(filename, image, type);
3447 }
3448
3449 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3450 const wxBitmap& bitmap,
3451 long type) {
3452 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3453 }
3454
3455 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3456 PyObject* data) {
3457 if (! PyString_Check(data)) {
3458 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3459 "Expected string object"));
3460 return;
3461 }
3462
3463 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3464 void* ptr = (void*)PyString_AsString(data);
3465 size_t size = PyString_Size(data);
3466 wxPyEndBlockThreads(blocked);
3467
3468 wxMemoryFSHandler::AddFile(filename, ptr, size);
3469 }
3470
3471
3472 #include "wx/wxPython/pyistream.h"
3473
3474
3475 SWIGINTERN int
3476 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3477 {
3478 long v = 0;
3479 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3480 return SWIG_TypeError;
3481 }
3482 else if (val)
3483 *val = (unsigned long)v;
3484 return SWIG_OK;
3485 }
3486
3487
3488 SWIGINTERN int
3489 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3490 {
3491 unsigned long v;
3492 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3493 if (SWIG_IsOK(res)) {
3494 if ((v > UCHAR_MAX)) {
3495 return SWIG_OverflowError;
3496 } else {
3497 if (val) *val = static_cast< unsigned char >(v);
3498 }
3499 }
3500 return res;
3501 }
3502
3503
3504 SWIGINTERNINLINE PyObject *
3505 SWIG_From_unsigned_SS_char (unsigned char value)
3506 {
3507 return SWIG_From_unsigned_SS_long (value);
3508 }
3509
3510 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3511 wxImageHistogramEntry e = (*self)[key];
3512 return e.value;
3513 }
3514 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3515 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3516 wxImageHistogramEntry e = (*self)[key];
3517 return e.value;
3518 }
3519 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3520 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3521 colour.Green(),
3522 colour.Blue());
3523 wxImageHistogramEntry e = (*self)[key];
3524 return e.value;
3525 }
3526
3527 // Pull the nested class out to the top level for SWIG's sake
3528 #define wxImage_RGBValue wxImage::RGBValue
3529 #define wxImage_HSVValue wxImage::HSVValue
3530
3531 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3532 if (width > 0 && height > 0)
3533 return new wxImage(width, height, clear);
3534 else
3535 return new wxImage;
3536 }
3537 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3538 return new wxImage(bitmap.ConvertToImage());
3539 }
3540 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3541 if (DATASIZE != width*height*3) {
3542 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3543 return NULL;
3544 }
3545
3546 // Copy the source data so the wxImage can clean it up later
3547 buffer copy = (buffer)malloc(DATASIZE);
3548 if (copy == NULL) {
3549 wxPyBLOCK_THREADS(PyErr_NoMemory());
3550 return NULL;
3551 }
3552 memcpy(copy, data, DATASIZE);
3553 return new wxImage(width, height, copy, false);
3554 }
3555 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3556 if (DATASIZE != width*height*3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return NULL;
3559 }
3560 if (ALPHASIZE != width*height) {
3561 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3562 return NULL;
3563 }
3564
3565 // Copy the source data so the wxImage can clean it up later
3566 buffer dcopy = (buffer)malloc(DATASIZE);
3567 if (dcopy == NULL) {
3568 wxPyBLOCK_THREADS(PyErr_NoMemory());
3569 return NULL;
3570 }
3571 memcpy(dcopy, data, DATASIZE);
3572
3573 buffer acopy = (buffer)malloc(ALPHASIZE);
3574 if (acopy == NULL) {
3575 wxPyBLOCK_THREADS(PyErr_NoMemory());
3576 return NULL;
3577 }
3578 memcpy(acopy, alpha, ALPHASIZE);
3579
3580 return new wxImage(width, height, dcopy, acopy, false);
3581 }
3582 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3583 wxSize size(self->GetWidth(), self->GetHeight());
3584 return size;
3585 }
3586 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3587 buffer data = self->GetData();
3588 int len = self->GetWidth() * self->GetHeight() * 3;
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3591 return rv;
3592 }
3593 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3594 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3595 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3596 return;
3597 }
3598 buffer copy = (buffer)malloc(DATASIZE);
3599 if (copy == NULL) {
3600 wxPyBLOCK_THREADS(PyErr_NoMemory());
3601 return;
3602 }
3603 memcpy(copy, data, DATASIZE);
3604 self->SetData(copy, false);
3605 // wxImage takes ownership of copy...
3606 }
3607 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3608 buffer data = self->GetData();
3609 int len = self->GetWidth() * self->GetHeight() * 3;
3610 PyObject* rv;
3611 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3612 return rv;
3613 }
3614 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3615 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3616 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3617 return;
3618 }
3619 self->SetData(data, true);
3620 }
3621 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3622 buffer data = self->GetAlpha();
3623 if (! data) {
3624 RETURN_NONE();
3625 } else {
3626 int len = self->GetWidth() * self->GetHeight();
3627 PyObject* rv;
3628 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3629 return rv;
3630 }
3631 }
3632 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3633 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3634 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3635 return;
3636 }
3637 buffer acopy = (buffer)malloc(ALPHASIZE);
3638 if (acopy == NULL) {
3639 wxPyBLOCK_THREADS(PyErr_NoMemory());
3640 return;
3641 }
3642 memcpy(acopy, alpha, ALPHASIZE);
3643 self->SetAlpha(acopy, false);
3644 // wxImage takes ownership of acopy...
3645 }
3646 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3647 buffer data = self->GetAlpha();
3648 int len = self->GetWidth() * self->GetHeight();
3649 PyObject* rv;
3650 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3651 return rv;
3652 }
3653 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3654 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3655 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3656 return;
3657 }
3658 self->SetAlpha(alpha, true);
3659 }
3660 SWIGINTERN PyObject *wxImage_GetHandlers(){
3661 wxList& list = wxImage::GetHandlers();
3662 return wxPy_ConvertList(&list);
3663 }
3664 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3665 wxBitmap bitmap(*self, depth);
3666 return bitmap;
3667 }
3668 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3669 wxImage mono = self->ConvertToMono( red, green, blue );
3670 wxBitmap bitmap( mono, 1 );
3671 return bitmap;
3672 }
3673
3674 wxImage* _ImageFromBuffer(int width, int height,
3675 buffer data, int DATASIZE,
3676 buffer alpha=NULL, int ALPHASIZE=0)
3677 {
3678 if (DATASIZE != width*height*3) {
3679 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3680 return NULL;
3681 }
3682 if (alpha != NULL) {
3683 if (ALPHASIZE != width*height) {
3684 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3685 return NULL;
3686 }
3687 return new wxImage(width, height, data, alpha, true);
3688 }
3689 return new wxImage(width, height, data, true);
3690 }
3691
3692 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3693 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3694 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3696 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3700 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3701 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3702 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3703 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3704 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3705 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3706 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3707
3708 #include <wx/imagtga.h>
3709
3710
3711 #include <wx/quantize.h>
3712
3713 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3714 return wxQuantize::Quantize(src, dest,
3715 //NULL, // palette
3716 desiredNoColours,
3717 NULL, // eightBitData
3718 flags);
3719 }
3720 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3721 if (PyCallable_Check(func)) {
3722 self->Connect(id, lastId, eventType,
3723 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3724 new wxPyCallback(func));
3725 }
3726 else if (func == Py_None) {
3727 self->Disconnect(id, lastId, eventType,
3728 (wxObjectEventFunction)
3729 &wxPyCallback::EventThunker);
3730 }
3731 else {
3732 wxPyBLOCK_THREADS(
3733 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3734 }
3735 }
3736 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3737 return self->Disconnect(id, lastId, eventType,
3738 (wxObjectEventFunction)
3739 &wxPyCallback::EventThunker);
3740 }
3741 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3742 if (_self && _self != Py_None) {
3743 self->SetClientObject(new wxPyOORClientData(_self, incref));
3744 }
3745 else {
3746 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3747 if (data) {
3748 self->SetClientObject(NULL); // This will delete it too
3749 }
3750 }
3751 }
3752
3753 #if ! wxUSE_HOTKEY
3754 #define wxEVT_HOTKEY -9999
3755 #endif
3756
3757 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3758 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3759 if (data) {
3760 Py_INCREF(data->m_obj);
3761 return data->m_obj;
3762 } else {
3763 Py_INCREF(Py_None);
3764 return Py_None;
3765 }
3766 }
3767 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3768 wxPyClientData* data = new wxPyClientData(clientData);
3769 self->SetClientObject(data);
3770 }
3771 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3772 #if wxUSE_UNICODE
3773 return self->GetUnicodeKey();
3774 #else
3775 return 0;
3776 #endif
3777 }
3778 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3779 #if wxUSE_UNICODE
3780 self->m_uniChar = uniChar;
3781 #endif
3782 }
3783
3784 SWIGINTERNINLINE PyObject *
3785 SWIG_From_unsigned_SS_int (unsigned int value)
3786 {
3787 return SWIG_From_unsigned_SS_long (value);
3788 }
3789
3790
3791 SWIGINTERN int
3792 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3793 {
3794 unsigned long v;
3795 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3796 if (SWIG_IsOK(res)) {
3797 if ((v > UINT_MAX)) {
3798 return SWIG_OverflowError;
3799 } else {
3800 if (val) *val = static_cast< unsigned int >(v);
3801 }
3802 }
3803 return res;
3804 }
3805
3806 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3807 self->m_size = size;
3808 }
3809 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3810 int count = self->GetNumberOfFiles();
3811 wxString* files = self->GetFiles();
3812 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3813 PyObject* list = PyList_New(count);
3814
3815 if (!list) {
3816 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3817 wxPyEndBlockThreads(blocked);
3818 return NULL;
3819 }
3820
3821 for (int i=0; i<count; i++) {
3822 PyList_SetItem(list, i, wx2PyString(files[i]));
3823 }
3824 wxPyEndBlockThreads(blocked);
3825 return list;
3826 }
3827
3828
3829 SWIGINTERN wxPyApp *new_wxPyApp(){
3830 wxPythonApp = new wxPyApp();
3831 return wxPythonApp;
3832 }
3833 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3834 return wxPyTestDisplayAvailable();
3835 }
3836
3837 void wxApp_CleanUp() {
3838 __wxPyCleanup();
3839 }
3840
3841
3842 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3843
3844
3845
3846
3847
3848 SWIGINTERNINLINE PyObject *
3849 SWIG_FromCharPtr(const char *cptr)
3850 {
3851 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3852 }
3853
3854
3855 #if 0 // #ifdef __WXMAC__
3856
3857 // A dummy class that raises an exception if used...
3858 class wxEventLoop
3859 {
3860 public:
3861 wxEventLoop() { wxPyRaiseNotImplemented(); }
3862 int Run() { return 0; }
3863 void Exit(int rc = 0) {}
3864 bool Pending() const { return false; }
3865 bool Dispatch() { return false; }
3866 bool IsRunning() const { return false; }
3867 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3868 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3869 };
3870
3871 #else
3872
3873 #include <wx/evtloop.h>
3874
3875 #endif
3876
3877
3878
3879 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3880 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3881 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3882 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3883 wxWindowList& list = self->GetChildren();
3884 return wxPy_ConvertList(&list);
3885 }
3886 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3887 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3888 #if wxUSE_HOTKEY
3889 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3890 #else
3891 return false;
3892 #endif
3893 }
3894 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3895
3896
3897
3898 return false;
3899
3900 }
3901 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3902 return wxPyGetWinHandle(self);
3903 }
3904 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3905 self->AssociateHandle((WXWidget)handle);
3906 }
3907
3908 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3909 return wxWindow::FindWindowById(id, parent);
3910 }
3911
3912 wxWindow* wxFindWindowByName( const wxString& name,
3913 const wxWindow *parent = NULL ) {
3914 return wxWindow::FindWindowByName(name, parent);
3915 }
3916
3917 wxWindow* wxFindWindowByLabel( const wxString& label,
3918 const wxWindow *parent = NULL ) {
3919 return wxWindow::FindWindowByLabel(label, parent);
3920 }
3921
3922
3923 #ifdef __WXMSW__
3924 #include <wx/msw/private.h> // to get wxGetWindowId
3925 #endif
3926
3927
3928 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3929 #ifdef __WXMSW__
3930 WXHWND hWnd = (WXHWND)_hWnd;
3931 long id = wxGetWindowId(hWnd);
3932 wxWindow* win = new wxWindow;
3933 if (parent)
3934 parent->AddChild(win);
3935 win->SetEventHandler(win);
3936 win->SetHWND(hWnd);
3937 win->SetId(id);
3938 win->SubclassWin(hWnd);
3939 win->AdoptAttributesFromHWND();
3940 win->SetupColours();
3941 return win;
3942 #else
3943 wxPyRaiseNotImplemented();
3944 return NULL;
3945 #endif
3946 }
3947
3948
3949 PyObject* GetTopLevelWindows() {
3950 return wxPy_ConvertList(&wxTopLevelWindows);
3951 }
3952
3953
3954 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3955 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3956 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3957
3958 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3959
3960
3961 SWIGINTERNINLINE int
3962 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3963 {
3964 unsigned long v;
3965 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3966 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3967 return res;
3968 }
3969
3970 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3971 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3972 wxMenuItemList& list = self->GetMenuItems();
3973 return wxPy_ConvertList(&list);
3974 }
3975 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3976 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3977 static const wxString wxPyControlNameStr(wxControlNameStr);
3978 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3979 if (clientData) {
3980 wxPyClientData* data = new wxPyClientData(clientData);
3981 return self->Append(item, data);
3982 } else
3983 return self->Append(item);
3984 }
3985 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3986 if (clientData) {
3987 wxPyClientData* data = new wxPyClientData(clientData);
3988 return self->Insert(item, pos, data);
3989 } else
3990 return self->Insert(item, pos);
3991 }
3992 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3993 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3994 if (data) {
3995 Py_INCREF(data->m_obj);
3996 return data->m_obj;
3997 } else {
3998 Py_INCREF(Py_None);
3999 return Py_None;
4000 }
4001 }
4002 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
4003 wxPyClientData* data = new wxPyClientData(clientData);
4004 self->SetClientObject(n, data);
4005 }
4006
4007
4008 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4009 wxPyUserData* data = NULL;
4010 if ( userData ) {
4011 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4012 data = new wxPyUserData(userData);
4013 wxPyEndBlockThreads(blocked);
4014 }
4015 return new wxSizerItem(window, proportion, flag, border, data);
4016 }
4017 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4018 wxPyUserData* data = NULL;
4019 if ( userData ) {
4020 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4021 data = new wxPyUserData(userData);
4022 wxPyEndBlockThreads(blocked);
4023 }
4024 return new wxSizerItem(width, height, proportion, flag, border, data);
4025 }
4026 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4027 wxPyUserData* data = NULL;
4028 if ( userData ) {
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 data = new wxPyUserData(userData);
4031 wxPyEndBlockThreads(blocked);
4032 }
4033 return new wxSizerItem(sizer, proportion, flag, border, data);
4034 }
4035
4036 SWIGINTERNINLINE PyObject *
4037 SWIG_From_float (float value)
4038 {
4039 return SWIG_From_double (value);
4040 }
4041
4042 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4043 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4044 if (data) {
4045 Py_INCREF(data->m_obj);
4046 return data->m_obj;
4047 } else {
4048 Py_INCREF(Py_None);
4049 return Py_None;
4050 }
4051 }
4052 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4053 wxPyUserData* data = NULL;
4054 if ( userData ) {
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 data = new wxPyUserData(userData);
4057 wxPyEndBlockThreads(blocked);
4058 }
4059 self->SetUserData(data);
4060 }
4061
4062 // Figure out the type of the sizer item
4063
4064 struct wxPySizerItemInfo {
4065 wxPySizerItemInfo()
4066 : window(NULL), sizer(NULL), gotSize(false),
4067 size(wxDefaultSize), gotPos(false), pos(-1)
4068 {}
4069
4070 wxWindow* window;
4071 wxSizer* sizer;
4072 bool gotSize;
4073 wxSize size;
4074 bool gotPos;
4075 int pos;
4076 };
4077
4078 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4079
4080 wxPySizerItemInfo info;
4081 wxSize size;
4082 wxSize* sizePtr = &size;
4083
4084 // Find out what the type of the item is
4085 // try wxWindow
4086 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4087 PyErr_Clear();
4088 info.window = NULL;
4089
4090 // try wxSizer
4091 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4092 PyErr_Clear();
4093 info.sizer = NULL;
4094
4095 // try wxSize or (w,h)
4096 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4097 info.size = *sizePtr;
4098 info.gotSize = true;
4099 }
4100
4101 // or a single int
4102 if (checkIdx && PyInt_Check(item)) {
4103 info.pos = PyInt_AsLong(item);
4104 info.gotPos = true;
4105 }
4106 }
4107 }
4108
4109 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4110 // no expected type, figure out what kind of error message to generate
4111 if ( !checkSize && !checkIdx )
4112 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4113 else if ( checkSize && !checkIdx )
4114 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4115 else if ( !checkSize && checkIdx)
4116 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4117 else
4118 // can this one happen?
4119 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4120 }
4121
4122 return info;
4123 }
4124
4125 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4126 if (!self->GetClientObject())
4127 self->SetClientObject(new wxPyOORClientData(_self));
4128 }
4129 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4130
4131 wxPyUserData* data = NULL;
4132 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4133 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4134 if ( userData && (info.window || info.sizer || info.gotSize) )
4135 data = new wxPyUserData(userData);
4136 if ( info.sizer )
4137 PyObject_SetAttrString(item,"thisown",Py_False);
4138 wxPyEndBlockThreads(blocked);
4139
4140 // Now call the real Add method if a valid item type was found
4141 if ( info.window )
4142 return self->Add(info.window, proportion, flag, border, data);
4143 else if ( info.sizer )
4144 return self->Add(info.sizer, proportion, flag, border, data);
4145 else if (info.gotSize)
4146 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4147 proportion, flag, border, data);
4148 else
4149 return NULL;
4150 }
4151 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4152
4153 wxPyUserData* data = NULL;
4154 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4155 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4156 if ( userData && (info.window || info.sizer || info.gotSize) )
4157 data = new wxPyUserData(userData);
4158 if ( info.sizer )
4159 PyObject_SetAttrString(item,"thisown",Py_False);
4160 wxPyEndBlockThreads(blocked);
4161
4162 // Now call the real Insert method if a valid item type was found
4163 if ( info.window )
4164 return self->Insert(before, info.window, proportion, flag, border, data);
4165 else if ( info.sizer )
4166 return self->Insert(before, info.sizer, proportion, flag, border, data);
4167 else if (info.gotSize)
4168 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4169 proportion, flag, border, data);
4170 else
4171 return NULL;
4172 }
4173 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4174
4175 wxPyUserData* data = NULL;
4176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4177 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4178 if ( userData && (info.window || info.sizer || info.gotSize) )
4179 data = new wxPyUserData(userData);
4180 if ( info.sizer )
4181 PyObject_SetAttrString(item,"thisown",Py_False);
4182 wxPyEndBlockThreads(blocked);
4183
4184 // Now call the real Prepend method if a valid item type was found
4185 if ( info.window )
4186 return self->Prepend(info.window, proportion, flag, border, data);
4187 else if ( info.sizer )
4188 return self->Prepend(info.sizer, proportion, flag, border, data);
4189 else if (info.gotSize)
4190 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4191 proportion, flag, border, data);
4192 else
4193 return NULL;
4194 }
4195 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4196 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4198 wxPyEndBlockThreads(blocked);
4199 if ( info.window )
4200 return self->Remove(info.window);
4201 else if ( info.sizer )
4202 return self->Remove(info.sizer);
4203 else if ( info.gotPos )
4204 return self->Remove(info.pos);
4205 else
4206 return false;
4207 }
4208 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4210 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4211 wxPyEndBlockThreads(blocked);
4212 if ( info.window )
4213 return self->Detach(info.window);
4214 else if ( info.sizer )
4215 return self->Detach(info.sizer);
4216 else if ( info.gotPos )
4217 return self->Detach(info.pos);
4218 else
4219 return false;
4220 }
4221 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4222 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4223 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4224 wxPyEndBlockThreads(blocked);
4225 if ( info.window )
4226 return self->GetItem(info.window);
4227 else if ( info.sizer )
4228 return self->GetItem(info.sizer);
4229 else if ( info.gotPos )
4230 return self->GetItem(info.pos);
4231 else
4232 return NULL;
4233 }
4234 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4235 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4236 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4237 wxPyEndBlockThreads(blocked);
4238 if ( info.window )
4239 self->SetItemMinSize(info.window, size);
4240 else if ( info.sizer )
4241 self->SetItemMinSize(info.sizer, size);
4242 else if ( info.gotPos )
4243 self->SetItemMinSize(info.pos, size);
4244 }
4245 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4246 wxSizerItemList& list = self->GetChildren();
4247 return wxPy_ConvertList(&list);
4248 }
4249 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4250 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4251 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4252 wxPyEndBlockThreads(blocked);
4253 if ( info.window )
4254 return self->Show(info.window, show, recursive);
4255 else if ( info.sizer )
4256 return self->Show(info.sizer, show, recursive);
4257 else if ( info.gotPos )
4258 return self->Show(info.pos, show);
4259 else
4260 return false;
4261 }
4262 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4263 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4264 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4265 wxPyEndBlockThreads(blocked);
4266 if ( info.window )
4267 return self->IsShown(info.window);
4268 else if ( info.sizer )
4269 return self->IsShown(info.sizer);
4270 else if ( info.gotPos )
4271 return self->IsShown(info.pos);
4272 else
4273 return false;
4274 }
4275
4276 // See pyclasses.h
4277 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4278 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4279 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4280
4281
4282
4283
4284 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4285 {
4286 if (source == Py_None) {
4287 **obj = wxGBPosition(-1,-1);
4288 return true;
4289 }
4290 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4291 }
4292
4293 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4294 {
4295 if (source == Py_None) {
4296 **obj = wxGBSpan(-1,-1);
4297 return true;
4298 }
4299 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4300 }
4301
4302
4303 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4304 wxGBPosition temp, *obj = &temp;
4305 if ( other == Py_None ) return false;
4306 if ( ! wxGBPosition_helper(other, &obj) ) {
4307 PyErr_Clear();
4308 return false;
4309 }
4310 return self->operator==(*obj);
4311 }
4312 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4313 wxGBPosition temp, *obj = &temp;
4314 if ( other == Py_None ) return true;
4315 if ( ! wxGBPosition_helper(other, &obj)) {
4316 PyErr_Clear();
4317 return true;
4318 }
4319 return self->operator!=(*obj);
4320 }
4321 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4322 self->SetRow(row);
4323 self->SetCol(col);
4324 }
4325 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4326 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4327 PyObject* tup = PyTuple_New(2);
4328 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4329 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4330 wxPyEndBlockThreads(blocked);
4331 return tup;
4332 }
4333 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4334 wxGBSpan temp, *obj = &temp;
4335 if ( other == Py_None ) return false;
4336 if ( ! wxGBSpan_helper(other, &obj) ) {
4337 PyErr_Clear();
4338 return false;
4339 }
4340 return self->operator==(*obj);
4341 }
4342 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4343 wxGBSpan temp, *obj = &temp;
4344 if ( other == Py_None ) return true;
4345 if ( ! wxGBSpan_helper(other, &obj)) {
4346 PyErr_Clear();
4347 return true;
4348 }
4349 return self->operator!=(*obj);
4350 }
4351 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4352 self->SetRowspan(rowspan);
4353 self->SetColspan(colspan);
4354 }
4355 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4356 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4357 PyObject* tup = PyTuple_New(2);
4358 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4359 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4360 wxPyEndBlockThreads(blocked);
4361 return tup;
4362 }
4363 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4364 wxPyUserData* data = NULL;
4365 if ( userData ) {
4366 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4367 data = new wxPyUserData(userData);
4368 wxPyEndBlockThreads(blocked);
4369 }
4370 return new wxGBSizerItem(window, pos, span, flag, border, data);
4371 }
4372 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4373 wxPyUserData* data = NULL;
4374 if ( userData ) {
4375 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4376 data = new wxPyUserData(userData);
4377 wxPyEndBlockThreads(blocked);
4378 }
4379 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4380 }
4381 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4382 wxPyUserData* data = NULL;
4383 if ( userData ) {
4384 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4385 data = new wxPyUserData(userData);
4386 wxPyEndBlockThreads(blocked);
4387 }
4388 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4389 }
4390 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4391 int row, col;
4392 self->GetEndPos(row, col);
4393 return wxGBPosition(row, col);
4394 }
4395 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4396
4397 wxPyUserData* data = NULL;
4398 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4399 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4400 if ( userData && (info.window || info.sizer || info.gotSize) )
4401 data = new wxPyUserData(userData);
4402 if ( info.sizer )
4403 PyObject_SetAttrString(item,"thisown",Py_False);
4404 wxPyEndBlockThreads(blocked);
4405
4406 // Now call the real Add method if a valid item type was found
4407 if ( info.window )
4408 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4409 else if ( info.sizer )
4410 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4411 else if (info.gotSize)
4412 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4413 pos, span, flag, border, data);
4414 return NULL;
4415 }
4416
4417
4418 #ifdef __cplusplus
4419 extern "C" {
4420 #endif
4421 SWIGINTERN int EmptyString_set(PyObject *) {
4422 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4423 return 1;
4424 }
4425
4426
4427 SWIGINTERN PyObject *EmptyString_get(void) {
4428 PyObject *pyobj = 0;
4429
4430 {
4431 #if wxUSE_UNICODE
4432 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4433 #else
4434 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4435 #endif
4436 }
4437 return pyobj;
4438 }
4439
4440
4441 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4442 PyObject *resultobj = 0;
4443 wxObject *arg1 = (wxObject *) 0 ;
4444 wxString result;
4445 void *argp1 = 0 ;
4446 int res1 = 0 ;
4447 PyObject *swig_obj[1] ;
4448
4449 if (!args) SWIG_fail;
4450 swig_obj[0] = args;
4451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4452 if (!SWIG_IsOK(res1)) {
4453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4454 }
4455 arg1 = reinterpret_cast< wxObject * >(argp1);
4456 {
4457 PyThreadState* __tstate = wxPyBeginAllowThreads();
4458 result = wxObject_GetClassName(arg1);
4459 wxPyEndAllowThreads(__tstate);
4460 if (PyErr_Occurred()) SWIG_fail;
4461 }
4462 {
4463 #if wxUSE_UNICODE
4464 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4465 #else
4466 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4467 #endif
4468 }
4469 return resultobj;
4470 fail:
4471 return NULL;
4472 }
4473
4474
4475 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4476 PyObject *resultobj = 0;
4477 wxObject *arg1 = (wxObject *) 0 ;
4478 void *argp1 = 0 ;
4479 int res1 = 0 ;
4480 PyObject *swig_obj[1] ;
4481
4482 if (!args) SWIG_fail;
4483 swig_obj[0] = args;
4484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4485 if (!SWIG_IsOK(res1)) {
4486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4487 }
4488 arg1 = reinterpret_cast< wxObject * >(argp1);
4489 {
4490 PyThreadState* __tstate = wxPyBeginAllowThreads();
4491 wxObject_Destroy(arg1);
4492 wxPyEndAllowThreads(__tstate);
4493 if (PyErr_Occurred()) SWIG_fail;
4494 }
4495 resultobj = SWIG_Py_Void();
4496 return resultobj;
4497 fail:
4498 return NULL;
4499 }
4500
4501
4502 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4503 PyObject *resultobj = 0;
4504 wxObject *arg1 = (wxObject *) 0 ;
4505 wxObject *arg2 = 0 ;
4506 bool result;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509 void *argp2 = 0 ;
4510 int res2 = 0 ;
4511 PyObject * obj0 = 0 ;
4512 PyObject * obj1 = 0 ;
4513 char * kwnames[] = {
4514 (char *) "self",(char *) "p", NULL
4515 };
4516
4517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4519 if (!SWIG_IsOK(res1)) {
4520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4521 }
4522 arg1 = reinterpret_cast< wxObject * >(argp1);
4523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4524 if (!SWIG_IsOK(res2)) {
4525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4526 }
4527 if (!argp2) {
4528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4529 }
4530 arg2 = reinterpret_cast< wxObject * >(argp2);
4531 {
4532 PyThreadState* __tstate = wxPyBeginAllowThreads();
4533 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4534 wxPyEndAllowThreads(__tstate);
4535 if (PyErr_Occurred()) SWIG_fail;
4536 }
4537 {
4538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4539 }
4540 return resultobj;
4541 fail:
4542 return NULL;
4543 }
4544
4545
4546 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4547 PyObject *obj;
4548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4549 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4550 return SWIG_Py_Void();
4551 }
4552
4553 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4554 PyObject *resultobj = 0;
4555 wxSize *arg1 = (wxSize *) 0 ;
4556 int arg2 ;
4557 void *argp1 = 0 ;
4558 int res1 = 0 ;
4559 int val2 ;
4560 int ecode2 = 0 ;
4561 PyObject *swig_obj[2] ;
4562
4563 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4565 if (!SWIG_IsOK(res1)) {
4566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4567 }
4568 arg1 = reinterpret_cast< wxSize * >(argp1);
4569 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4570 if (!SWIG_IsOK(ecode2)) {
4571 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4572 }
4573 arg2 = static_cast< int >(val2);
4574 if (arg1) (arg1)->x = arg2;
4575
4576 resultobj = SWIG_Py_Void();
4577 return resultobj;
4578 fail:
4579 return NULL;
4580 }
4581
4582
4583 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4584 PyObject *resultobj = 0;
4585 wxSize *arg1 = (wxSize *) 0 ;
4586 int result;
4587 void *argp1 = 0 ;
4588 int res1 = 0 ;
4589 PyObject *swig_obj[1] ;
4590
4591 if (!args) SWIG_fail;
4592 swig_obj[0] = args;
4593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4594 if (!SWIG_IsOK(res1)) {
4595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4596 }
4597 arg1 = reinterpret_cast< wxSize * >(argp1);
4598 result = (int) ((arg1)->x);
4599 resultobj = SWIG_From_int(static_cast< int >(result));
4600 return resultobj;
4601 fail:
4602 return NULL;
4603 }
4604
4605
4606 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4607 PyObject *resultobj = 0;
4608 wxSize *arg1 = (wxSize *) 0 ;
4609 int arg2 ;
4610 void *argp1 = 0 ;
4611 int res1 = 0 ;
4612 int val2 ;
4613 int ecode2 = 0 ;
4614 PyObject *swig_obj[2] ;
4615
4616 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4618 if (!SWIG_IsOK(res1)) {
4619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4620 }
4621 arg1 = reinterpret_cast< wxSize * >(argp1);
4622 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4623 if (!SWIG_IsOK(ecode2)) {
4624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4625 }
4626 arg2 = static_cast< int >(val2);
4627 if (arg1) (arg1)->y = arg2;
4628
4629 resultobj = SWIG_Py_Void();
4630 return resultobj;
4631 fail:
4632 return NULL;
4633 }
4634
4635
4636 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4637 PyObject *resultobj = 0;
4638 wxSize *arg1 = (wxSize *) 0 ;
4639 int result;
4640 void *argp1 = 0 ;
4641 int res1 = 0 ;
4642 PyObject *swig_obj[1] ;
4643
4644 if (!args) SWIG_fail;
4645 swig_obj[0] = args;
4646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4647 if (!SWIG_IsOK(res1)) {
4648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4649 }
4650 arg1 = reinterpret_cast< wxSize * >(argp1);
4651 result = (int) ((arg1)->y);
4652 resultobj = SWIG_From_int(static_cast< int >(result));
4653 return resultobj;
4654 fail:
4655 return NULL;
4656 }
4657
4658
4659 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4660 PyObject *resultobj = 0;
4661 int arg1 = (int) 0 ;
4662 int arg2 = (int) 0 ;
4663 wxSize *result = 0 ;
4664 int val1 ;
4665 int ecode1 = 0 ;
4666 int val2 ;
4667 int ecode2 = 0 ;
4668 PyObject * obj0 = 0 ;
4669 PyObject * obj1 = 0 ;
4670 char * kwnames[] = {
4671 (char *) "w",(char *) "h", NULL
4672 };
4673
4674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4675 if (obj0) {
4676 ecode1 = SWIG_AsVal_int(obj0, &val1);
4677 if (!SWIG_IsOK(ecode1)) {
4678 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4679 }
4680 arg1 = static_cast< int >(val1);
4681 }
4682 if (obj1) {
4683 ecode2 = SWIG_AsVal_int(obj1, &val2);
4684 if (!SWIG_IsOK(ecode2)) {
4685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4686 }
4687 arg2 = static_cast< int >(val2);
4688 }
4689 {
4690 result = (wxSize *)new wxSize(arg1,arg2);
4691 if (PyErr_Occurred()) SWIG_fail;
4692 }
4693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4694 return resultobj;
4695 fail:
4696 return NULL;
4697 }
4698
4699
4700 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4701 PyObject *resultobj = 0;
4702 wxSize *arg1 = (wxSize *) 0 ;
4703 void *argp1 = 0 ;
4704 int res1 = 0 ;
4705 PyObject *swig_obj[1] ;
4706
4707 if (!args) SWIG_fail;
4708 swig_obj[0] = args;
4709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4710 if (!SWIG_IsOK(res1)) {
4711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4712 }
4713 arg1 = reinterpret_cast< wxSize * >(argp1);
4714 {
4715 delete arg1;
4716
4717 if (PyErr_Occurred()) SWIG_fail;
4718 }
4719 resultobj = SWIG_Py_Void();
4720 return resultobj;
4721 fail:
4722 return NULL;
4723 }
4724
4725
4726 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4727 PyObject *resultobj = 0;
4728 wxSize *arg1 = (wxSize *) 0 ;
4729 PyObject *arg2 = (PyObject *) 0 ;
4730 bool result;
4731 void *argp1 = 0 ;
4732 int res1 = 0 ;
4733 PyObject * obj0 = 0 ;
4734 PyObject * obj1 = 0 ;
4735 char * kwnames[] = {
4736 (char *) "self",(char *) "other", NULL
4737 };
4738
4739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4741 if (!SWIG_IsOK(res1)) {
4742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4743 }
4744 arg1 = reinterpret_cast< wxSize * >(argp1);
4745 arg2 = obj1;
4746 {
4747 result = (bool)wxSize___eq__(arg1,arg2);
4748 if (PyErr_Occurred()) SWIG_fail;
4749 }
4750 {
4751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4752 }
4753 return resultobj;
4754 fail:
4755 return NULL;
4756 }
4757
4758
4759 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4760 PyObject *resultobj = 0;
4761 wxSize *arg1 = (wxSize *) 0 ;
4762 PyObject *arg2 = (PyObject *) 0 ;
4763 bool result;
4764 void *argp1 = 0 ;
4765 int res1 = 0 ;
4766 PyObject * obj0 = 0 ;
4767 PyObject * obj1 = 0 ;
4768 char * kwnames[] = {
4769 (char *) "self",(char *) "other", NULL
4770 };
4771
4772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4774 if (!SWIG_IsOK(res1)) {
4775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4776 }
4777 arg1 = reinterpret_cast< wxSize * >(argp1);
4778 arg2 = obj1;
4779 {
4780 result = (bool)wxSize___ne__(arg1,arg2);
4781 if (PyErr_Occurred()) SWIG_fail;
4782 }
4783 {
4784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4785 }
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj = 0;
4794 wxSize *arg1 = (wxSize *) 0 ;
4795 wxSize *arg2 = 0 ;
4796 wxSize result;
4797 void *argp1 = 0 ;
4798 int res1 = 0 ;
4799 wxSize temp2 ;
4800 PyObject * obj0 = 0 ;
4801 PyObject * obj1 = 0 ;
4802 char * kwnames[] = {
4803 (char *) "self",(char *) "sz", NULL
4804 };
4805
4806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4808 if (!SWIG_IsOK(res1)) {
4809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4810 }
4811 arg1 = reinterpret_cast< wxSize * >(argp1);
4812 {
4813 arg2 = &temp2;
4814 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4815 }
4816 {
4817 result = (arg1)->operator +((wxSize const &)*arg2);
4818 if (PyErr_Occurred()) SWIG_fail;
4819 }
4820 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4821 return resultobj;
4822 fail:
4823 return NULL;
4824 }
4825
4826
4827 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4828 PyObject *resultobj = 0;
4829 wxSize *arg1 = (wxSize *) 0 ;
4830 wxSize *arg2 = 0 ;
4831 wxSize result;
4832 void *argp1 = 0 ;
4833 int res1 = 0 ;
4834 wxSize temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char * kwnames[] = {
4838 (char *) "self",(char *) "sz", NULL
4839 };
4840
4841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4843 if (!SWIG_IsOK(res1)) {
4844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4845 }
4846 arg1 = reinterpret_cast< wxSize * >(argp1);
4847 {
4848 arg2 = &temp2;
4849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4850 }
4851 {
4852 result = (arg1)->operator -((wxSize const &)*arg2);
4853 if (PyErr_Occurred()) SWIG_fail;
4854 }
4855 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4856 return resultobj;
4857 fail:
4858 return NULL;
4859 }
4860
4861
4862 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4863 PyObject *resultobj = 0;
4864 wxSize *arg1 = (wxSize *) 0 ;
4865 wxSize *arg2 = 0 ;
4866 void *argp1 = 0 ;
4867 int res1 = 0 ;
4868 wxSize temp2 ;
4869 PyObject * obj0 = 0 ;
4870 PyObject * obj1 = 0 ;
4871 char * kwnames[] = {
4872 (char *) "self",(char *) "sz", NULL
4873 };
4874
4875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4877 if (!SWIG_IsOK(res1)) {
4878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4879 }
4880 arg1 = reinterpret_cast< wxSize * >(argp1);
4881 {
4882 arg2 = &temp2;
4883 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4884 }
4885 {
4886 (arg1)->IncTo((wxSize const &)*arg2);
4887 if (PyErr_Occurred()) SWIG_fail;
4888 }
4889 resultobj = SWIG_Py_Void();
4890 return resultobj;
4891 fail:
4892 return NULL;
4893 }
4894
4895
4896 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4897 PyObject *resultobj = 0;
4898 wxSize *arg1 = (wxSize *) 0 ;
4899 wxSize *arg2 = 0 ;
4900 void *argp1 = 0 ;
4901 int res1 = 0 ;
4902 wxSize temp2 ;
4903 PyObject * obj0 = 0 ;
4904 PyObject * obj1 = 0 ;
4905 char * kwnames[] = {
4906 (char *) "self",(char *) "sz", NULL
4907 };
4908
4909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4911 if (!SWIG_IsOK(res1)) {
4912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4913 }
4914 arg1 = reinterpret_cast< wxSize * >(argp1);
4915 {
4916 arg2 = &temp2;
4917 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4918 }
4919 {
4920 (arg1)->DecTo((wxSize const &)*arg2);
4921 if (PyErr_Occurred()) SWIG_fail;
4922 }
4923 resultobj = SWIG_Py_Void();
4924 return resultobj;
4925 fail:
4926 return NULL;
4927 }
4928
4929
4930 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4931 PyObject *resultobj = 0;
4932 wxSize *arg1 = (wxSize *) 0 ;
4933 int arg2 ;
4934 int arg3 ;
4935 void *argp1 = 0 ;
4936 int res1 = 0 ;
4937 int val2 ;
4938 int ecode2 = 0 ;
4939 int val3 ;
4940 int ecode3 = 0 ;
4941 PyObject * obj0 = 0 ;
4942 PyObject * obj1 = 0 ;
4943 PyObject * obj2 = 0 ;
4944 char * kwnames[] = {
4945 (char *) "self",(char *) "dx",(char *) "dy", NULL
4946 };
4947
4948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4950 if (!SWIG_IsOK(res1)) {
4951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4952 }
4953 arg1 = reinterpret_cast< wxSize * >(argp1);
4954 ecode2 = SWIG_AsVal_int(obj1, &val2);
4955 if (!SWIG_IsOK(ecode2)) {
4956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4957 }
4958 arg2 = static_cast< int >(val2);
4959 ecode3 = SWIG_AsVal_int(obj2, &val3);
4960 if (!SWIG_IsOK(ecode3)) {
4961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4962 }
4963 arg3 = static_cast< int >(val3);
4964 {
4965 (arg1)->IncBy(arg2,arg3);
4966 if (PyErr_Occurred()) SWIG_fail;
4967 }
4968 resultobj = SWIG_Py_Void();
4969 return resultobj;
4970 fail:
4971 return NULL;
4972 }
4973
4974
4975 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4976 PyObject *resultobj = 0;
4977 wxSize *arg1 = (wxSize *) 0 ;
4978 int arg2 ;
4979 int arg3 ;
4980 void *argp1 = 0 ;
4981 int res1 = 0 ;
4982 int val2 ;
4983 int ecode2 = 0 ;
4984 int val3 ;
4985 int ecode3 = 0 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 PyObject * obj2 = 0 ;
4989 char * kwnames[] = {
4990 (char *) "self",(char *) "dx",(char *) "dy", NULL
4991 };
4992
4993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4995 if (!SWIG_IsOK(res1)) {
4996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4997 }
4998 arg1 = reinterpret_cast< wxSize * >(argp1);
4999 ecode2 = SWIG_AsVal_int(obj1, &val2);
5000 if (!SWIG_IsOK(ecode2)) {
5001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5002 }
5003 arg2 = static_cast< int >(val2);
5004 ecode3 = SWIG_AsVal_int(obj2, &val3);
5005 if (!SWIG_IsOK(ecode3)) {
5006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5007 }
5008 arg3 = static_cast< int >(val3);
5009 {
5010 (arg1)->DecBy(arg2,arg3);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 float arg2 ;
5024 float arg3 ;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 float val2 ;
5028 int ecode2 = 0 ;
5029 float val3 ;
5030 int ecode3 = 0 ;
5031 PyObject * obj0 = 0 ;
5032 PyObject * obj1 = 0 ;
5033 PyObject * obj2 = 0 ;
5034 char * kwnames[] = {
5035 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5036 };
5037
5038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5040 if (!SWIG_IsOK(res1)) {
5041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5042 }
5043 arg1 = reinterpret_cast< wxSize * >(argp1);
5044 ecode2 = SWIG_AsVal_float(obj1, &val2);
5045 if (!SWIG_IsOK(ecode2)) {
5046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5047 }
5048 arg2 = static_cast< float >(val2);
5049 ecode3 = SWIG_AsVal_float(obj2, &val3);
5050 if (!SWIG_IsOK(ecode3)) {
5051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5052 }
5053 arg3 = static_cast< float >(val3);
5054 {
5055 (arg1)->Scale(arg2,arg3);
5056 if (PyErr_Occurred()) SWIG_fail;
5057 }
5058 resultobj = SWIG_Py_Void();
5059 return resultobj;
5060 fail:
5061 return NULL;
5062 }
5063
5064
5065 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5066 PyObject *resultobj = 0;
5067 wxSize *arg1 = (wxSize *) 0 ;
5068 int arg2 ;
5069 int arg3 ;
5070 void *argp1 = 0 ;
5071 int res1 = 0 ;
5072 int val2 ;
5073 int ecode2 = 0 ;
5074 int val3 ;
5075 int ecode3 = 0 ;
5076 PyObject * obj0 = 0 ;
5077 PyObject * obj1 = 0 ;
5078 PyObject * obj2 = 0 ;
5079 char * kwnames[] = {
5080 (char *) "self",(char *) "w",(char *) "h", NULL
5081 };
5082
5083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5087 }
5088 arg1 = reinterpret_cast< wxSize * >(argp1);
5089 ecode2 = SWIG_AsVal_int(obj1, &val2);
5090 if (!SWIG_IsOK(ecode2)) {
5091 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5092 }
5093 arg2 = static_cast< int >(val2);
5094 ecode3 = SWIG_AsVal_int(obj2, &val3);
5095 if (!SWIG_IsOK(ecode3)) {
5096 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5097 }
5098 arg3 = static_cast< int >(val3);
5099 {
5100 (arg1)->Set(arg2,arg3);
5101 if (PyErr_Occurred()) SWIG_fail;
5102 }
5103 resultobj = SWIG_Py_Void();
5104 return resultobj;
5105 fail:
5106 return NULL;
5107 }
5108
5109
5110 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5111 PyObject *resultobj = 0;
5112 wxSize *arg1 = (wxSize *) 0 ;
5113 int arg2 ;
5114 void *argp1 = 0 ;
5115 int res1 = 0 ;
5116 int val2 ;
5117 int ecode2 = 0 ;
5118 PyObject * obj0 = 0 ;
5119 PyObject * obj1 = 0 ;
5120 char * kwnames[] = {
5121 (char *) "self",(char *) "w", NULL
5122 };
5123
5124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5126 if (!SWIG_IsOK(res1)) {
5127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5128 }
5129 arg1 = reinterpret_cast< wxSize * >(argp1);
5130 ecode2 = SWIG_AsVal_int(obj1, &val2);
5131 if (!SWIG_IsOK(ecode2)) {
5132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5133 }
5134 arg2 = static_cast< int >(val2);
5135 {
5136 (arg1)->SetWidth(arg2);
5137 if (PyErr_Occurred()) SWIG_fail;
5138 }
5139 resultobj = SWIG_Py_Void();
5140 return resultobj;
5141 fail:
5142 return NULL;
5143 }
5144
5145
5146 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5147 PyObject *resultobj = 0;
5148 wxSize *arg1 = (wxSize *) 0 ;
5149 int arg2 ;
5150 void *argp1 = 0 ;
5151 int res1 = 0 ;
5152 int val2 ;
5153 int ecode2 = 0 ;
5154 PyObject * obj0 = 0 ;
5155 PyObject * obj1 = 0 ;
5156 char * kwnames[] = {
5157 (char *) "self",(char *) "h", NULL
5158 };
5159
5160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5162 if (!SWIG_IsOK(res1)) {
5163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5164 }
5165 arg1 = reinterpret_cast< wxSize * >(argp1);
5166 ecode2 = SWIG_AsVal_int(obj1, &val2);
5167 if (!SWIG_IsOK(ecode2)) {
5168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5169 }
5170 arg2 = static_cast< int >(val2);
5171 {
5172 (arg1)->SetHeight(arg2);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 resultobj = SWIG_Py_Void();
5176 return resultobj;
5177 fail:
5178 return NULL;
5179 }
5180
5181
5182 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5183 PyObject *resultobj = 0;
5184 wxSize *arg1 = (wxSize *) 0 ;
5185 int result;
5186 void *argp1 = 0 ;
5187 int res1 = 0 ;
5188 PyObject *swig_obj[1] ;
5189
5190 if (!args) SWIG_fail;
5191 swig_obj[0] = args;
5192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5193 if (!SWIG_IsOK(res1)) {
5194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5195 }
5196 arg1 = reinterpret_cast< wxSize * >(argp1);
5197 {
5198 result = (int)((wxSize const *)arg1)->GetWidth();
5199 if (PyErr_Occurred()) SWIG_fail;
5200 }
5201 resultobj = SWIG_From_int(static_cast< int >(result));
5202 return resultobj;
5203 fail:
5204 return NULL;
5205 }
5206
5207
5208 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5209 PyObject *resultobj = 0;
5210 wxSize *arg1 = (wxSize *) 0 ;
5211 int result;
5212 void *argp1 = 0 ;
5213 int res1 = 0 ;
5214 PyObject *swig_obj[1] ;
5215
5216 if (!args) SWIG_fail;
5217 swig_obj[0] = args;
5218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5219 if (!SWIG_IsOK(res1)) {
5220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5221 }
5222 arg1 = reinterpret_cast< wxSize * >(argp1);
5223 {
5224 result = (int)((wxSize const *)arg1)->GetHeight();
5225 if (PyErr_Occurred()) SWIG_fail;
5226 }
5227 resultobj = SWIG_From_int(static_cast< int >(result));
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5235 PyObject *resultobj = 0;
5236 wxSize *arg1 = (wxSize *) 0 ;
5237 bool result;
5238 void *argp1 = 0 ;
5239 int res1 = 0 ;
5240 PyObject *swig_obj[1] ;
5241
5242 if (!args) SWIG_fail;
5243 swig_obj[0] = args;
5244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5245 if (!SWIG_IsOK(res1)) {
5246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5247 }
5248 arg1 = reinterpret_cast< wxSize * >(argp1);
5249 {
5250 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5251 if (PyErr_Occurred()) SWIG_fail;
5252 }
5253 {
5254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5255 }
5256 return resultobj;
5257 fail:
5258 return NULL;
5259 }
5260
5261
5262 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5263 PyObject *resultobj = 0;
5264 wxSize *arg1 = (wxSize *) 0 ;
5265 wxSize *arg2 = 0 ;
5266 void *argp1 = 0 ;
5267 int res1 = 0 ;
5268 wxSize temp2 ;
5269 PyObject * obj0 = 0 ;
5270 PyObject * obj1 = 0 ;
5271 char * kwnames[] = {
5272 (char *) "self",(char *) "size", NULL
5273 };
5274
5275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5277 if (!SWIG_IsOK(res1)) {
5278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5279 }
5280 arg1 = reinterpret_cast< wxSize * >(argp1);
5281 {
5282 arg2 = &temp2;
5283 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5284 }
5285 {
5286 (arg1)->SetDefaults((wxSize const &)*arg2);
5287 if (PyErr_Occurred()) SWIG_fail;
5288 }
5289 resultobj = SWIG_Py_Void();
5290 return resultobj;
5291 fail:
5292 return NULL;
5293 }
5294
5295
5296 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5297 PyObject *resultobj = 0;
5298 wxSize *arg1 = (wxSize *) 0 ;
5299 PyObject *result = 0 ;
5300 void *argp1 = 0 ;
5301 int res1 = 0 ;
5302 PyObject *swig_obj[1] ;
5303
5304 if (!args) SWIG_fail;
5305 swig_obj[0] = args;
5306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5307 if (!SWIG_IsOK(res1)) {
5308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5309 }
5310 arg1 = reinterpret_cast< wxSize * >(argp1);
5311 {
5312 result = (PyObject *)wxSize_Get(arg1);
5313 if (PyErr_Occurred()) SWIG_fail;
5314 }
5315 resultobj = result;
5316 return resultobj;
5317 fail:
5318 return NULL;
5319 }
5320
5321
5322 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5323 PyObject *obj;
5324 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5325 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5326 return SWIG_Py_Void();
5327 }
5328
5329 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5330 return SWIG_Python_InitShadowInstance(args);
5331 }
5332
5333 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5334 PyObject *resultobj = 0;
5335 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5336 double arg2 ;
5337 void *argp1 = 0 ;
5338 int res1 = 0 ;
5339 double val2 ;
5340 int ecode2 = 0 ;
5341 PyObject *swig_obj[2] ;
5342
5343 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5345 if (!SWIG_IsOK(res1)) {
5346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5347 }
5348 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5349 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5350 if (!SWIG_IsOK(ecode2)) {
5351 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5352 }
5353 arg2 = static_cast< double >(val2);
5354 if (arg1) (arg1)->x = arg2;
5355
5356 resultobj = SWIG_Py_Void();
5357 return resultobj;
5358 fail:
5359 return NULL;
5360 }
5361
5362
5363 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5364 PyObject *resultobj = 0;
5365 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5366 double result;
5367 void *argp1 = 0 ;
5368 int res1 = 0 ;
5369 PyObject *swig_obj[1] ;
5370
5371 if (!args) SWIG_fail;
5372 swig_obj[0] = args;
5373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5374 if (!SWIG_IsOK(res1)) {
5375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5376 }
5377 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5378 result = (double) ((arg1)->x);
5379 resultobj = SWIG_From_double(static_cast< double >(result));
5380 return resultobj;
5381 fail:
5382 return NULL;
5383 }
5384
5385
5386 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5387 PyObject *resultobj = 0;
5388 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5389 double arg2 ;
5390 void *argp1 = 0 ;
5391 int res1 = 0 ;
5392 double val2 ;
5393 int ecode2 = 0 ;
5394 PyObject *swig_obj[2] ;
5395
5396 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5398 if (!SWIG_IsOK(res1)) {
5399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5400 }
5401 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5402 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5403 if (!SWIG_IsOK(ecode2)) {
5404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5405 }
5406 arg2 = static_cast< double >(val2);
5407 if (arg1) (arg1)->y = arg2;
5408
5409 resultobj = SWIG_Py_Void();
5410 return resultobj;
5411 fail:
5412 return NULL;
5413 }
5414
5415
5416 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5417 PyObject *resultobj = 0;
5418 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5419 double result;
5420 void *argp1 = 0 ;
5421 int res1 = 0 ;
5422 PyObject *swig_obj[1] ;
5423
5424 if (!args) SWIG_fail;
5425 swig_obj[0] = args;
5426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5427 if (!SWIG_IsOK(res1)) {
5428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5429 }
5430 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5431 result = (double) ((arg1)->y);
5432 resultobj = SWIG_From_double(static_cast< double >(result));
5433 return resultobj;
5434 fail:
5435 return NULL;
5436 }
5437
5438
5439 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5440 PyObject *resultobj = 0;
5441 double arg1 = (double) 0.0 ;
5442 double arg2 = (double) 0.0 ;
5443 wxRealPoint *result = 0 ;
5444 double val1 ;
5445 int ecode1 = 0 ;
5446 double val2 ;
5447 int ecode2 = 0 ;
5448 PyObject * obj0 = 0 ;
5449 PyObject * obj1 = 0 ;
5450 char * kwnames[] = {
5451 (char *) "x",(char *) "y", NULL
5452 };
5453
5454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5455 if (obj0) {
5456 ecode1 = SWIG_AsVal_double(obj0, &val1);
5457 if (!SWIG_IsOK(ecode1)) {
5458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5459 }
5460 arg1 = static_cast< double >(val1);
5461 }
5462 if (obj1) {
5463 ecode2 = SWIG_AsVal_double(obj1, &val2);
5464 if (!SWIG_IsOK(ecode2)) {
5465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5466 }
5467 arg2 = static_cast< double >(val2);
5468 }
5469 {
5470 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5471 if (PyErr_Occurred()) SWIG_fail;
5472 }
5473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5474 return resultobj;
5475 fail:
5476 return NULL;
5477 }
5478
5479
5480 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5481 PyObject *resultobj = 0;
5482 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5483 void *argp1 = 0 ;
5484 int res1 = 0 ;
5485 PyObject *swig_obj[1] ;
5486
5487 if (!args) SWIG_fail;
5488 swig_obj[0] = args;
5489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5490 if (!SWIG_IsOK(res1)) {
5491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5492 }
5493 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5494 {
5495 delete arg1;
5496
5497 if (PyErr_Occurred()) SWIG_fail;
5498 }
5499 resultobj = SWIG_Py_Void();
5500 return resultobj;
5501 fail:
5502 return NULL;
5503 }
5504
5505
5506 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5507 PyObject *resultobj = 0;
5508 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5509 PyObject *arg2 = (PyObject *) 0 ;
5510 bool result;
5511 void *argp1 = 0 ;
5512 int res1 = 0 ;
5513 PyObject * obj0 = 0 ;
5514 PyObject * obj1 = 0 ;
5515 char * kwnames[] = {
5516 (char *) "self",(char *) "other", NULL
5517 };
5518
5519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5521 if (!SWIG_IsOK(res1)) {
5522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5523 }
5524 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5525 arg2 = obj1;
5526 {
5527 result = (bool)wxRealPoint___eq__(arg1,arg2);
5528 if (PyErr_Occurred()) SWIG_fail;
5529 }
5530 {
5531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5532 }
5533 return resultobj;
5534 fail:
5535 return NULL;
5536 }
5537
5538
5539 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5540 PyObject *resultobj = 0;
5541 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5542 PyObject *arg2 = (PyObject *) 0 ;
5543 bool result;
5544 void *argp1 = 0 ;
5545 int res1 = 0 ;
5546 PyObject * obj0 = 0 ;
5547 PyObject * obj1 = 0 ;
5548 char * kwnames[] = {
5549 (char *) "self",(char *) "other", NULL
5550 };
5551
5552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5554 if (!SWIG_IsOK(res1)) {
5555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5556 }
5557 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5558 arg2 = obj1;
5559 {
5560 result = (bool)wxRealPoint___ne__(arg1,arg2);
5561 if (PyErr_Occurred()) SWIG_fail;
5562 }
5563 {
5564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5565 }
5566 return resultobj;
5567 fail:
5568 return NULL;
5569 }
5570
5571
5572 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5573 PyObject *resultobj = 0;
5574 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5575 wxRealPoint *arg2 = 0 ;
5576 wxRealPoint result;
5577 void *argp1 = 0 ;
5578 int res1 = 0 ;
5579 wxRealPoint temp2 ;
5580 PyObject * obj0 = 0 ;
5581 PyObject * obj1 = 0 ;
5582 char * kwnames[] = {
5583 (char *) "self",(char *) "pt", NULL
5584 };
5585
5586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5588 if (!SWIG_IsOK(res1)) {
5589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5590 }
5591 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5592 {
5593 arg2 = &temp2;
5594 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5595 }
5596 {
5597 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5598 if (PyErr_Occurred()) SWIG_fail;
5599 }
5600 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5601 return resultobj;
5602 fail:
5603 return NULL;
5604 }
5605
5606
5607 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5608 PyObject *resultobj = 0;
5609 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5610 wxRealPoint *arg2 = 0 ;
5611 wxRealPoint result;
5612 void *argp1 = 0 ;
5613 int res1 = 0 ;
5614 wxRealPoint temp2 ;
5615 PyObject * obj0 = 0 ;
5616 PyObject * obj1 = 0 ;
5617 char * kwnames[] = {
5618 (char *) "self",(char *) "pt", NULL
5619 };
5620
5621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5623 if (!SWIG_IsOK(res1)) {
5624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5625 }
5626 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5627 {
5628 arg2 = &temp2;
5629 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5630 }
5631 {
5632 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj = 0;
5644 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5645 double arg2 ;
5646 double arg3 ;
5647 void *argp1 = 0 ;
5648 int res1 = 0 ;
5649 double val2 ;
5650 int ecode2 = 0 ;
5651 double val3 ;
5652 int ecode3 = 0 ;
5653 PyObject * obj0 = 0 ;
5654 PyObject * obj1 = 0 ;
5655 PyObject * obj2 = 0 ;
5656 char * kwnames[] = {
5657 (char *) "self",(char *) "x",(char *) "y", NULL
5658 };
5659
5660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5662 if (!SWIG_IsOK(res1)) {
5663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5664 }
5665 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5666 ecode2 = SWIG_AsVal_double(obj1, &val2);
5667 if (!SWIG_IsOK(ecode2)) {
5668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5669 }
5670 arg2 = static_cast< double >(val2);
5671 ecode3 = SWIG_AsVal_double(obj2, &val3);
5672 if (!SWIG_IsOK(ecode3)) {
5673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5674 }
5675 arg3 = static_cast< double >(val3);
5676 {
5677 wxRealPoint_Set(arg1,arg2,arg3);
5678 if (PyErr_Occurred()) SWIG_fail;
5679 }
5680 resultobj = SWIG_Py_Void();
5681 return resultobj;
5682 fail:
5683 return NULL;
5684 }
5685
5686
5687 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5688 PyObject *resultobj = 0;
5689 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5690 PyObject *result = 0 ;
5691 void *argp1 = 0 ;
5692 int res1 = 0 ;
5693 PyObject *swig_obj[1] ;
5694
5695 if (!args) SWIG_fail;
5696 swig_obj[0] = args;
5697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5698 if (!SWIG_IsOK(res1)) {
5699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5700 }
5701 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5702 {
5703 result = (PyObject *)wxRealPoint_Get(arg1);
5704 if (PyErr_Occurred()) SWIG_fail;
5705 }
5706 resultobj = result;
5707 return resultobj;
5708 fail:
5709 return NULL;
5710 }
5711
5712
5713 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5714 PyObject *obj;
5715 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5716 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5717 return SWIG_Py_Void();
5718 }
5719
5720 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5721 return SWIG_Python_InitShadowInstance(args);
5722 }
5723
5724 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5725 PyObject *resultobj = 0;
5726 wxPoint *arg1 = (wxPoint *) 0 ;
5727 int arg2 ;
5728 void *argp1 = 0 ;
5729 int res1 = 0 ;
5730 int val2 ;
5731 int ecode2 = 0 ;
5732 PyObject *swig_obj[2] ;
5733
5734 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5736 if (!SWIG_IsOK(res1)) {
5737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5738 }
5739 arg1 = reinterpret_cast< wxPoint * >(argp1);
5740 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5741 if (!SWIG_IsOK(ecode2)) {
5742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5743 }
5744 arg2 = static_cast< int >(val2);
5745 if (arg1) (arg1)->x = arg2;
5746
5747 resultobj = SWIG_Py_Void();
5748 return resultobj;
5749 fail:
5750 return NULL;
5751 }
5752
5753
5754 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5755 PyObject *resultobj = 0;
5756 wxPoint *arg1 = (wxPoint *) 0 ;
5757 int result;
5758 void *argp1 = 0 ;
5759 int res1 = 0 ;
5760 PyObject *swig_obj[1] ;
5761
5762 if (!args) SWIG_fail;
5763 swig_obj[0] = args;
5764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5765 if (!SWIG_IsOK(res1)) {
5766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5767 }
5768 arg1 = reinterpret_cast< wxPoint * >(argp1);
5769 result = (int) ((arg1)->x);
5770 resultobj = SWIG_From_int(static_cast< int >(result));
5771 return resultobj;
5772 fail:
5773 return NULL;
5774 }
5775
5776
5777 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5778 PyObject *resultobj = 0;
5779 wxPoint *arg1 = (wxPoint *) 0 ;
5780 int arg2 ;
5781 void *argp1 = 0 ;
5782 int res1 = 0 ;
5783 int val2 ;
5784 int ecode2 = 0 ;
5785 PyObject *swig_obj[2] ;
5786
5787 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5789 if (!SWIG_IsOK(res1)) {
5790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5791 }
5792 arg1 = reinterpret_cast< wxPoint * >(argp1);
5793 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5794 if (!SWIG_IsOK(ecode2)) {
5795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5796 }
5797 arg2 = static_cast< int >(val2);
5798 if (arg1) (arg1)->y = arg2;
5799
5800 resultobj = SWIG_Py_Void();
5801 return resultobj;
5802 fail:
5803 return NULL;
5804 }
5805
5806
5807 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5808 PyObject *resultobj = 0;
5809 wxPoint *arg1 = (wxPoint *) 0 ;
5810 int result;
5811 void *argp1 = 0 ;
5812 int res1 = 0 ;
5813 PyObject *swig_obj[1] ;
5814
5815 if (!args) SWIG_fail;
5816 swig_obj[0] = args;
5817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5818 if (!SWIG_IsOK(res1)) {
5819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5820 }
5821 arg1 = reinterpret_cast< wxPoint * >(argp1);
5822 result = (int) ((arg1)->y);
5823 resultobj = SWIG_From_int(static_cast< int >(result));
5824 return resultobj;
5825 fail:
5826 return NULL;
5827 }
5828
5829
5830 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5831 PyObject *resultobj = 0;
5832 int arg1 = (int) 0 ;
5833 int arg2 = (int) 0 ;
5834 wxPoint *result = 0 ;
5835 int val1 ;
5836 int ecode1 = 0 ;
5837 int val2 ;
5838 int ecode2 = 0 ;
5839 PyObject * obj0 = 0 ;
5840 PyObject * obj1 = 0 ;
5841 char * kwnames[] = {
5842 (char *) "x",(char *) "y", NULL
5843 };
5844
5845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5846 if (obj0) {
5847 ecode1 = SWIG_AsVal_int(obj0, &val1);
5848 if (!SWIG_IsOK(ecode1)) {
5849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5850 }
5851 arg1 = static_cast< int >(val1);
5852 }
5853 if (obj1) {
5854 ecode2 = SWIG_AsVal_int(obj1, &val2);
5855 if (!SWIG_IsOK(ecode2)) {
5856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5857 }
5858 arg2 = static_cast< int >(val2);
5859 }
5860 {
5861 result = (wxPoint *)new wxPoint(arg1,arg2);
5862 if (PyErr_Occurred()) SWIG_fail;
5863 }
5864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5865 return resultobj;
5866 fail:
5867 return NULL;
5868 }
5869
5870
5871 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5872 PyObject *resultobj = 0;
5873 wxPoint *arg1 = (wxPoint *) 0 ;
5874 void *argp1 = 0 ;
5875 int res1 = 0 ;
5876 PyObject *swig_obj[1] ;
5877
5878 if (!args) SWIG_fail;
5879 swig_obj[0] = args;
5880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5881 if (!SWIG_IsOK(res1)) {
5882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5883 }
5884 arg1 = reinterpret_cast< wxPoint * >(argp1);
5885 {
5886 delete arg1;
5887
5888 if (PyErr_Occurred()) SWIG_fail;
5889 }
5890 resultobj = SWIG_Py_Void();
5891 return resultobj;
5892 fail:
5893 return NULL;
5894 }
5895
5896
5897 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5898 PyObject *resultobj = 0;
5899 wxPoint *arg1 = (wxPoint *) 0 ;
5900 PyObject *arg2 = (PyObject *) 0 ;
5901 bool result;
5902 void *argp1 = 0 ;
5903 int res1 = 0 ;
5904 PyObject * obj0 = 0 ;
5905 PyObject * obj1 = 0 ;
5906 char * kwnames[] = {
5907 (char *) "self",(char *) "other", NULL
5908 };
5909
5910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5912 if (!SWIG_IsOK(res1)) {
5913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5914 }
5915 arg1 = reinterpret_cast< wxPoint * >(argp1);
5916 arg2 = obj1;
5917 {
5918 result = (bool)wxPoint___eq__(arg1,arg2);
5919 if (PyErr_Occurred()) SWIG_fail;
5920 }
5921 {
5922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5923 }
5924 return resultobj;
5925 fail:
5926 return NULL;
5927 }
5928
5929
5930 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5931 PyObject *resultobj = 0;
5932 wxPoint *arg1 = (wxPoint *) 0 ;
5933 PyObject *arg2 = (PyObject *) 0 ;
5934 bool result;
5935 void *argp1 = 0 ;
5936 int res1 = 0 ;
5937 PyObject * obj0 = 0 ;
5938 PyObject * obj1 = 0 ;
5939 char * kwnames[] = {
5940 (char *) "self",(char *) "other", NULL
5941 };
5942
5943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5945 if (!SWIG_IsOK(res1)) {
5946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5947 }
5948 arg1 = reinterpret_cast< wxPoint * >(argp1);
5949 arg2 = obj1;
5950 {
5951 result = (bool)wxPoint___ne__(arg1,arg2);
5952 if (PyErr_Occurred()) SWIG_fail;
5953 }
5954 {
5955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5956 }
5957 return resultobj;
5958 fail:
5959 return NULL;
5960 }
5961
5962
5963 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5964 PyObject *resultobj = 0;
5965 wxPoint *arg1 = (wxPoint *) 0 ;
5966 wxPoint *arg2 = 0 ;
5967 wxPoint result;
5968 void *argp1 = 0 ;
5969 int res1 = 0 ;
5970 wxPoint temp2 ;
5971 PyObject * obj0 = 0 ;
5972 PyObject * obj1 = 0 ;
5973 char * kwnames[] = {
5974 (char *) "self",(char *) "pt", NULL
5975 };
5976
5977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5979 if (!SWIG_IsOK(res1)) {
5980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5981 }
5982 arg1 = reinterpret_cast< wxPoint * >(argp1);
5983 {
5984 arg2 = &temp2;
5985 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5986 }
5987 {
5988 result = (arg1)->operator +((wxPoint const &)*arg2);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5999 PyObject *resultobj = 0;
6000 wxPoint *arg1 = (wxPoint *) 0 ;
6001 wxPoint *arg2 = 0 ;
6002 wxPoint result;
6003 void *argp1 = 0 ;
6004 int res1 = 0 ;
6005 wxPoint temp2 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 char * kwnames[] = {
6009 (char *) "self",(char *) "pt", NULL
6010 };
6011
6012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6014 if (!SWIG_IsOK(res1)) {
6015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6016 }
6017 arg1 = reinterpret_cast< wxPoint * >(argp1);
6018 {
6019 arg2 = &temp2;
6020 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6021 }
6022 {
6023 result = (arg1)->operator -((wxPoint const &)*arg2);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6027 return resultobj;
6028 fail:
6029 return NULL;
6030 }
6031
6032
6033 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6034 PyObject *resultobj = 0;
6035 wxPoint *arg1 = (wxPoint *) 0 ;
6036 wxPoint *arg2 = 0 ;
6037 wxPoint *result = 0 ;
6038 void *argp1 = 0 ;
6039 int res1 = 0 ;
6040 wxPoint temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char * kwnames[] = {
6044 (char *) "self",(char *) "pt", NULL
6045 };
6046
6047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6049 if (!SWIG_IsOK(res1)) {
6050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6051 }
6052 arg1 = reinterpret_cast< wxPoint * >(argp1);
6053 {
6054 arg2 = &temp2;
6055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6056 }
6057 {
6058 {
6059 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6060 result = (wxPoint *) &_result_ref;
6061 }
6062 if (PyErr_Occurred()) SWIG_fail;
6063 }
6064 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6065 return resultobj;
6066 fail:
6067 return NULL;
6068 }
6069
6070
6071 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6072 PyObject *resultobj = 0;
6073 wxPoint *arg1 = (wxPoint *) 0 ;
6074 wxPoint *arg2 = 0 ;
6075 wxPoint *result = 0 ;
6076 void *argp1 = 0 ;
6077 int res1 = 0 ;
6078 wxPoint temp2 ;
6079 PyObject * obj0 = 0 ;
6080 PyObject * obj1 = 0 ;
6081 char * kwnames[] = {
6082 (char *) "self",(char *) "pt", NULL
6083 };
6084
6085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6087 if (!SWIG_IsOK(res1)) {
6088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6089 }
6090 arg1 = reinterpret_cast< wxPoint * >(argp1);
6091 {
6092 arg2 = &temp2;
6093 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6094 }
6095 {
6096 {
6097 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6098 result = (wxPoint *) &_result_ref;
6099 }
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj = 0;
6111 wxPoint *arg1 = (wxPoint *) 0 ;
6112 long arg2 ;
6113 long arg3 ;
6114 void *argp1 = 0 ;
6115 int res1 = 0 ;
6116 long val2 ;
6117 int ecode2 = 0 ;
6118 long val3 ;
6119 int ecode3 = 0 ;
6120 PyObject * obj0 = 0 ;
6121 PyObject * obj1 = 0 ;
6122 PyObject * obj2 = 0 ;
6123 char * kwnames[] = {
6124 (char *) "self",(char *) "x",(char *) "y", NULL
6125 };
6126
6127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6129 if (!SWIG_IsOK(res1)) {
6130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6131 }
6132 arg1 = reinterpret_cast< wxPoint * >(argp1);
6133 ecode2 = SWIG_AsVal_long(obj1, &val2);
6134 if (!SWIG_IsOK(ecode2)) {
6135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6136 }
6137 arg2 = static_cast< long >(val2);
6138 ecode3 = SWIG_AsVal_long(obj2, &val3);
6139 if (!SWIG_IsOK(ecode3)) {
6140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6141 }
6142 arg3 = static_cast< long >(val3);
6143 {
6144 wxPoint_Set(arg1,arg2,arg3);
6145 if (PyErr_Occurred()) SWIG_fail;
6146 }
6147 resultobj = SWIG_Py_Void();
6148 return resultobj;
6149 fail:
6150 return NULL;
6151 }
6152
6153
6154 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6155 PyObject *resultobj = 0;
6156 wxPoint *arg1 = (wxPoint *) 0 ;
6157 PyObject *result = 0 ;
6158 void *argp1 = 0 ;
6159 int res1 = 0 ;
6160 PyObject *swig_obj[1] ;
6161
6162 if (!args) SWIG_fail;
6163 swig_obj[0] = args;
6164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6165 if (!SWIG_IsOK(res1)) {
6166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6167 }
6168 arg1 = reinterpret_cast< wxPoint * >(argp1);
6169 {
6170 result = (PyObject *)wxPoint_Get(arg1);
6171 if (PyErr_Occurred()) SWIG_fail;
6172 }
6173 resultobj = result;
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6181 PyObject *obj;
6182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6183 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6184 return SWIG_Py_Void();
6185 }
6186
6187 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6188 return SWIG_Python_InitShadowInstance(args);
6189 }
6190
6191 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6192 PyObject *resultobj = 0;
6193 int arg1 = (int) 0 ;
6194 int arg2 = (int) 0 ;
6195 int arg3 = (int) 0 ;
6196 int arg4 = (int) 0 ;
6197 wxRect *result = 0 ;
6198 int val1 ;
6199 int ecode1 = 0 ;
6200 int val2 ;
6201 int ecode2 = 0 ;
6202 int val3 ;
6203 int ecode3 = 0 ;
6204 int val4 ;
6205 int ecode4 = 0 ;
6206 PyObject * obj0 = 0 ;
6207 PyObject * obj1 = 0 ;
6208 PyObject * obj2 = 0 ;
6209 PyObject * obj3 = 0 ;
6210 char * kwnames[] = {
6211 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6212 };
6213
6214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6215 if (obj0) {
6216 ecode1 = SWIG_AsVal_int(obj0, &val1);
6217 if (!SWIG_IsOK(ecode1)) {
6218 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6219 }
6220 arg1 = static_cast< int >(val1);
6221 }
6222 if (obj1) {
6223 ecode2 = SWIG_AsVal_int(obj1, &val2);
6224 if (!SWIG_IsOK(ecode2)) {
6225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6226 }
6227 arg2 = static_cast< int >(val2);
6228 }
6229 if (obj2) {
6230 ecode3 = SWIG_AsVal_int(obj2, &val3);
6231 if (!SWIG_IsOK(ecode3)) {
6232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6233 }
6234 arg3 = static_cast< int >(val3);
6235 }
6236 if (obj3) {
6237 ecode4 = SWIG_AsVal_int(obj3, &val4);
6238 if (!SWIG_IsOK(ecode4)) {
6239 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6240 }
6241 arg4 = static_cast< int >(val4);
6242 }
6243 {
6244 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6245 if (PyErr_Occurred()) SWIG_fail;
6246 }
6247 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6248 return resultobj;
6249 fail:
6250 return NULL;
6251 }
6252
6253
6254 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6255 PyObject *resultobj = 0;
6256 wxPoint *arg1 = 0 ;
6257 wxPoint *arg2 = 0 ;
6258 wxRect *result = 0 ;
6259 wxPoint temp1 ;
6260 wxPoint temp2 ;
6261 PyObject * obj0 = 0 ;
6262 PyObject * obj1 = 0 ;
6263 char * kwnames[] = {
6264 (char *) "topLeft",(char *) "bottomRight", NULL
6265 };
6266
6267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6268 {
6269 arg1 = &temp1;
6270 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6271 }
6272 {
6273 arg2 = &temp2;
6274 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6275 }
6276 {
6277 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6278 if (PyErr_Occurred()) SWIG_fail;
6279 }
6280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6281 return resultobj;
6282 fail:
6283 return NULL;
6284 }
6285
6286
6287 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6288 PyObject *resultobj = 0;
6289 wxPoint *arg1 = 0 ;
6290 wxSize *arg2 = 0 ;
6291 wxRect *result = 0 ;
6292 wxPoint temp1 ;
6293 wxSize temp2 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char * kwnames[] = {
6297 (char *) "pos",(char *) "size", NULL
6298 };
6299
6300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6301 {
6302 arg1 = &temp1;
6303 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6304 }
6305 {
6306 arg2 = &temp2;
6307 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6308 }
6309 {
6310 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6311 if (PyErr_Occurred()) SWIG_fail;
6312 }
6313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6314 return resultobj;
6315 fail:
6316 return NULL;
6317 }
6318
6319
6320 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6321 PyObject *resultobj = 0;
6322 wxSize *arg1 = 0 ;
6323 wxRect *result = 0 ;
6324 wxSize temp1 ;
6325 PyObject * obj0 = 0 ;
6326 char * kwnames[] = {
6327 (char *) "size", NULL
6328 };
6329
6330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6331 {
6332 arg1 = &temp1;
6333 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6334 }
6335 {
6336 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6337 if (PyErr_Occurred()) SWIG_fail;
6338 }
6339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6340 return resultobj;
6341 fail:
6342 return NULL;
6343 }
6344
6345
6346 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6347 PyObject *resultobj = 0;
6348 wxRect *arg1 = (wxRect *) 0 ;
6349 void *argp1 = 0 ;
6350 int res1 = 0 ;
6351 PyObject *swig_obj[1] ;
6352
6353 if (!args) SWIG_fail;
6354 swig_obj[0] = args;
6355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6356 if (!SWIG_IsOK(res1)) {
6357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6358 }
6359 arg1 = reinterpret_cast< wxRect * >(argp1);
6360 {
6361 delete arg1;
6362
6363 if (PyErr_Occurred()) SWIG_fail;
6364 }
6365 resultobj = SWIG_Py_Void();
6366 return resultobj;
6367 fail:
6368 return NULL;
6369 }
6370
6371
6372 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6373 PyObject *resultobj = 0;
6374 wxRect *arg1 = (wxRect *) 0 ;
6375 int result;
6376 void *argp1 = 0 ;
6377 int res1 = 0 ;
6378 PyObject *swig_obj[1] ;
6379
6380 if (!args) SWIG_fail;
6381 swig_obj[0] = args;
6382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6383 if (!SWIG_IsOK(res1)) {
6384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6385 }
6386 arg1 = reinterpret_cast< wxRect * >(argp1);
6387 {
6388 result = (int)((wxRect const *)arg1)->GetX();
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 resultobj = SWIG_From_int(static_cast< int >(result));
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6399 PyObject *resultobj = 0;
6400 wxRect *arg1 = (wxRect *) 0 ;
6401 int arg2 ;
6402 void *argp1 = 0 ;
6403 int res1 = 0 ;
6404 int val2 ;
6405 int ecode2 = 0 ;
6406 PyObject * obj0 = 0 ;
6407 PyObject * obj1 = 0 ;
6408 char * kwnames[] = {
6409 (char *) "self",(char *) "x", NULL
6410 };
6411
6412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6414 if (!SWIG_IsOK(res1)) {
6415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6416 }
6417 arg1 = reinterpret_cast< wxRect * >(argp1);
6418 ecode2 = SWIG_AsVal_int(obj1, &val2);
6419 if (!SWIG_IsOK(ecode2)) {
6420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6421 }
6422 arg2 = static_cast< int >(val2);
6423 {
6424 (arg1)->SetX(arg2);
6425 if (PyErr_Occurred()) SWIG_fail;
6426 }
6427 resultobj = SWIG_Py_Void();
6428 return resultobj;
6429 fail:
6430 return NULL;
6431 }
6432
6433
6434 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6435 PyObject *resultobj = 0;
6436 wxRect *arg1 = (wxRect *) 0 ;
6437 int result;
6438 void *argp1 = 0 ;
6439 int res1 = 0 ;
6440 PyObject *swig_obj[1] ;
6441
6442 if (!args) SWIG_fail;
6443 swig_obj[0] = args;
6444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6445 if (!SWIG_IsOK(res1)) {
6446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6447 }
6448 arg1 = reinterpret_cast< wxRect * >(argp1);
6449 {
6450 result = (int)(arg1)->GetY();
6451 if (PyErr_Occurred()) SWIG_fail;
6452 }
6453 resultobj = SWIG_From_int(static_cast< int >(result));
6454 return resultobj;
6455 fail:
6456 return NULL;
6457 }
6458
6459
6460 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6461 PyObject *resultobj = 0;
6462 wxRect *arg1 = (wxRect *) 0 ;
6463 int arg2 ;
6464 void *argp1 = 0 ;
6465 int res1 = 0 ;
6466 int val2 ;
6467 int ecode2 = 0 ;
6468 PyObject * obj0 = 0 ;
6469 PyObject * obj1 = 0 ;
6470 char * kwnames[] = {
6471 (char *) "self",(char *) "y", NULL
6472 };
6473
6474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6476 if (!SWIG_IsOK(res1)) {
6477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6478 }
6479 arg1 = reinterpret_cast< wxRect * >(argp1);
6480 ecode2 = SWIG_AsVal_int(obj1, &val2);
6481 if (!SWIG_IsOK(ecode2)) {
6482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6483 }
6484 arg2 = static_cast< int >(val2);
6485 {
6486 (arg1)->SetY(arg2);
6487 if (PyErr_Occurred()) SWIG_fail;
6488 }
6489 resultobj = SWIG_Py_Void();
6490 return resultobj;
6491 fail:
6492 return NULL;
6493 }
6494
6495
6496 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6497 PyObject *resultobj = 0;
6498 wxRect *arg1 = (wxRect *) 0 ;
6499 int result;
6500 void *argp1 = 0 ;
6501 int res1 = 0 ;
6502 PyObject *swig_obj[1] ;
6503
6504 if (!args) SWIG_fail;
6505 swig_obj[0] = args;
6506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6507 if (!SWIG_IsOK(res1)) {
6508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6509 }
6510 arg1 = reinterpret_cast< wxRect * >(argp1);
6511 {
6512 result = (int)((wxRect const *)arg1)->GetWidth();
6513 if (PyErr_Occurred()) SWIG_fail;
6514 }
6515 resultobj = SWIG_From_int(static_cast< int >(result));
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6523 PyObject *resultobj = 0;
6524 wxRect *arg1 = (wxRect *) 0 ;
6525 int arg2 ;
6526 void *argp1 = 0 ;
6527 int res1 = 0 ;
6528 int val2 ;
6529 int ecode2 = 0 ;
6530 PyObject * obj0 = 0 ;
6531 PyObject * obj1 = 0 ;
6532 char * kwnames[] = {
6533 (char *) "self",(char *) "w", NULL
6534 };
6535
6536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6538 if (!SWIG_IsOK(res1)) {
6539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6540 }
6541 arg1 = reinterpret_cast< wxRect * >(argp1);
6542 ecode2 = SWIG_AsVal_int(obj1, &val2);
6543 if (!SWIG_IsOK(ecode2)) {
6544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6545 }
6546 arg2 = static_cast< int >(val2);
6547 {
6548 (arg1)->SetWidth(arg2);
6549 if (PyErr_Occurred()) SWIG_fail;
6550 }
6551 resultobj = SWIG_Py_Void();
6552 return resultobj;
6553 fail:
6554 return NULL;
6555 }
6556
6557
6558 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6559 PyObject *resultobj = 0;
6560 wxRect *arg1 = (wxRect *) 0 ;
6561 int result;
6562 void *argp1 = 0 ;
6563 int res1 = 0 ;
6564 PyObject *swig_obj[1] ;
6565
6566 if (!args) SWIG_fail;
6567 swig_obj[0] = args;
6568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6569 if (!SWIG_IsOK(res1)) {
6570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6571 }
6572 arg1 = reinterpret_cast< wxRect * >(argp1);
6573 {
6574 result = (int)((wxRect const *)arg1)->GetHeight();
6575 if (PyErr_Occurred()) SWIG_fail;
6576 }
6577 resultobj = SWIG_From_int(static_cast< int >(result));
6578 return resultobj;
6579 fail:
6580 return NULL;
6581 }
6582
6583
6584 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6585 PyObject *resultobj = 0;
6586 wxRect *arg1 = (wxRect *) 0 ;
6587 int arg2 ;
6588 void *argp1 = 0 ;
6589 int res1 = 0 ;
6590 int val2 ;
6591 int ecode2 = 0 ;
6592 PyObject * obj0 = 0 ;
6593 PyObject * obj1 = 0 ;
6594 char * kwnames[] = {
6595 (char *) "self",(char *) "h", NULL
6596 };
6597
6598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6600 if (!SWIG_IsOK(res1)) {
6601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6602 }
6603 arg1 = reinterpret_cast< wxRect * >(argp1);
6604 ecode2 = SWIG_AsVal_int(obj1, &val2);
6605 if (!SWIG_IsOK(ecode2)) {
6606 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6607 }
6608 arg2 = static_cast< int >(val2);
6609 {
6610 (arg1)->SetHeight(arg2);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 resultobj = SWIG_Py_Void();
6614 return resultobj;
6615 fail:
6616 return NULL;
6617 }
6618
6619
6620 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6621 PyObject *resultobj = 0;
6622 wxRect *arg1 = (wxRect *) 0 ;
6623 wxPoint result;
6624 void *argp1 = 0 ;
6625 int res1 = 0 ;
6626 PyObject *swig_obj[1] ;
6627
6628 if (!args) SWIG_fail;
6629 swig_obj[0] = args;
6630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6631 if (!SWIG_IsOK(res1)) {
6632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6633 }
6634 arg1 = reinterpret_cast< wxRect * >(argp1);
6635 {
6636 result = ((wxRect const *)arg1)->GetPosition();
6637 if (PyErr_Occurred()) SWIG_fail;
6638 }
6639 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6640 return resultobj;
6641 fail:
6642 return NULL;
6643 }
6644
6645
6646 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6647 PyObject *resultobj = 0;
6648 wxRect *arg1 = (wxRect *) 0 ;
6649 wxPoint *arg2 = 0 ;
6650 void *argp1 = 0 ;
6651 int res1 = 0 ;
6652 wxPoint temp2 ;
6653 PyObject * obj0 = 0 ;
6654 PyObject * obj1 = 0 ;
6655 char * kwnames[] = {
6656 (char *) "self",(char *) "p", NULL
6657 };
6658
6659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6661 if (!SWIG_IsOK(res1)) {
6662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6663 }
6664 arg1 = reinterpret_cast< wxRect * >(argp1);
6665 {
6666 arg2 = &temp2;
6667 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6668 }
6669 {
6670 (arg1)->SetPosition((wxPoint const &)*arg2);
6671 if (PyErr_Occurred()) SWIG_fail;
6672 }
6673 resultobj = SWIG_Py_Void();
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 wxRect *arg1 = (wxRect *) 0 ;
6683 wxSize result;
6684 void *argp1 = 0 ;
6685 int res1 = 0 ;
6686 PyObject *swig_obj[1] ;
6687
6688 if (!args) SWIG_fail;
6689 swig_obj[0] = args;
6690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6691 if (!SWIG_IsOK(res1)) {
6692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6693 }
6694 arg1 = reinterpret_cast< wxRect * >(argp1);
6695 {
6696 result = ((wxRect const *)arg1)->GetSize();
6697 if (PyErr_Occurred()) SWIG_fail;
6698 }
6699 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6700 return resultobj;
6701 fail:
6702 return NULL;
6703 }
6704
6705
6706 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6707 PyObject *resultobj = 0;
6708 wxRect *arg1 = (wxRect *) 0 ;
6709 wxSize *arg2 = 0 ;
6710 void *argp1 = 0 ;
6711 int res1 = 0 ;
6712 wxSize temp2 ;
6713 PyObject * obj0 = 0 ;
6714 PyObject * obj1 = 0 ;
6715 char * kwnames[] = {
6716 (char *) "self",(char *) "s", NULL
6717 };
6718
6719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6721 if (!SWIG_IsOK(res1)) {
6722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6723 }
6724 arg1 = reinterpret_cast< wxRect * >(argp1);
6725 {
6726 arg2 = &temp2;
6727 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6728 }
6729 {
6730 (arg1)->SetSize((wxSize const &)*arg2);
6731 if (PyErr_Occurred()) SWIG_fail;
6732 }
6733 resultobj = SWIG_Py_Void();
6734 return resultobj;
6735 fail:
6736 return NULL;
6737 }
6738
6739
6740 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6741 PyObject *resultobj = 0;
6742 wxRect *arg1 = (wxRect *) 0 ;
6743 bool result;
6744 void *argp1 = 0 ;
6745 int res1 = 0 ;
6746 PyObject *swig_obj[1] ;
6747
6748 if (!args) SWIG_fail;
6749 swig_obj[0] = args;
6750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6751 if (!SWIG_IsOK(res1)) {
6752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6753 }
6754 arg1 = reinterpret_cast< wxRect * >(argp1);
6755 {
6756 result = (bool)((wxRect const *)arg1)->IsEmpty();
6757 if (PyErr_Occurred()) SWIG_fail;
6758 }
6759 {
6760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6761 }
6762 return resultobj;
6763 fail:
6764 return NULL;
6765 }
6766
6767
6768 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6769 PyObject *resultobj = 0;
6770 wxRect *arg1 = (wxRect *) 0 ;
6771 wxPoint result;
6772 void *argp1 = 0 ;
6773 int res1 = 0 ;
6774 PyObject *swig_obj[1] ;
6775
6776 if (!args) SWIG_fail;
6777 swig_obj[0] = args;
6778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6779 if (!SWIG_IsOK(res1)) {
6780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6781 }
6782 arg1 = reinterpret_cast< wxRect * >(argp1);
6783 {
6784 result = ((wxRect const *)arg1)->GetTopLeft();
6785 if (PyErr_Occurred()) SWIG_fail;
6786 }
6787 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6788 return resultobj;
6789 fail:
6790 return NULL;
6791 }
6792
6793
6794 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6795 PyObject *resultobj = 0;
6796 wxRect *arg1 = (wxRect *) 0 ;
6797 wxPoint *arg2 = 0 ;
6798 void *argp1 = 0 ;
6799 int res1 = 0 ;
6800 wxPoint temp2 ;
6801 PyObject * obj0 = 0 ;
6802 PyObject * obj1 = 0 ;
6803 char * kwnames[] = {
6804 (char *) "self",(char *) "p", NULL
6805 };
6806
6807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6809 if (!SWIG_IsOK(res1)) {
6810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6811 }
6812 arg1 = reinterpret_cast< wxRect * >(argp1);
6813 {
6814 arg2 = &temp2;
6815 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6816 }
6817 {
6818 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6819 if (PyErr_Occurred()) SWIG_fail;
6820 }
6821 resultobj = SWIG_Py_Void();
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6829 PyObject *resultobj = 0;
6830 wxRect *arg1 = (wxRect *) 0 ;
6831 wxPoint result;
6832 void *argp1 = 0 ;
6833 int res1 = 0 ;
6834 PyObject *swig_obj[1] ;
6835
6836 if (!args) SWIG_fail;
6837 swig_obj[0] = args;
6838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6839 if (!SWIG_IsOK(res1)) {
6840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6841 }
6842 arg1 = reinterpret_cast< wxRect * >(argp1);
6843 {
6844 result = ((wxRect const *)arg1)->GetBottomRight();
6845 if (PyErr_Occurred()) SWIG_fail;
6846 }
6847 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6848 return resultobj;
6849 fail:
6850 return NULL;
6851 }
6852
6853
6854 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6855 PyObject *resultobj = 0;
6856 wxRect *arg1 = (wxRect *) 0 ;
6857 wxPoint *arg2 = 0 ;
6858 void *argp1 = 0 ;
6859 int res1 = 0 ;
6860 wxPoint temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char * kwnames[] = {
6864 (char *) "self",(char *) "p", NULL
6865 };
6866
6867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6869 if (!SWIG_IsOK(res1)) {
6870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6871 }
6872 arg1 = reinterpret_cast< wxRect * >(argp1);
6873 {
6874 arg2 = &temp2;
6875 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6876 }
6877 {
6878 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 resultobj = SWIG_Py_Void();
6882 return resultobj;
6883 fail:
6884 return NULL;
6885 }
6886
6887
6888 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6889 PyObject *resultobj = 0;
6890 wxRect *arg1 = (wxRect *) 0 ;
6891 wxPoint result;
6892 void *argp1 = 0 ;
6893 int res1 = 0 ;
6894 PyObject *swig_obj[1] ;
6895
6896 if (!args) SWIG_fail;
6897 swig_obj[0] = args;
6898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6899 if (!SWIG_IsOK(res1)) {
6900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6901 }
6902 arg1 = reinterpret_cast< wxRect * >(argp1);
6903 {
6904 result = ((wxRect const *)arg1)->GetTopRight();
6905 if (PyErr_Occurred()) SWIG_fail;
6906 }
6907 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6908 return resultobj;
6909 fail:
6910 return NULL;
6911 }
6912
6913
6914 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6915 PyObject *resultobj = 0;
6916 wxRect *arg1 = (wxRect *) 0 ;
6917 wxPoint *arg2 = 0 ;
6918 void *argp1 = 0 ;
6919 int res1 = 0 ;
6920 wxPoint temp2 ;
6921 PyObject * obj0 = 0 ;
6922 PyObject * obj1 = 0 ;
6923 char * kwnames[] = {
6924 (char *) "self",(char *) "p", NULL
6925 };
6926
6927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6929 if (!SWIG_IsOK(res1)) {
6930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6931 }
6932 arg1 = reinterpret_cast< wxRect * >(argp1);
6933 {
6934 arg2 = &temp2;
6935 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6936 }
6937 {
6938 (arg1)->SetTopRight((wxPoint const &)*arg2);
6939 if (PyErr_Occurred()) SWIG_fail;
6940 }
6941 resultobj = SWIG_Py_Void();
6942 return resultobj;
6943 fail:
6944 return NULL;
6945 }
6946
6947
6948 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6949 PyObject *resultobj = 0;
6950 wxRect *arg1 = (wxRect *) 0 ;
6951 wxPoint result;
6952 void *argp1 = 0 ;
6953 int res1 = 0 ;
6954 PyObject *swig_obj[1] ;
6955
6956 if (!args) SWIG_fail;
6957 swig_obj[0] = args;
6958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6959 if (!SWIG_IsOK(res1)) {
6960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6961 }
6962 arg1 = reinterpret_cast< wxRect * >(argp1);
6963 {
6964 result = ((wxRect const *)arg1)->GetBottomLeft();
6965 if (PyErr_Occurred()) SWIG_fail;
6966 }
6967 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6968 return resultobj;
6969 fail:
6970 return NULL;
6971 }
6972
6973
6974 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6975 PyObject *resultobj = 0;
6976 wxRect *arg1 = (wxRect *) 0 ;
6977 wxPoint *arg2 = 0 ;
6978 void *argp1 = 0 ;
6979 int res1 = 0 ;
6980 wxPoint temp2 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char * kwnames[] = {
6984 (char *) "self",(char *) "p", NULL
6985 };
6986
6987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6989 if (!SWIG_IsOK(res1)) {
6990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6991 }
6992 arg1 = reinterpret_cast< wxRect * >(argp1);
6993 {
6994 arg2 = &temp2;
6995 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6996 }
6997 {
6998 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_Py_Void();
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 PyObject *resultobj = 0;
7010 wxRect *arg1 = (wxRect *) 0 ;
7011 int result;
7012 void *argp1 = 0 ;
7013 int res1 = 0 ;
7014 PyObject *swig_obj[1] ;
7015
7016 if (!args) SWIG_fail;
7017 swig_obj[0] = args;
7018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7019 if (!SWIG_IsOK(res1)) {
7020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7021 }
7022 arg1 = reinterpret_cast< wxRect * >(argp1);
7023 {
7024 result = (int)((wxRect const *)arg1)->GetLeft();
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_From_int(static_cast< int >(result));
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7035 PyObject *resultobj = 0;
7036 wxRect *arg1 = (wxRect *) 0 ;
7037 int result;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 PyObject *swig_obj[1] ;
7041
7042 if (!args) SWIG_fail;
7043 swig_obj[0] = args;
7044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7045 if (!SWIG_IsOK(res1)) {
7046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7047 }
7048 arg1 = reinterpret_cast< wxRect * >(argp1);
7049 {
7050 result = (int)((wxRect const *)arg1)->GetTop();
7051 if (PyErr_Occurred()) SWIG_fail;
7052 }
7053 resultobj = SWIG_From_int(static_cast< int >(result));
7054 return resultobj;
7055 fail:
7056 return NULL;
7057 }
7058
7059
7060 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7061 PyObject *resultobj = 0;
7062 wxRect *arg1 = (wxRect *) 0 ;
7063 int result;
7064 void *argp1 = 0 ;
7065 int res1 = 0 ;
7066 PyObject *swig_obj[1] ;
7067
7068 if (!args) SWIG_fail;
7069 swig_obj[0] = args;
7070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7071 if (!SWIG_IsOK(res1)) {
7072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7073 }
7074 arg1 = reinterpret_cast< wxRect * >(argp1);
7075 {
7076 result = (int)((wxRect const *)arg1)->GetBottom();
7077 if (PyErr_Occurred()) SWIG_fail;
7078 }
7079 resultobj = SWIG_From_int(static_cast< int >(result));
7080 return resultobj;
7081 fail:
7082 return NULL;
7083 }
7084
7085
7086 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7087 PyObject *resultobj = 0;
7088 wxRect *arg1 = (wxRect *) 0 ;
7089 int result;
7090 void *argp1 = 0 ;
7091 int res1 = 0 ;
7092 PyObject *swig_obj[1] ;
7093
7094 if (!args) SWIG_fail;
7095 swig_obj[0] = args;
7096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7097 if (!SWIG_IsOK(res1)) {
7098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7099 }
7100 arg1 = reinterpret_cast< wxRect * >(argp1);
7101 {
7102 result = (int)((wxRect const *)arg1)->GetRight();
7103 if (PyErr_Occurred()) SWIG_fail;
7104 }
7105 resultobj = SWIG_From_int(static_cast< int >(result));
7106 return resultobj;
7107 fail:
7108 return NULL;
7109 }
7110
7111
7112 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7113 PyObject *resultobj = 0;
7114 wxRect *arg1 = (wxRect *) 0 ;
7115 int arg2 ;
7116 void *argp1 = 0 ;
7117 int res1 = 0 ;
7118 int val2 ;
7119 int ecode2 = 0 ;
7120 PyObject * obj0 = 0 ;
7121 PyObject * obj1 = 0 ;
7122 char * kwnames[] = {
7123 (char *) "self",(char *) "left", NULL
7124 };
7125
7126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7128 if (!SWIG_IsOK(res1)) {
7129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7130 }
7131 arg1 = reinterpret_cast< wxRect * >(argp1);
7132 ecode2 = SWIG_AsVal_int(obj1, &val2);
7133 if (!SWIG_IsOK(ecode2)) {
7134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7135 }
7136 arg2 = static_cast< int >(val2);
7137 {
7138 (arg1)->SetLeft(arg2);
7139 if (PyErr_Occurred()) SWIG_fail;
7140 }
7141 resultobj = SWIG_Py_Void();
7142 return resultobj;
7143 fail:
7144 return NULL;
7145 }
7146
7147
7148 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7149 PyObject *resultobj = 0;
7150 wxRect *arg1 = (wxRect *) 0 ;
7151 int arg2 ;
7152 void *argp1 = 0 ;
7153 int res1 = 0 ;
7154 int val2 ;
7155 int ecode2 = 0 ;
7156 PyObject * obj0 = 0 ;
7157 PyObject * obj1 = 0 ;
7158 char * kwnames[] = {
7159 (char *) "self",(char *) "right", NULL
7160 };
7161
7162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7164 if (!SWIG_IsOK(res1)) {
7165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7166 }
7167 arg1 = reinterpret_cast< wxRect * >(argp1);
7168 ecode2 = SWIG_AsVal_int(obj1, &val2);
7169 if (!SWIG_IsOK(ecode2)) {
7170 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7171 }
7172 arg2 = static_cast< int >(val2);
7173 {
7174 (arg1)->SetRight(arg2);
7175 if (PyErr_Occurred()) SWIG_fail;
7176 }
7177 resultobj = SWIG_Py_Void();
7178 return resultobj;
7179 fail:
7180 return NULL;
7181 }
7182
7183
7184 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7185 PyObject *resultobj = 0;
7186 wxRect *arg1 = (wxRect *) 0 ;
7187 int arg2 ;
7188 void *argp1 = 0 ;
7189 int res1 = 0 ;
7190 int val2 ;
7191 int ecode2 = 0 ;
7192 PyObject * obj0 = 0 ;
7193 PyObject * obj1 = 0 ;
7194 char * kwnames[] = {
7195 (char *) "self",(char *) "top", NULL
7196 };
7197
7198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7200 if (!SWIG_IsOK(res1)) {
7201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7202 }
7203 arg1 = reinterpret_cast< wxRect * >(argp1);
7204 ecode2 = SWIG_AsVal_int(obj1, &val2);
7205 if (!SWIG_IsOK(ecode2)) {
7206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7207 }
7208 arg2 = static_cast< int >(val2);
7209 {
7210 (arg1)->SetTop(arg2);
7211 if (PyErr_Occurred()) SWIG_fail;
7212 }
7213 resultobj = SWIG_Py_Void();
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj = 0;
7222 wxRect *arg1 = (wxRect *) 0 ;
7223 int arg2 ;
7224 void *argp1 = 0 ;
7225 int res1 = 0 ;
7226 int val2 ;
7227 int ecode2 = 0 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "self",(char *) "bottom", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7238 }
7239 arg1 = reinterpret_cast< wxRect * >(argp1);
7240 ecode2 = SWIG_AsVal_int(obj1, &val2);
7241 if (!SWIG_IsOK(ecode2)) {
7242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7243 }
7244 arg2 = static_cast< int >(val2);
7245 {
7246 (arg1)->SetBottom(arg2);
7247 if (PyErr_Occurred()) SWIG_fail;
7248 }
7249 resultobj = SWIG_Py_Void();
7250 return resultobj;
7251 fail:
7252 return NULL;
7253 }
7254
7255
7256 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7257 PyObject *resultobj = 0;
7258 wxRect *arg1 = (wxRect *) 0 ;
7259 int arg2 ;
7260 int arg3 ;
7261 wxRect *result = 0 ;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 int val2 ;
7265 int ecode2 = 0 ;
7266 int val3 ;
7267 int ecode3 = 0 ;
7268 PyObject * obj0 = 0 ;
7269 PyObject * obj1 = 0 ;
7270 PyObject * obj2 = 0 ;
7271 char * kwnames[] = {
7272 (char *) "self",(char *) "dx",(char *) "dy", NULL
7273 };
7274
7275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) 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_Inflate" "', 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_Inflate" "', expected argument " "2"" of type '" "int""'");
7284 }
7285 arg2 = static_cast< int >(val2);
7286 ecode3 = SWIG_AsVal_int(obj2, &val3);
7287 if (!SWIG_IsOK(ecode3)) {
7288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7289 }
7290 arg3 = static_cast< int >(val3);
7291 {
7292 {
7293 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7294 result = (wxRect *) &_result_ref;
7295 }
7296 if (PyErr_Occurred()) SWIG_fail;
7297 }
7298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7299 return resultobj;
7300 fail:
7301 return NULL;
7302 }
7303
7304
7305 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7306 PyObject *resultobj = 0;
7307 wxRect *arg1 = (wxRect *) 0 ;
7308 int arg2 ;
7309 int arg3 ;
7310 wxRect *result = 0 ;
7311 void *argp1 = 0 ;
7312 int res1 = 0 ;
7313 int val2 ;
7314 int ecode2 = 0 ;
7315 int val3 ;
7316 int ecode3 = 0 ;
7317 PyObject * obj0 = 0 ;
7318 PyObject * obj1 = 0 ;
7319 PyObject * obj2 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "dx",(char *) "dy", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 ecode2 = SWIG_AsVal_int(obj1, &val2);
7331 if (!SWIG_IsOK(ecode2)) {
7332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7333 }
7334 arg2 = static_cast< int >(val2);
7335 ecode3 = SWIG_AsVal_int(obj2, &val3);
7336 if (!SWIG_IsOK(ecode3)) {
7337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7338 }
7339 arg3 = static_cast< int >(val3);
7340 {
7341 {
7342 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7343 result = (wxRect *) &_result_ref;
7344 }
7345 if (PyErr_Occurred()) SWIG_fail;
7346 }
7347 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7348 return resultobj;
7349 fail:
7350 return NULL;
7351 }
7352
7353
7354 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7355 PyObject *resultobj = 0;
7356 wxRect *arg1 = (wxRect *) 0 ;
7357 int arg2 ;
7358 int arg3 ;
7359 void *argp1 = 0 ;
7360 int res1 = 0 ;
7361 int val2 ;
7362 int ecode2 = 0 ;
7363 int val3 ;
7364 int ecode3 = 0 ;
7365 PyObject * obj0 = 0 ;
7366 PyObject * obj1 = 0 ;
7367 PyObject * obj2 = 0 ;
7368 char * kwnames[] = {
7369 (char *) "self",(char *) "dx",(char *) "dy", NULL
7370 };
7371
7372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7374 if (!SWIG_IsOK(res1)) {
7375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7376 }
7377 arg1 = reinterpret_cast< wxRect * >(argp1);
7378 ecode2 = SWIG_AsVal_int(obj1, &val2);
7379 if (!SWIG_IsOK(ecode2)) {
7380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7381 }
7382 arg2 = static_cast< int >(val2);
7383 ecode3 = SWIG_AsVal_int(obj2, &val3);
7384 if (!SWIG_IsOK(ecode3)) {
7385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7386 }
7387 arg3 = static_cast< int >(val3);
7388 {
7389 (arg1)->Offset(arg2,arg3);
7390 if (PyErr_Occurred()) SWIG_fail;
7391 }
7392 resultobj = SWIG_Py_Void();
7393 return resultobj;
7394 fail:
7395 return NULL;
7396 }
7397
7398
7399 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7400 PyObject *resultobj = 0;
7401 wxRect *arg1 = (wxRect *) 0 ;
7402 wxPoint *arg2 = 0 ;
7403 void *argp1 = 0 ;
7404 int res1 = 0 ;
7405 wxPoint temp2 ;
7406 PyObject * obj0 = 0 ;
7407 PyObject * obj1 = 0 ;
7408 char * kwnames[] = {
7409 (char *) "self",(char *) "pt", NULL
7410 };
7411
7412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7414 if (!SWIG_IsOK(res1)) {
7415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7416 }
7417 arg1 = reinterpret_cast< wxRect * >(argp1);
7418 {
7419 arg2 = &temp2;
7420 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7421 }
7422 {
7423 (arg1)->Offset((wxPoint const &)*arg2);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 resultobj = SWIG_Py_Void();
7427 return resultobj;
7428 fail:
7429 return NULL;
7430 }
7431
7432
7433 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7434 PyObject *resultobj = 0;
7435 wxRect *arg1 = (wxRect *) 0 ;
7436 wxRect *arg2 = 0 ;
7437 wxRect result;
7438 void *argp1 = 0 ;
7439 int res1 = 0 ;
7440 wxRect temp2 ;
7441 PyObject * obj0 = 0 ;
7442 PyObject * obj1 = 0 ;
7443 char * kwnames[] = {
7444 (char *) "self",(char *) "rect", NULL
7445 };
7446
7447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7449 if (!SWIG_IsOK(res1)) {
7450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7451 }
7452 arg1 = reinterpret_cast< wxRect * >(argp1);
7453 {
7454 arg2 = &temp2;
7455 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7456 }
7457 {
7458 result = (arg1)->Intersect((wxRect const &)*arg2);
7459 if (PyErr_Occurred()) SWIG_fail;
7460 }
7461 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7462 return resultobj;
7463 fail:
7464 return NULL;
7465 }
7466
7467
7468 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7469 PyObject *resultobj = 0;
7470 wxRect *arg1 = (wxRect *) 0 ;
7471 wxRect *arg2 = 0 ;
7472 wxRect result;
7473 void *argp1 = 0 ;
7474 int res1 = 0 ;
7475 wxRect temp2 ;
7476 PyObject * obj0 = 0 ;
7477 PyObject * obj1 = 0 ;
7478 char * kwnames[] = {
7479 (char *) "self",(char *) "rect", NULL
7480 };
7481
7482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) 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_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7486 }
7487 arg1 = reinterpret_cast< wxRect * >(argp1);
7488 {
7489 arg2 = &temp2;
7490 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7491 }
7492 {
7493 result = (arg1)->Union((wxRect const &)*arg2);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj = 0;
7505 wxRect *arg1 = (wxRect *) 0 ;
7506 wxRect *arg2 = 0 ;
7507 wxRect result;
7508 void *argp1 = 0 ;
7509 int res1 = 0 ;
7510 wxRect temp2 ;
7511 PyObject * obj0 = 0 ;
7512 PyObject * obj1 = 0 ;
7513 char * kwnames[] = {
7514 (char *) "self",(char *) "rect", NULL
7515 };
7516
7517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7519 if (!SWIG_IsOK(res1)) {
7520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7521 }
7522 arg1 = reinterpret_cast< wxRect * >(argp1);
7523 {
7524 arg2 = &temp2;
7525 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7526 }
7527 {
7528 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7529 if (PyErr_Occurred()) SWIG_fail;
7530 }
7531 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7532 return resultobj;
7533 fail:
7534 return NULL;
7535 }
7536
7537
7538 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7539 PyObject *resultobj = 0;
7540 wxRect *arg1 = (wxRect *) 0 ;
7541 wxRect *arg2 = 0 ;
7542 wxRect *result = 0 ;
7543 void *argp1 = 0 ;
7544 int res1 = 0 ;
7545 wxRect temp2 ;
7546 PyObject * obj0 = 0 ;
7547 PyObject * obj1 = 0 ;
7548 char * kwnames[] = {
7549 (char *) "self",(char *) "rect", NULL
7550 };
7551
7552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7554 if (!SWIG_IsOK(res1)) {
7555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7556 }
7557 arg1 = reinterpret_cast< wxRect * >(argp1);
7558 {
7559 arg2 = &temp2;
7560 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7561 }
7562 {
7563 {
7564 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7565 result = (wxRect *) &_result_ref;
7566 }
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7577 PyObject *resultobj = 0;
7578 wxRect *arg1 = (wxRect *) 0 ;
7579 PyObject *arg2 = (PyObject *) 0 ;
7580 bool result;
7581 void *argp1 = 0 ;
7582 int res1 = 0 ;
7583 PyObject * obj0 = 0 ;
7584 PyObject * obj1 = 0 ;
7585 char * kwnames[] = {
7586 (char *) "self",(char *) "other", NULL
7587 };
7588
7589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7591 if (!SWIG_IsOK(res1)) {
7592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7593 }
7594 arg1 = reinterpret_cast< wxRect * >(argp1);
7595 arg2 = obj1;
7596 {
7597 result = (bool)wxRect___eq__(arg1,arg2);
7598 if (PyErr_Occurred()) SWIG_fail;
7599 }
7600 {
7601 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7602 }
7603 return resultobj;
7604 fail:
7605 return NULL;
7606 }
7607
7608
7609 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7610 PyObject *resultobj = 0;
7611 wxRect *arg1 = (wxRect *) 0 ;
7612 PyObject *arg2 = (PyObject *) 0 ;
7613 bool result;
7614 void *argp1 = 0 ;
7615 int res1 = 0 ;
7616 PyObject * obj0 = 0 ;
7617 PyObject * obj1 = 0 ;
7618 char * kwnames[] = {
7619 (char *) "self",(char *) "other", NULL
7620 };
7621
7622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7624 if (!SWIG_IsOK(res1)) {
7625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7626 }
7627 arg1 = reinterpret_cast< wxRect * >(argp1);
7628 arg2 = obj1;
7629 {
7630 result = (bool)wxRect___ne__(arg1,arg2);
7631 if (PyErr_Occurred()) SWIG_fail;
7632 }
7633 {
7634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7635 }
7636 return resultobj;
7637 fail:
7638 return NULL;
7639 }
7640
7641
7642 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7643 PyObject *resultobj = 0;
7644 wxRect *arg1 = (wxRect *) 0 ;
7645 int arg2 ;
7646 int arg3 ;
7647 bool result;
7648 void *argp1 = 0 ;
7649 int res1 = 0 ;
7650 int val2 ;
7651 int ecode2 = 0 ;
7652 int val3 ;
7653 int ecode3 = 0 ;
7654 PyObject * obj0 = 0 ;
7655 PyObject * obj1 = 0 ;
7656 PyObject * obj2 = 0 ;
7657 char * kwnames[] = {
7658 (char *) "self",(char *) "x",(char *) "y", NULL
7659 };
7660
7661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7663 if (!SWIG_IsOK(res1)) {
7664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7665 }
7666 arg1 = reinterpret_cast< wxRect * >(argp1);
7667 ecode2 = SWIG_AsVal_int(obj1, &val2);
7668 if (!SWIG_IsOK(ecode2)) {
7669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7670 }
7671 arg2 = static_cast< int >(val2);
7672 ecode3 = SWIG_AsVal_int(obj2, &val3);
7673 if (!SWIG_IsOK(ecode3)) {
7674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7675 }
7676 arg3 = static_cast< int >(val3);
7677 {
7678 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7679 if (PyErr_Occurred()) SWIG_fail;
7680 }
7681 {
7682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7683 }
7684 return resultobj;
7685 fail:
7686 return NULL;
7687 }
7688
7689
7690 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7691 PyObject *resultobj = 0;
7692 wxRect *arg1 = (wxRect *) 0 ;
7693 wxPoint *arg2 = 0 ;
7694 bool result;
7695 void *argp1 = 0 ;
7696 int res1 = 0 ;
7697 wxPoint temp2 ;
7698 PyObject * obj0 = 0 ;
7699 PyObject * obj1 = 0 ;
7700 char * kwnames[] = {
7701 (char *) "self",(char *) "pt", NULL
7702 };
7703
7704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7706 if (!SWIG_IsOK(res1)) {
7707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7708 }
7709 arg1 = reinterpret_cast< wxRect * >(argp1);
7710 {
7711 arg2 = &temp2;
7712 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7713 }
7714 {
7715 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7716 if (PyErr_Occurred()) SWIG_fail;
7717 }
7718 {
7719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7720 }
7721 return resultobj;
7722 fail:
7723 return NULL;
7724 }
7725
7726
7727 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7728 PyObject *resultobj = 0;
7729 wxRect *arg1 = (wxRect *) 0 ;
7730 wxRect *arg2 = 0 ;
7731 bool result;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 wxRect temp2 ;
7735 PyObject * obj0 = 0 ;
7736 PyObject * obj1 = 0 ;
7737 char * kwnames[] = {
7738 (char *) "self",(char *) "rect", NULL
7739 };
7740
7741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7743 if (!SWIG_IsOK(res1)) {
7744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7745 }
7746 arg1 = reinterpret_cast< wxRect * >(argp1);
7747 {
7748 arg2 = &temp2;
7749 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7750 }
7751 {
7752 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7753 if (PyErr_Occurred()) SWIG_fail;
7754 }
7755 {
7756 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7757 }
7758 return resultobj;
7759 fail:
7760 return NULL;
7761 }
7762
7763
7764 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7765 PyObject *resultobj = 0;
7766 wxRect *arg1 = (wxRect *) 0 ;
7767 wxRect *arg2 = 0 ;
7768 bool result;
7769 void *argp1 = 0 ;
7770 int res1 = 0 ;
7771 wxRect temp2 ;
7772 PyObject * obj0 = 0 ;
7773 PyObject * obj1 = 0 ;
7774 char * kwnames[] = {
7775 (char *) "self",(char *) "rect", NULL
7776 };
7777
7778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7780 if (!SWIG_IsOK(res1)) {
7781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7782 }
7783 arg1 = reinterpret_cast< wxRect * >(argp1);
7784 {
7785 arg2 = &temp2;
7786 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7787 }
7788 {
7789 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7790 if (PyErr_Occurred()) SWIG_fail;
7791 }
7792 {
7793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7794 }
7795 return resultobj;
7796 fail:
7797 return NULL;
7798 }
7799
7800
7801 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7802 PyObject *resultobj = 0;
7803 wxRect *arg1 = (wxRect *) 0 ;
7804 wxRect *arg2 = 0 ;
7805 int arg3 = (int) wxBOTH ;
7806 wxRect result;
7807 void *argp1 = 0 ;
7808 int res1 = 0 ;
7809 wxRect temp2 ;
7810 int val3 ;
7811 int ecode3 = 0 ;
7812 PyObject * obj0 = 0 ;
7813 PyObject * obj1 = 0 ;
7814 PyObject * obj2 = 0 ;
7815 char * kwnames[] = {
7816 (char *) "self",(char *) "r",(char *) "dir", NULL
7817 };
7818
7819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7823 }
7824 arg1 = reinterpret_cast< wxRect * >(argp1);
7825 {
7826 arg2 = &temp2;
7827 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7828 }
7829 if (obj2) {
7830 ecode3 = SWIG_AsVal_int(obj2, &val3);
7831 if (!SWIG_IsOK(ecode3)) {
7832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7833 }
7834 arg3 = static_cast< int >(val3);
7835 }
7836 {
7837 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7838 if (PyErr_Occurred()) SWIG_fail;
7839 }
7840 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7841 return resultobj;
7842 fail:
7843 return NULL;
7844 }
7845
7846
7847 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7848 PyObject *resultobj = 0;
7849 wxRect *arg1 = (wxRect *) 0 ;
7850 int arg2 ;
7851 void *argp1 = 0 ;
7852 int res1 = 0 ;
7853 int val2 ;
7854 int ecode2 = 0 ;
7855 PyObject *swig_obj[2] ;
7856
7857 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7859 if (!SWIG_IsOK(res1)) {
7860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7861 }
7862 arg1 = reinterpret_cast< wxRect * >(argp1);
7863 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7864 if (!SWIG_IsOK(ecode2)) {
7865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7866 }
7867 arg2 = static_cast< int >(val2);
7868 if (arg1) (arg1)->x = arg2;
7869
7870 resultobj = SWIG_Py_Void();
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxRect *arg1 = (wxRect *) 0 ;
7880 int result;
7881 void *argp1 = 0 ;
7882 int res1 = 0 ;
7883 PyObject *swig_obj[1] ;
7884
7885 if (!args) SWIG_fail;
7886 swig_obj[0] = args;
7887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7890 }
7891 arg1 = reinterpret_cast< wxRect * >(argp1);
7892 result = (int) ((arg1)->x);
7893 resultobj = SWIG_From_int(static_cast< int >(result));
7894 return resultobj;
7895 fail:
7896 return NULL;
7897 }
7898
7899
7900 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7901 PyObject *resultobj = 0;
7902 wxRect *arg1 = (wxRect *) 0 ;
7903 int arg2 ;
7904 void *argp1 = 0 ;
7905 int res1 = 0 ;
7906 int val2 ;
7907 int ecode2 = 0 ;
7908 PyObject *swig_obj[2] ;
7909
7910 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7912 if (!SWIG_IsOK(res1)) {
7913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7914 }
7915 arg1 = reinterpret_cast< wxRect * >(argp1);
7916 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7917 if (!SWIG_IsOK(ecode2)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7919 }
7920 arg2 = static_cast< int >(val2);
7921 if (arg1) (arg1)->y = arg2;
7922
7923 resultobj = SWIG_Py_Void();
7924 return resultobj;
7925 fail:
7926 return NULL;
7927 }
7928
7929
7930 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7931 PyObject *resultobj = 0;
7932 wxRect *arg1 = (wxRect *) 0 ;
7933 int result;
7934 void *argp1 = 0 ;
7935 int res1 = 0 ;
7936 PyObject *swig_obj[1] ;
7937
7938 if (!args) SWIG_fail;
7939 swig_obj[0] = args;
7940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7941 if (!SWIG_IsOK(res1)) {
7942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7943 }
7944 arg1 = reinterpret_cast< wxRect * >(argp1);
7945 result = (int) ((arg1)->y);
7946 resultobj = SWIG_From_int(static_cast< int >(result));
7947 return resultobj;
7948 fail:
7949 return NULL;
7950 }
7951
7952
7953 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7954 PyObject *resultobj = 0;
7955 wxRect *arg1 = (wxRect *) 0 ;
7956 int arg2 ;
7957 void *argp1 = 0 ;
7958 int res1 = 0 ;
7959 int val2 ;
7960 int ecode2 = 0 ;
7961 PyObject *swig_obj[2] ;
7962
7963 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7965 if (!SWIG_IsOK(res1)) {
7966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7967 }
7968 arg1 = reinterpret_cast< wxRect * >(argp1);
7969 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7970 if (!SWIG_IsOK(ecode2)) {
7971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7972 }
7973 arg2 = static_cast< int >(val2);
7974 if (arg1) (arg1)->width = arg2;
7975
7976 resultobj = SWIG_Py_Void();
7977 return resultobj;
7978 fail:
7979 return NULL;
7980 }
7981
7982
7983 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7984 PyObject *resultobj = 0;
7985 wxRect *arg1 = (wxRect *) 0 ;
7986 int result;
7987 void *argp1 = 0 ;
7988 int res1 = 0 ;
7989 PyObject *swig_obj[1] ;
7990
7991 if (!args) SWIG_fail;
7992 swig_obj[0] = args;
7993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7994 if (!SWIG_IsOK(res1)) {
7995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7996 }
7997 arg1 = reinterpret_cast< wxRect * >(argp1);
7998 result = (int) ((arg1)->width);
7999 resultobj = SWIG_From_int(static_cast< int >(result));
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *resultobj = 0;
8008 wxRect *arg1 = (wxRect *) 0 ;
8009 int arg2 ;
8010 void *argp1 = 0 ;
8011 int res1 = 0 ;
8012 int val2 ;
8013 int ecode2 = 0 ;
8014 PyObject *swig_obj[2] ;
8015
8016 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8018 if (!SWIG_IsOK(res1)) {
8019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8020 }
8021 arg1 = reinterpret_cast< wxRect * >(argp1);
8022 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8023 if (!SWIG_IsOK(ecode2)) {
8024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8025 }
8026 arg2 = static_cast< int >(val2);
8027 if (arg1) (arg1)->height = arg2;
8028
8029 resultobj = SWIG_Py_Void();
8030 return resultobj;
8031 fail:
8032 return NULL;
8033 }
8034
8035
8036 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8037 PyObject *resultobj = 0;
8038 wxRect *arg1 = (wxRect *) 0 ;
8039 int result;
8040 void *argp1 = 0 ;
8041 int res1 = 0 ;
8042 PyObject *swig_obj[1] ;
8043
8044 if (!args) SWIG_fail;
8045 swig_obj[0] = args;
8046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8047 if (!SWIG_IsOK(res1)) {
8048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8049 }
8050 arg1 = reinterpret_cast< wxRect * >(argp1);
8051 result = (int) ((arg1)->height);
8052 resultobj = SWIG_From_int(static_cast< int >(result));
8053 return resultobj;
8054 fail:
8055 return NULL;
8056 }
8057
8058
8059 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8060 PyObject *resultobj = 0;
8061 wxRect *arg1 = (wxRect *) 0 ;
8062 int arg2 = (int) 0 ;
8063 int arg3 = (int) 0 ;
8064 int arg4 = (int) 0 ;
8065 int arg5 = (int) 0 ;
8066 void *argp1 = 0 ;
8067 int res1 = 0 ;
8068 int val2 ;
8069 int ecode2 = 0 ;
8070 int val3 ;
8071 int ecode3 = 0 ;
8072 int val4 ;
8073 int ecode4 = 0 ;
8074 int val5 ;
8075 int ecode5 = 0 ;
8076 PyObject * obj0 = 0 ;
8077 PyObject * obj1 = 0 ;
8078 PyObject * obj2 = 0 ;
8079 PyObject * obj3 = 0 ;
8080 PyObject * obj4 = 0 ;
8081 char * kwnames[] = {
8082 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8083 };
8084
8085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8087 if (!SWIG_IsOK(res1)) {
8088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8089 }
8090 arg1 = reinterpret_cast< wxRect * >(argp1);
8091 if (obj1) {
8092 ecode2 = SWIG_AsVal_int(obj1, &val2);
8093 if (!SWIG_IsOK(ecode2)) {
8094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8095 }
8096 arg2 = static_cast< int >(val2);
8097 }
8098 if (obj2) {
8099 ecode3 = SWIG_AsVal_int(obj2, &val3);
8100 if (!SWIG_IsOK(ecode3)) {
8101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8102 }
8103 arg3 = static_cast< int >(val3);
8104 }
8105 if (obj3) {
8106 ecode4 = SWIG_AsVal_int(obj3, &val4);
8107 if (!SWIG_IsOK(ecode4)) {
8108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8109 }
8110 arg4 = static_cast< int >(val4);
8111 }
8112 if (obj4) {
8113 ecode5 = SWIG_AsVal_int(obj4, &val5);
8114 if (!SWIG_IsOK(ecode5)) {
8115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8116 }
8117 arg5 = static_cast< int >(val5);
8118 }
8119 {
8120 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8121 if (PyErr_Occurred()) SWIG_fail;
8122 }
8123 resultobj = SWIG_Py_Void();
8124 return resultobj;
8125 fail:
8126 return NULL;
8127 }
8128
8129
8130 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8131 PyObject *resultobj = 0;
8132 wxRect *arg1 = (wxRect *) 0 ;
8133 PyObject *result = 0 ;
8134 void *argp1 = 0 ;
8135 int res1 = 0 ;
8136 PyObject *swig_obj[1] ;
8137
8138 if (!args) SWIG_fail;
8139 swig_obj[0] = args;
8140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8141 if (!SWIG_IsOK(res1)) {
8142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8143 }
8144 arg1 = reinterpret_cast< wxRect * >(argp1);
8145 {
8146 result = (PyObject *)wxRect_Get(arg1);
8147 if (PyErr_Occurred()) SWIG_fail;
8148 }
8149 resultobj = result;
8150 return resultobj;
8151 fail:
8152 return NULL;
8153 }
8154
8155
8156 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8157 PyObject *obj;
8158 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8159 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8160 return SWIG_Py_Void();
8161 }
8162
8163 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8164 return SWIG_Python_InitShadowInstance(args);
8165 }
8166
8167 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8168 PyObject *resultobj = 0;
8169 wxRect *arg1 = (wxRect *) 0 ;
8170 wxRect *arg2 = (wxRect *) 0 ;
8171 PyObject *result = 0 ;
8172 void *argp1 = 0 ;
8173 int res1 = 0 ;
8174 void *argp2 = 0 ;
8175 int res2 = 0 ;
8176 PyObject * obj0 = 0 ;
8177 PyObject * obj1 = 0 ;
8178 char * kwnames[] = {
8179 (char *) "r1",(char *) "r2", NULL
8180 };
8181
8182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8184 if (!SWIG_IsOK(res1)) {
8185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8186 }
8187 arg1 = reinterpret_cast< wxRect * >(argp1);
8188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8189 if (!SWIG_IsOK(res2)) {
8190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8191 }
8192 arg2 = reinterpret_cast< wxRect * >(argp2);
8193 {
8194 if (!wxPyCheckForApp()) SWIG_fail;
8195 PyThreadState* __tstate = wxPyBeginAllowThreads();
8196 result = (PyObject *)wxIntersectRect(arg1,arg2);
8197 wxPyEndAllowThreads(__tstate);
8198 if (PyErr_Occurred()) SWIG_fail;
8199 }
8200 resultobj = result;
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj = 0;
8209 double arg1 = (double) 0.0 ;
8210 double arg2 = (double) 0.0 ;
8211 wxPoint2D *result = 0 ;
8212 double val1 ;
8213 int ecode1 = 0 ;
8214 double val2 ;
8215 int ecode2 = 0 ;
8216 PyObject * obj0 = 0 ;
8217 PyObject * obj1 = 0 ;
8218 char * kwnames[] = {
8219 (char *) "x",(char *) "y", NULL
8220 };
8221
8222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8223 if (obj0) {
8224 ecode1 = SWIG_AsVal_double(obj0, &val1);
8225 if (!SWIG_IsOK(ecode1)) {
8226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8227 }
8228 arg1 = static_cast< double >(val1);
8229 }
8230 if (obj1) {
8231 ecode2 = SWIG_AsVal_double(obj1, &val2);
8232 if (!SWIG_IsOK(ecode2)) {
8233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8234 }
8235 arg2 = static_cast< double >(val2);
8236 }
8237 {
8238 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8239 if (PyErr_Occurred()) SWIG_fail;
8240 }
8241 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8242 return resultobj;
8243 fail:
8244 return NULL;
8245 }
8246
8247
8248 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8249 PyObject *resultobj = 0;
8250 wxPoint2D *arg1 = 0 ;
8251 wxPoint2D *result = 0 ;
8252 wxPoint2D temp1 ;
8253 PyObject * obj0 = 0 ;
8254 char * kwnames[] = {
8255 (char *) "pt", NULL
8256 };
8257
8258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8259 {
8260 arg1 = &temp1;
8261 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8262 }
8263 {
8264 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8265 if (PyErr_Occurred()) SWIG_fail;
8266 }
8267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8268 return resultobj;
8269 fail:
8270 return NULL;
8271 }
8272
8273
8274 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8275 PyObject *resultobj = 0;
8276 wxPoint *arg1 = 0 ;
8277 wxPoint2D *result = 0 ;
8278 wxPoint temp1 ;
8279 PyObject * obj0 = 0 ;
8280 char * kwnames[] = {
8281 (char *) "pt", NULL
8282 };
8283
8284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8285 {
8286 arg1 = &temp1;
8287 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8288 }
8289 {
8290 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8291 if (PyErr_Occurred()) SWIG_fail;
8292 }
8293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8294 return resultobj;
8295 fail:
8296 return NULL;
8297 }
8298
8299
8300 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8301 PyObject *resultobj = 0;
8302 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8303 void *argp1 = 0 ;
8304 int res1 = 0 ;
8305 PyObject *swig_obj[1] ;
8306
8307 if (!args) SWIG_fail;
8308 swig_obj[0] = args;
8309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8310 if (!SWIG_IsOK(res1)) {
8311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8312 }
8313 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8314 {
8315 delete arg1;
8316
8317 if (PyErr_Occurred()) SWIG_fail;
8318 }
8319 resultobj = SWIG_Py_Void();
8320 return resultobj;
8321 fail:
8322 return NULL;
8323 }
8324
8325
8326 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8327 PyObject *resultobj = 0;
8328 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8329 int *arg2 = (int *) 0 ;
8330 int *arg3 = (int *) 0 ;
8331 void *argp1 = 0 ;
8332 int res1 = 0 ;
8333 int temp2 ;
8334 int res2 = SWIG_TMPOBJ ;
8335 int temp3 ;
8336 int res3 = SWIG_TMPOBJ ;
8337 PyObject *swig_obj[1] ;
8338
8339 arg2 = &temp2;
8340 arg3 = &temp3;
8341 if (!args) SWIG_fail;
8342 swig_obj[0] = args;
8343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8344 if (!SWIG_IsOK(res1)) {
8345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8346 }
8347 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8348 {
8349 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8350 if (PyErr_Occurred()) SWIG_fail;
8351 }
8352 resultobj = SWIG_Py_Void();
8353 if (SWIG_IsTmpObj(res2)) {
8354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8355 } else {
8356 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8358 }
8359 if (SWIG_IsTmpObj(res3)) {
8360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8361 } else {
8362 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8364 }
8365 return resultobj;
8366 fail:
8367 return NULL;
8368 }
8369
8370
8371 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8372 PyObject *resultobj = 0;
8373 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8374 int *arg2 = (int *) 0 ;
8375 int *arg3 = (int *) 0 ;
8376 void *argp1 = 0 ;
8377 int res1 = 0 ;
8378 int temp2 ;
8379 int res2 = SWIG_TMPOBJ ;
8380 int temp3 ;
8381 int res3 = SWIG_TMPOBJ ;
8382 PyObject *swig_obj[1] ;
8383
8384 arg2 = &temp2;
8385 arg3 = &temp3;
8386 if (!args) SWIG_fail;
8387 swig_obj[0] = args;
8388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8389 if (!SWIG_IsOK(res1)) {
8390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8391 }
8392 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8393 {
8394 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8395 if (PyErr_Occurred()) SWIG_fail;
8396 }
8397 resultobj = SWIG_Py_Void();
8398 if (SWIG_IsTmpObj(res2)) {
8399 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8400 } else {
8401 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8402 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8403 }
8404 if (SWIG_IsTmpObj(res3)) {
8405 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8406 } else {
8407 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8408 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8409 }
8410 return resultobj;
8411 fail:
8412 return NULL;
8413 }
8414
8415
8416 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8417 PyObject *resultobj = 0;
8418 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8419 double result;
8420 void *argp1 = 0 ;
8421 int res1 = 0 ;
8422 PyObject *swig_obj[1] ;
8423
8424 if (!args) SWIG_fail;
8425 swig_obj[0] = args;
8426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8427 if (!SWIG_IsOK(res1)) {
8428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8429 }
8430 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8431 {
8432 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8433 if (PyErr_Occurred()) SWIG_fail;
8434 }
8435 resultobj = SWIG_From_double(static_cast< double >(result));
8436 return resultobj;
8437 fail:
8438 return NULL;
8439 }
8440
8441
8442 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8443 PyObject *resultobj = 0;
8444 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8445 double result;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 PyObject *swig_obj[1] ;
8449
8450 if (!args) SWIG_fail;
8451 swig_obj[0] = args;
8452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8453 if (!SWIG_IsOK(res1)) {
8454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8455 }
8456 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8457 {
8458 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8459 if (PyErr_Occurred()) SWIG_fail;
8460 }
8461 resultobj = SWIG_From_double(static_cast< double >(result));
8462 return resultobj;
8463 fail:
8464 return NULL;
8465 }
8466
8467
8468 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8469 PyObject *resultobj = 0;
8470 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8471 double arg2 ;
8472 void *argp1 = 0 ;
8473 int res1 = 0 ;
8474 double val2 ;
8475 int ecode2 = 0 ;
8476 PyObject * obj0 = 0 ;
8477 PyObject * obj1 = 0 ;
8478 char * kwnames[] = {
8479 (char *) "self",(char *) "length", NULL
8480 };
8481
8482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8484 if (!SWIG_IsOK(res1)) {
8485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8486 }
8487 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8488 ecode2 = SWIG_AsVal_double(obj1, &val2);
8489 if (!SWIG_IsOK(ecode2)) {
8490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8491 }
8492 arg2 = static_cast< double >(val2);
8493 {
8494 (arg1)->SetVectorLength(arg2);
8495 if (PyErr_Occurred()) SWIG_fail;
8496 }
8497 resultobj = SWIG_Py_Void();
8498 return resultobj;
8499 fail:
8500 return NULL;
8501 }
8502
8503
8504 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8505 PyObject *resultobj = 0;
8506 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8507 double arg2 ;
8508 void *argp1 = 0 ;
8509 int res1 = 0 ;
8510 double val2 ;
8511 int ecode2 = 0 ;
8512 PyObject * obj0 = 0 ;
8513 PyObject * obj1 = 0 ;
8514 char * kwnames[] = {
8515 (char *) "self",(char *) "degrees", NULL
8516 };
8517
8518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8520 if (!SWIG_IsOK(res1)) {
8521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8522 }
8523 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8524 ecode2 = SWIG_AsVal_double(obj1, &val2);
8525 if (!SWIG_IsOK(ecode2)) {
8526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8527 }
8528 arg2 = static_cast< double >(val2);
8529 {
8530 (arg1)->SetVectorAngle(arg2);
8531 if (PyErr_Occurred()) SWIG_fail;
8532 }
8533 resultobj = SWIG_Py_Void();
8534 return resultobj;
8535 fail:
8536 return NULL;
8537 }
8538
8539
8540 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8541 PyObject *resultobj = 0;
8542 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8543 wxPoint2D *arg2 = 0 ;
8544 double result;
8545 void *argp1 = 0 ;
8546 int res1 = 0 ;
8547 wxPoint2D temp2 ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 char * kwnames[] = {
8551 (char *) "self",(char *) "pt", NULL
8552 };
8553
8554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8556 if (!SWIG_IsOK(res1)) {
8557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8558 }
8559 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8560 {
8561 arg2 = &temp2;
8562 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8563 }
8564 {
8565 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8566 if (PyErr_Occurred()) SWIG_fail;
8567 }
8568 resultobj = SWIG_From_double(static_cast< double >(result));
8569 return resultobj;
8570 fail:
8571 return NULL;
8572 }
8573
8574
8575 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8576 PyObject *resultobj = 0;
8577 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8578 wxPoint2D *arg2 = 0 ;
8579 double result;
8580 void *argp1 = 0 ;
8581 int res1 = 0 ;
8582 wxPoint2D temp2 ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char * kwnames[] = {
8586 (char *) "self",(char *) "pt", NULL
8587 };
8588
8589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8591 if (!SWIG_IsOK(res1)) {
8592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8593 }
8594 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8595 {
8596 arg2 = &temp2;
8597 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8598 }
8599 {
8600 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8601 if (PyErr_Occurred()) SWIG_fail;
8602 }
8603 resultobj = SWIG_From_double(static_cast< double >(result));
8604 return resultobj;
8605 fail:
8606 return NULL;
8607 }
8608
8609
8610 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8611 PyObject *resultobj = 0;
8612 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8613 wxPoint2D *arg2 = 0 ;
8614 double result;
8615 void *argp1 = 0 ;
8616 int res1 = 0 ;
8617 wxPoint2D temp2 ;
8618 PyObject * obj0 = 0 ;
8619 PyObject * obj1 = 0 ;
8620 char * kwnames[] = {
8621 (char *) "self",(char *) "vec", NULL
8622 };
8623
8624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8626 if (!SWIG_IsOK(res1)) {
8627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8628 }
8629 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8630 {
8631 arg2 = &temp2;
8632 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8633 }
8634 {
8635 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8636 if (PyErr_Occurred()) SWIG_fail;
8637 }
8638 resultobj = SWIG_From_double(static_cast< double >(result));
8639 return resultobj;
8640 fail:
8641 return NULL;
8642 }
8643
8644
8645 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8646 PyObject *resultobj = 0;
8647 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8648 wxPoint2D *arg2 = 0 ;
8649 double result;
8650 void *argp1 = 0 ;
8651 int res1 = 0 ;
8652 wxPoint2D temp2 ;
8653 PyObject * obj0 = 0 ;
8654 PyObject * obj1 = 0 ;
8655 char * kwnames[] = {
8656 (char *) "self",(char *) "vec", NULL
8657 };
8658
8659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8661 if (!SWIG_IsOK(res1)) {
8662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8663 }
8664 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8665 {
8666 arg2 = &temp2;
8667 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8668 }
8669 {
8670 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8671 if (PyErr_Occurred()) SWIG_fail;
8672 }
8673 resultobj = SWIG_From_double(static_cast< double >(result));
8674 return resultobj;
8675 fail:
8676 return NULL;
8677 }
8678
8679
8680 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8681 PyObject *resultobj = 0;
8682 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8683 wxPoint2D result;
8684 void *argp1 = 0 ;
8685 int res1 = 0 ;
8686 PyObject *swig_obj[1] ;
8687
8688 if (!args) SWIG_fail;
8689 swig_obj[0] = args;
8690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8691 if (!SWIG_IsOK(res1)) {
8692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8693 }
8694 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8695 {
8696 result = (arg1)->operator -();
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8700 return resultobj;
8701 fail:
8702 return NULL;
8703 }
8704
8705
8706 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8707 PyObject *resultobj = 0;
8708 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8709 wxPoint2D *arg2 = 0 ;
8710 wxPoint2D *result = 0 ;
8711 void *argp1 = 0 ;
8712 int res1 = 0 ;
8713 wxPoint2D temp2 ;
8714 PyObject * obj0 = 0 ;
8715 PyObject * obj1 = 0 ;
8716 char * kwnames[] = {
8717 (char *) "self",(char *) "pt", NULL
8718 };
8719
8720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8722 if (!SWIG_IsOK(res1)) {
8723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8724 }
8725 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8726 {
8727 arg2 = &temp2;
8728 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8729 }
8730 {
8731 {
8732 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8733 result = (wxPoint2D *) &_result_ref;
8734 }
8735 if (PyErr_Occurred()) SWIG_fail;
8736 }
8737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8738 return resultobj;
8739 fail:
8740 return NULL;
8741 }
8742
8743
8744 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj = 0;
8746 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8747 wxPoint2D *arg2 = 0 ;
8748 wxPoint2D *result = 0 ;
8749 void *argp1 = 0 ;
8750 int res1 = 0 ;
8751 wxPoint2D temp2 ;
8752 PyObject * obj0 = 0 ;
8753 PyObject * obj1 = 0 ;
8754 char * kwnames[] = {
8755 (char *) "self",(char *) "pt", NULL
8756 };
8757
8758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8760 if (!SWIG_IsOK(res1)) {
8761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8762 }
8763 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8764 {
8765 arg2 = &temp2;
8766 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8767 }
8768 {
8769 {
8770 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8771 result = (wxPoint2D *) &_result_ref;
8772 }
8773 if (PyErr_Occurred()) SWIG_fail;
8774 }
8775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8776 return resultobj;
8777 fail:
8778 return NULL;
8779 }
8780
8781
8782 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8783 PyObject *resultobj = 0;
8784 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8785 wxPoint2D *arg2 = 0 ;
8786 wxPoint2D *result = 0 ;
8787 void *argp1 = 0 ;
8788 int res1 = 0 ;
8789 wxPoint2D temp2 ;
8790 PyObject * obj0 = 0 ;
8791 PyObject * obj1 = 0 ;
8792 char * kwnames[] = {
8793 (char *) "self",(char *) "pt", NULL
8794 };
8795
8796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8798 if (!SWIG_IsOK(res1)) {
8799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8800 }
8801 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8802 {
8803 arg2 = &temp2;
8804 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8805 }
8806 {
8807 {
8808 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8809 result = (wxPoint2D *) &_result_ref;
8810 }
8811 if (PyErr_Occurred()) SWIG_fail;
8812 }
8813 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8814 return resultobj;
8815 fail:
8816 return NULL;
8817 }
8818
8819
8820 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8821 PyObject *resultobj = 0;
8822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8823 wxPoint2D *arg2 = 0 ;
8824 wxPoint2D *result = 0 ;
8825 void *argp1 = 0 ;
8826 int res1 = 0 ;
8827 wxPoint2D temp2 ;
8828 PyObject * obj0 = 0 ;
8829 PyObject * obj1 = 0 ;
8830 char * kwnames[] = {
8831 (char *) "self",(char *) "pt", NULL
8832 };
8833
8834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8836 if (!SWIG_IsOK(res1)) {
8837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8838 }
8839 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8840 {
8841 arg2 = &temp2;
8842 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8843 }
8844 {
8845 {
8846 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8847 result = (wxPoint2D *) &_result_ref;
8848 }
8849 if (PyErr_Occurred()) SWIG_fail;
8850 }
8851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj = 0;
8860 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8861 PyObject *arg2 = (PyObject *) 0 ;
8862 bool result;
8863 void *argp1 = 0 ;
8864 int res1 = 0 ;
8865 PyObject * obj0 = 0 ;
8866 PyObject * obj1 = 0 ;
8867 char * kwnames[] = {
8868 (char *) "self",(char *) "other", NULL
8869 };
8870
8871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8873 if (!SWIG_IsOK(res1)) {
8874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8875 }
8876 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8877 arg2 = obj1;
8878 {
8879 result = (bool)wxPoint2D___eq__(arg1,arg2);
8880 if (PyErr_Occurred()) SWIG_fail;
8881 }
8882 {
8883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8884 }
8885 return resultobj;
8886 fail:
8887 return NULL;
8888 }
8889
8890
8891 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8892 PyObject *resultobj = 0;
8893 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8894 PyObject *arg2 = (PyObject *) 0 ;
8895 bool result;
8896 void *argp1 = 0 ;
8897 int res1 = 0 ;
8898 PyObject * obj0 = 0 ;
8899 PyObject * obj1 = 0 ;
8900 char * kwnames[] = {
8901 (char *) "self",(char *) "other", NULL
8902 };
8903
8904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8906 if (!SWIG_IsOK(res1)) {
8907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8908 }
8909 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8910 arg2 = obj1;
8911 {
8912 result = (bool)wxPoint2D___ne__(arg1,arg2);
8913 if (PyErr_Occurred()) SWIG_fail;
8914 }
8915 {
8916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8917 }
8918 return resultobj;
8919 fail:
8920 return NULL;
8921 }
8922
8923
8924 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8925 PyObject *resultobj = 0;
8926 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8927 double arg2 ;
8928 void *argp1 = 0 ;
8929 int res1 = 0 ;
8930 double val2 ;
8931 int ecode2 = 0 ;
8932 PyObject *swig_obj[2] ;
8933
8934 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8936 if (!SWIG_IsOK(res1)) {
8937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8938 }
8939 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8940 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8941 if (!SWIG_IsOK(ecode2)) {
8942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8943 }
8944 arg2 = static_cast< double >(val2);
8945 if (arg1) (arg1)->m_x = arg2;
8946
8947 resultobj = SWIG_Py_Void();
8948 return resultobj;
8949 fail:
8950 return NULL;
8951 }
8952
8953
8954 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8955 PyObject *resultobj = 0;
8956 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8957 double result;
8958 void *argp1 = 0 ;
8959 int res1 = 0 ;
8960 PyObject *swig_obj[1] ;
8961
8962 if (!args) SWIG_fail;
8963 swig_obj[0] = args;
8964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8965 if (!SWIG_IsOK(res1)) {
8966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8967 }
8968 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8969 result = (double) ((arg1)->m_x);
8970 resultobj = SWIG_From_double(static_cast< double >(result));
8971 return resultobj;
8972 fail:
8973 return NULL;
8974 }
8975
8976
8977 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8978 PyObject *resultobj = 0;
8979 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8980 double arg2 ;
8981 void *argp1 = 0 ;
8982 int res1 = 0 ;
8983 double val2 ;
8984 int ecode2 = 0 ;
8985 PyObject *swig_obj[2] ;
8986
8987 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8989 if (!SWIG_IsOK(res1)) {
8990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8991 }
8992 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8993 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8994 if (!SWIG_IsOK(ecode2)) {
8995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8996 }
8997 arg2 = static_cast< double >(val2);
8998 if (arg1) (arg1)->m_y = arg2;
8999
9000 resultobj = SWIG_Py_Void();
9001 return resultobj;
9002 fail:
9003 return NULL;
9004 }
9005
9006
9007 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9008 PyObject *resultobj = 0;
9009 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9010 double result;
9011 void *argp1 = 0 ;
9012 int res1 = 0 ;
9013 PyObject *swig_obj[1] ;
9014
9015 if (!args) SWIG_fail;
9016 swig_obj[0] = args;
9017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9018 if (!SWIG_IsOK(res1)) {
9019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9020 }
9021 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9022 result = (double) ((arg1)->m_y);
9023 resultobj = SWIG_From_double(static_cast< double >(result));
9024 return resultobj;
9025 fail:
9026 return NULL;
9027 }
9028
9029
9030 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9031 PyObject *resultobj = 0;
9032 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9033 double arg2 = (double) 0 ;
9034 double arg3 = (double) 0 ;
9035 void *argp1 = 0 ;
9036 int res1 = 0 ;
9037 double val2 ;
9038 int ecode2 = 0 ;
9039 double val3 ;
9040 int ecode3 = 0 ;
9041 PyObject * obj0 = 0 ;
9042 PyObject * obj1 = 0 ;
9043 PyObject * obj2 = 0 ;
9044 char * kwnames[] = {
9045 (char *) "self",(char *) "x",(char *) "y", NULL
9046 };
9047
9048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9050 if (!SWIG_IsOK(res1)) {
9051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9052 }
9053 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9054 if (obj1) {
9055 ecode2 = SWIG_AsVal_double(obj1, &val2);
9056 if (!SWIG_IsOK(ecode2)) {
9057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9058 }
9059 arg2 = static_cast< double >(val2);
9060 }
9061 if (obj2) {
9062 ecode3 = SWIG_AsVal_double(obj2, &val3);
9063 if (!SWIG_IsOK(ecode3)) {
9064 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9065 }
9066 arg3 = static_cast< double >(val3);
9067 }
9068 {
9069 wxPoint2D_Set(arg1,arg2,arg3);
9070 if (PyErr_Occurred()) SWIG_fail;
9071 }
9072 resultobj = SWIG_Py_Void();
9073 return resultobj;
9074 fail:
9075 return NULL;
9076 }
9077
9078
9079 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9080 PyObject *resultobj = 0;
9081 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9082 PyObject *result = 0 ;
9083 void *argp1 = 0 ;
9084 int res1 = 0 ;
9085 PyObject *swig_obj[1] ;
9086
9087 if (!args) SWIG_fail;
9088 swig_obj[0] = args;
9089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9090 if (!SWIG_IsOK(res1)) {
9091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9092 }
9093 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9094 {
9095 result = (PyObject *)wxPoint2D_Get(arg1);
9096 if (PyErr_Occurred()) SWIG_fail;
9097 }
9098 resultobj = result;
9099 return resultobj;
9100 fail:
9101 return NULL;
9102 }
9103
9104
9105 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9106 PyObject *obj;
9107 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9108 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9109 return SWIG_Py_Void();
9110 }
9111
9112 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9113 return SWIG_Python_InitShadowInstance(args);
9114 }
9115
9116 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9117 PyObject *resultobj = 0;
9118 wxDouble arg1 = (wxDouble) 0.0 ;
9119 wxDouble arg2 = (wxDouble) 0.0 ;
9120 wxDouble arg3 = (wxDouble) 0.0 ;
9121 wxDouble arg4 = (wxDouble) 0.0 ;
9122 wxRect2D *result = 0 ;
9123 void *argp1 ;
9124 int res1 = 0 ;
9125 void *argp2 ;
9126 int res2 = 0 ;
9127 void *argp3 ;
9128 int res3 = 0 ;
9129 void *argp4 ;
9130 int res4 = 0 ;
9131 PyObject * obj0 = 0 ;
9132 PyObject * obj1 = 0 ;
9133 PyObject * obj2 = 0 ;
9134 PyObject * obj3 = 0 ;
9135 char * kwnames[] = {
9136 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9137 };
9138
9139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9140 if (obj0) {
9141 {
9142 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9143 if (!SWIG_IsOK(res1)) {
9144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9145 }
9146 if (!argp1) {
9147 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9148 } else {
9149 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9150 arg1 = *temp;
9151 if (SWIG_IsNewObj(res1)) delete temp;
9152 }
9153 }
9154 }
9155 if (obj1) {
9156 {
9157 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9158 if (!SWIG_IsOK(res2)) {
9159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9160 }
9161 if (!argp2) {
9162 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9163 } else {
9164 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9165 arg2 = *temp;
9166 if (SWIG_IsNewObj(res2)) delete temp;
9167 }
9168 }
9169 }
9170 if (obj2) {
9171 {
9172 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9173 if (!SWIG_IsOK(res3)) {
9174 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9175 }
9176 if (!argp3) {
9177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9178 } else {
9179 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9180 arg3 = *temp;
9181 if (SWIG_IsNewObj(res3)) delete temp;
9182 }
9183 }
9184 }
9185 if (obj3) {
9186 {
9187 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9188 if (!SWIG_IsOK(res4)) {
9189 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9190 }
9191 if (!argp4) {
9192 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9193 } else {
9194 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9195 arg4 = *temp;
9196 if (SWIG_IsNewObj(res4)) delete temp;
9197 }
9198 }
9199 }
9200 {
9201 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9202 if (PyErr_Occurred()) SWIG_fail;
9203 }
9204 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9205 return resultobj;
9206 fail:
9207 return NULL;
9208 }
9209
9210
9211 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9212 PyObject *resultobj = 0;
9213 wxRect2D *arg1 = (wxRect2D *) 0 ;
9214 void *argp1 = 0 ;
9215 int res1 = 0 ;
9216 PyObject *swig_obj[1] ;
9217
9218 if (!args) SWIG_fail;
9219 swig_obj[0] = args;
9220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9221 if (!SWIG_IsOK(res1)) {
9222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9223 }
9224 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9225 {
9226 delete arg1;
9227
9228 if (PyErr_Occurred()) SWIG_fail;
9229 }
9230 resultobj = SWIG_Py_Void();
9231 return resultobj;
9232 fail:
9233 return NULL;
9234 }
9235
9236
9237 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9238 PyObject *resultobj = 0;
9239 wxRect2D *arg1 = (wxRect2D *) 0 ;
9240 wxPoint2D result;
9241 void *argp1 = 0 ;
9242 int res1 = 0 ;
9243 PyObject *swig_obj[1] ;
9244
9245 if (!args) SWIG_fail;
9246 swig_obj[0] = args;
9247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9248 if (!SWIG_IsOK(res1)) {
9249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9250 }
9251 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9252 {
9253 result = (arg1)->GetPosition();
9254 if (PyErr_Occurred()) SWIG_fail;
9255 }
9256 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9257 return resultobj;
9258 fail:
9259 return NULL;
9260 }
9261
9262
9263 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9264 PyObject *resultobj = 0;
9265 wxRect2D *arg1 = (wxRect2D *) 0 ;
9266 wxSize result;
9267 void *argp1 = 0 ;
9268 int res1 = 0 ;
9269 PyObject *swig_obj[1] ;
9270
9271 if (!args) SWIG_fail;
9272 swig_obj[0] = args;
9273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9274 if (!SWIG_IsOK(res1)) {
9275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9276 }
9277 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9278 {
9279 result = (arg1)->GetSize();
9280 if (PyErr_Occurred()) SWIG_fail;
9281 }
9282 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9283 return resultobj;
9284 fail:
9285 return NULL;
9286 }
9287
9288
9289 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9290 PyObject *resultobj = 0;
9291 wxRect2D *arg1 = (wxRect2D *) 0 ;
9292 wxDouble result;
9293 void *argp1 = 0 ;
9294 int res1 = 0 ;
9295 PyObject *swig_obj[1] ;
9296
9297 if (!args) SWIG_fail;
9298 swig_obj[0] = args;
9299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9300 if (!SWIG_IsOK(res1)) {
9301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9302 }
9303 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9304 {
9305 result = ((wxRect2D const *)arg1)->GetLeft();
9306 if (PyErr_Occurred()) SWIG_fail;
9307 }
9308 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9309 return resultobj;
9310 fail:
9311 return NULL;
9312 }
9313
9314
9315 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9316 PyObject *resultobj = 0;
9317 wxRect2D *arg1 = (wxRect2D *) 0 ;
9318 wxDouble arg2 ;
9319 void *argp1 = 0 ;
9320 int res1 = 0 ;
9321 void *argp2 ;
9322 int res2 = 0 ;
9323 PyObject * obj0 = 0 ;
9324 PyObject * obj1 = 0 ;
9325 char * kwnames[] = {
9326 (char *) "self",(char *) "n", NULL
9327 };
9328
9329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9331 if (!SWIG_IsOK(res1)) {
9332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9333 }
9334 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9335 {
9336 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9337 if (!SWIG_IsOK(res2)) {
9338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9339 }
9340 if (!argp2) {
9341 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9342 } else {
9343 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9344 arg2 = *temp;
9345 if (SWIG_IsNewObj(res2)) delete temp;
9346 }
9347 }
9348 {
9349 (arg1)->SetLeft(arg2);
9350 if (PyErr_Occurred()) SWIG_fail;
9351 }
9352 resultobj = SWIG_Py_Void();
9353 return resultobj;
9354 fail:
9355 return NULL;
9356 }
9357
9358
9359 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9360 PyObject *resultobj = 0;
9361 wxRect2D *arg1 = (wxRect2D *) 0 ;
9362 wxDouble arg2 ;
9363 void *argp1 = 0 ;
9364 int res1 = 0 ;
9365 void *argp2 ;
9366 int res2 = 0 ;
9367 PyObject * obj0 = 0 ;
9368 PyObject * obj1 = 0 ;
9369 char * kwnames[] = {
9370 (char *) "self",(char *) "n", NULL
9371 };
9372
9373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9375 if (!SWIG_IsOK(res1)) {
9376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9377 }
9378 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9379 {
9380 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9381 if (!SWIG_IsOK(res2)) {
9382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9383 }
9384 if (!argp2) {
9385 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9386 } else {
9387 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9388 arg2 = *temp;
9389 if (SWIG_IsNewObj(res2)) delete temp;
9390 }
9391 }
9392 {
9393 (arg1)->MoveLeftTo(arg2);
9394 if (PyErr_Occurred()) SWIG_fail;
9395 }
9396 resultobj = SWIG_Py_Void();
9397 return resultobj;
9398 fail:
9399 return NULL;
9400 }
9401
9402
9403 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9404 PyObject *resultobj = 0;
9405 wxRect2D *arg1 = (wxRect2D *) 0 ;
9406 wxDouble result;
9407 void *argp1 = 0 ;
9408 int res1 = 0 ;
9409 PyObject *swig_obj[1] ;
9410
9411 if (!args) SWIG_fail;
9412 swig_obj[0] = args;
9413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9414 if (!SWIG_IsOK(res1)) {
9415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9416 }
9417 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9418 {
9419 result = ((wxRect2D const *)arg1)->GetTop();
9420 if (PyErr_Occurred()) SWIG_fail;
9421 }
9422 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9423 return resultobj;
9424 fail:
9425 return NULL;
9426 }
9427
9428
9429 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9430 PyObject *resultobj = 0;
9431 wxRect2D *arg1 = (wxRect2D *) 0 ;
9432 wxDouble arg2 ;
9433 void *argp1 = 0 ;
9434 int res1 = 0 ;
9435 void *argp2 ;
9436 int res2 = 0 ;
9437 PyObject * obj0 = 0 ;
9438 PyObject * obj1 = 0 ;
9439 char * kwnames[] = {
9440 (char *) "self",(char *) "n", NULL
9441 };
9442
9443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9445 if (!SWIG_IsOK(res1)) {
9446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9447 }
9448 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9449 {
9450 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9451 if (!SWIG_IsOK(res2)) {
9452 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9453 }
9454 if (!argp2) {
9455 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9456 } else {
9457 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9458 arg2 = *temp;
9459 if (SWIG_IsNewObj(res2)) delete temp;
9460 }
9461 }
9462 {
9463 (arg1)->SetTop(arg2);
9464 if (PyErr_Occurred()) SWIG_fail;
9465 }
9466 resultobj = SWIG_Py_Void();
9467 return resultobj;
9468 fail:
9469 return NULL;
9470 }
9471
9472
9473 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj = 0;
9475 wxRect2D *arg1 = (wxRect2D *) 0 ;
9476 wxDouble arg2 ;
9477 void *argp1 = 0 ;
9478 int res1 = 0 ;
9479 void *argp2 ;
9480 int res2 = 0 ;
9481 PyObject * obj0 = 0 ;
9482 PyObject * obj1 = 0 ;
9483 char * kwnames[] = {
9484 (char *) "self",(char *) "n", NULL
9485 };
9486
9487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9489 if (!SWIG_IsOK(res1)) {
9490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9491 }
9492 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9493 {
9494 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9495 if (!SWIG_IsOK(res2)) {
9496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9497 }
9498 if (!argp2) {
9499 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9500 } else {
9501 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9502 arg2 = *temp;
9503 if (SWIG_IsNewObj(res2)) delete temp;
9504 }
9505 }
9506 {
9507 (arg1)->MoveTopTo(arg2);
9508 if (PyErr_Occurred()) SWIG_fail;
9509 }
9510 resultobj = SWIG_Py_Void();
9511 return resultobj;
9512 fail:
9513 return NULL;
9514 }
9515
9516
9517 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9518 PyObject *resultobj = 0;
9519 wxRect2D *arg1 = (wxRect2D *) 0 ;
9520 wxDouble result;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 PyObject *swig_obj[1] ;
9524
9525 if (!args) SWIG_fail;
9526 swig_obj[0] = args;
9527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9528 if (!SWIG_IsOK(res1)) {
9529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9530 }
9531 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9532 {
9533 result = ((wxRect2D const *)arg1)->GetBottom();
9534 if (PyErr_Occurred()) SWIG_fail;
9535 }
9536 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9537 return resultobj;
9538 fail:
9539 return NULL;
9540 }
9541
9542
9543 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9544 PyObject *resultobj = 0;
9545 wxRect2D *arg1 = (wxRect2D *) 0 ;
9546 wxDouble arg2 ;
9547 void *argp1 = 0 ;
9548 int res1 = 0 ;
9549 void *argp2 ;
9550 int res2 = 0 ;
9551 PyObject * obj0 = 0 ;
9552 PyObject * obj1 = 0 ;
9553 char * kwnames[] = {
9554 (char *) "self",(char *) "n", NULL
9555 };
9556
9557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9559 if (!SWIG_IsOK(res1)) {
9560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9561 }
9562 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9563 {
9564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9565 if (!SWIG_IsOK(res2)) {
9566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9567 }
9568 if (!argp2) {
9569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9570 } else {
9571 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9572 arg2 = *temp;
9573 if (SWIG_IsNewObj(res2)) delete temp;
9574 }
9575 }
9576 {
9577 (arg1)->SetBottom(arg2);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 resultobj = SWIG_Py_Void();
9581 return resultobj;
9582 fail:
9583 return NULL;
9584 }
9585
9586
9587 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9588 PyObject *resultobj = 0;
9589 wxRect2D *arg1 = (wxRect2D *) 0 ;
9590 wxDouble arg2 ;
9591 void *argp1 = 0 ;
9592 int res1 = 0 ;
9593 void *argp2 ;
9594 int res2 = 0 ;
9595 PyObject * obj0 = 0 ;
9596 PyObject * obj1 = 0 ;
9597 char * kwnames[] = {
9598 (char *) "self",(char *) "n", NULL
9599 };
9600
9601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9603 if (!SWIG_IsOK(res1)) {
9604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9605 }
9606 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9607 {
9608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9609 if (!SWIG_IsOK(res2)) {
9610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9611 }
9612 if (!argp2) {
9613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9614 } else {
9615 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9616 arg2 = *temp;
9617 if (SWIG_IsNewObj(res2)) delete temp;
9618 }
9619 }
9620 {
9621 (arg1)->MoveBottomTo(arg2);
9622 if (PyErr_Occurred()) SWIG_fail;
9623 }
9624 resultobj = SWIG_Py_Void();
9625 return resultobj;
9626 fail:
9627 return NULL;
9628 }
9629
9630
9631 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 PyObject *resultobj = 0;
9633 wxRect2D *arg1 = (wxRect2D *) 0 ;
9634 wxDouble result;
9635 void *argp1 = 0 ;
9636 int res1 = 0 ;
9637 PyObject *swig_obj[1] ;
9638
9639 if (!args) SWIG_fail;
9640 swig_obj[0] = args;
9641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9644 }
9645 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9646 {
9647 result = ((wxRect2D const *)arg1)->GetRight();
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj = 0;
9659 wxRect2D *arg1 = (wxRect2D *) 0 ;
9660 wxDouble arg2 ;
9661 void *argp1 = 0 ;
9662 int res1 = 0 ;
9663 void *argp2 ;
9664 int res2 = 0 ;
9665 PyObject * obj0 = 0 ;
9666 PyObject * obj1 = 0 ;
9667 char * kwnames[] = {
9668 (char *) "self",(char *) "n", NULL
9669 };
9670
9671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9673 if (!SWIG_IsOK(res1)) {
9674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9675 }
9676 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9677 {
9678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9679 if (!SWIG_IsOK(res2)) {
9680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9681 }
9682 if (!argp2) {
9683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9684 } else {
9685 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9686 arg2 = *temp;
9687 if (SWIG_IsNewObj(res2)) delete temp;
9688 }
9689 }
9690 {
9691 (arg1)->SetRight(arg2);
9692 if (PyErr_Occurred()) SWIG_fail;
9693 }
9694 resultobj = SWIG_Py_Void();
9695 return resultobj;
9696 fail:
9697 return NULL;
9698 }
9699
9700
9701 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9702 PyObject *resultobj = 0;
9703 wxRect2D *arg1 = (wxRect2D *) 0 ;
9704 wxDouble arg2 ;
9705 void *argp1 = 0 ;
9706 int res1 = 0 ;
9707 void *argp2 ;
9708 int res2 = 0 ;
9709 PyObject * obj0 = 0 ;
9710 PyObject * obj1 = 0 ;
9711 char * kwnames[] = {
9712 (char *) "self",(char *) "n", NULL
9713 };
9714
9715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9717 if (!SWIG_IsOK(res1)) {
9718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9719 }
9720 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9721 {
9722 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9723 if (!SWIG_IsOK(res2)) {
9724 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9725 }
9726 if (!argp2) {
9727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9728 } else {
9729 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9730 arg2 = *temp;
9731 if (SWIG_IsNewObj(res2)) delete temp;
9732 }
9733 }
9734 {
9735 (arg1)->MoveRightTo(arg2);
9736 if (PyErr_Occurred()) SWIG_fail;
9737 }
9738 resultobj = SWIG_Py_Void();
9739 return resultobj;
9740 fail:
9741 return NULL;
9742 }
9743
9744
9745 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9746 PyObject *resultobj = 0;
9747 wxRect2D *arg1 = (wxRect2D *) 0 ;
9748 wxPoint2D result;
9749 void *argp1 = 0 ;
9750 int res1 = 0 ;
9751 PyObject *swig_obj[1] ;
9752
9753 if (!args) SWIG_fail;
9754 swig_obj[0] = args;
9755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9756 if (!SWIG_IsOK(res1)) {
9757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9758 }
9759 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9760 {
9761 result = ((wxRect2D const *)arg1)->GetLeftTop();
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9772 PyObject *resultobj = 0;
9773 wxRect2D *arg1 = (wxRect2D *) 0 ;
9774 wxPoint2D *arg2 = 0 ;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 wxPoint2D temp2 ;
9778 PyObject * obj0 = 0 ;
9779 PyObject * obj1 = 0 ;
9780 char * kwnames[] = {
9781 (char *) "self",(char *) "pt", NULL
9782 };
9783
9784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9786 if (!SWIG_IsOK(res1)) {
9787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9788 }
9789 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9790 {
9791 arg2 = &temp2;
9792 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9793 }
9794 {
9795 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_Py_Void();
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9806 PyObject *resultobj = 0;
9807 wxRect2D *arg1 = (wxRect2D *) 0 ;
9808 wxPoint2D *arg2 = 0 ;
9809 void *argp1 = 0 ;
9810 int res1 = 0 ;
9811 wxPoint2D temp2 ;
9812 PyObject * obj0 = 0 ;
9813 PyObject * obj1 = 0 ;
9814 char * kwnames[] = {
9815 (char *) "self",(char *) "pt", NULL
9816 };
9817
9818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9820 if (!SWIG_IsOK(res1)) {
9821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9822 }
9823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9824 {
9825 arg2 = &temp2;
9826 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9827 }
9828 {
9829 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9830 if (PyErr_Occurred()) SWIG_fail;
9831 }
9832 resultobj = SWIG_Py_Void();
9833 return resultobj;
9834 fail:
9835 return NULL;
9836 }
9837
9838
9839 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9840 PyObject *resultobj = 0;
9841 wxRect2D *arg1 = (wxRect2D *) 0 ;
9842 wxPoint2D result;
9843 void *argp1 = 0 ;
9844 int res1 = 0 ;
9845 PyObject *swig_obj[1] ;
9846
9847 if (!args) SWIG_fail;
9848 swig_obj[0] = args;
9849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9850 if (!SWIG_IsOK(res1)) {
9851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9852 }
9853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9854 {
9855 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9856 if (PyErr_Occurred()) SWIG_fail;
9857 }
9858 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9859 return resultobj;
9860 fail:
9861 return NULL;
9862 }
9863
9864
9865 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9866 PyObject *resultobj = 0;
9867 wxRect2D *arg1 = (wxRect2D *) 0 ;
9868 wxPoint2D *arg2 = 0 ;
9869 void *argp1 = 0 ;
9870 int res1 = 0 ;
9871 wxPoint2D temp2 ;
9872 PyObject * obj0 = 0 ;
9873 PyObject * obj1 = 0 ;
9874 char * kwnames[] = {
9875 (char *) "self",(char *) "pt", NULL
9876 };
9877
9878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9880 if (!SWIG_IsOK(res1)) {
9881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9882 }
9883 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9884 {
9885 arg2 = &temp2;
9886 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9887 }
9888 {
9889 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9890 if (PyErr_Occurred()) SWIG_fail;
9891 }
9892 resultobj = SWIG_Py_Void();
9893 return resultobj;
9894 fail:
9895 return NULL;
9896 }
9897
9898
9899 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9900 PyObject *resultobj = 0;
9901 wxRect2D *arg1 = (wxRect2D *) 0 ;
9902 wxPoint2D *arg2 = 0 ;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 wxPoint2D temp2 ;
9906 PyObject * obj0 = 0 ;
9907 PyObject * obj1 = 0 ;
9908 char * kwnames[] = {
9909 (char *) "self",(char *) "pt", NULL
9910 };
9911
9912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9914 if (!SWIG_IsOK(res1)) {
9915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9916 }
9917 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9918 {
9919 arg2 = &temp2;
9920 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9921 }
9922 {
9923 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9924 if (PyErr_Occurred()) SWIG_fail;
9925 }
9926 resultobj = SWIG_Py_Void();
9927 return resultobj;
9928 fail:
9929 return NULL;
9930 }
9931
9932
9933 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9934 PyObject *resultobj = 0;
9935 wxRect2D *arg1 = (wxRect2D *) 0 ;
9936 wxPoint2D result;
9937 void *argp1 = 0 ;
9938 int res1 = 0 ;
9939 PyObject *swig_obj[1] ;
9940
9941 if (!args) SWIG_fail;
9942 swig_obj[0] = args;
9943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9944 if (!SWIG_IsOK(res1)) {
9945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9946 }
9947 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9948 {
9949 result = ((wxRect2D const *)arg1)->GetRightTop();
9950 if (PyErr_Occurred()) SWIG_fail;
9951 }
9952 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9953 return resultobj;
9954 fail:
9955 return NULL;
9956 }
9957
9958
9959 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9960 PyObject *resultobj = 0;
9961 wxRect2D *arg1 = (wxRect2D *) 0 ;
9962 wxPoint2D *arg2 = 0 ;
9963 void *argp1 = 0 ;
9964 int res1 = 0 ;
9965 wxPoint2D temp2 ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 char * kwnames[] = {
9969 (char *) "self",(char *) "pt", NULL
9970 };
9971
9972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9974 if (!SWIG_IsOK(res1)) {
9975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9976 }
9977 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9978 {
9979 arg2 = &temp2;
9980 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9981 }
9982 {
9983 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9984 if (PyErr_Occurred()) SWIG_fail;
9985 }
9986 resultobj = SWIG_Py_Void();
9987 return resultobj;
9988 fail:
9989 return NULL;
9990 }
9991
9992
9993 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9994 PyObject *resultobj = 0;
9995 wxRect2D *arg1 = (wxRect2D *) 0 ;
9996 wxPoint2D *arg2 = 0 ;
9997 void *argp1 = 0 ;
9998 int res1 = 0 ;
9999 wxPoint2D temp2 ;
10000 PyObject * obj0 = 0 ;
10001 PyObject * obj1 = 0 ;
10002 char * kwnames[] = {
10003 (char *) "self",(char *) "pt", NULL
10004 };
10005
10006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10008 if (!SWIG_IsOK(res1)) {
10009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10010 }
10011 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10012 {
10013 arg2 = &temp2;
10014 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10015 }
10016 {
10017 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10018 if (PyErr_Occurred()) SWIG_fail;
10019 }
10020 resultobj = SWIG_Py_Void();
10021 return resultobj;
10022 fail:
10023 return NULL;
10024 }
10025
10026
10027 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10028 PyObject *resultobj = 0;
10029 wxRect2D *arg1 = (wxRect2D *) 0 ;
10030 wxPoint2D result;
10031 void *argp1 = 0 ;
10032 int res1 = 0 ;
10033 PyObject *swig_obj[1] ;
10034
10035 if (!args) SWIG_fail;
10036 swig_obj[0] = args;
10037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10038 if (!SWIG_IsOK(res1)) {
10039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10040 }
10041 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10042 {
10043 result = ((wxRect2D const *)arg1)->GetRightBottom();
10044 if (PyErr_Occurred()) SWIG_fail;
10045 }
10046 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10047 return resultobj;
10048 fail:
10049 return NULL;
10050 }
10051
10052
10053 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10054 PyObject *resultobj = 0;
10055 wxRect2D *arg1 = (wxRect2D *) 0 ;
10056 wxPoint2D *arg2 = 0 ;
10057 void *argp1 = 0 ;
10058 int res1 = 0 ;
10059 wxPoint2D temp2 ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char * kwnames[] = {
10063 (char *) "self",(char *) "pt", NULL
10064 };
10065
10066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10068 if (!SWIG_IsOK(res1)) {
10069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10070 }
10071 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10072 {
10073 arg2 = &temp2;
10074 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10075 }
10076 {
10077 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10078 if (PyErr_Occurred()) SWIG_fail;
10079 }
10080 resultobj = SWIG_Py_Void();
10081 return resultobj;
10082 fail:
10083 return NULL;
10084 }
10085
10086
10087 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10088 PyObject *resultobj = 0;
10089 wxRect2D *arg1 = (wxRect2D *) 0 ;
10090 wxPoint2D *arg2 = 0 ;
10091 void *argp1 = 0 ;
10092 int res1 = 0 ;
10093 wxPoint2D temp2 ;
10094 PyObject * obj0 = 0 ;
10095 PyObject * obj1 = 0 ;
10096 char * kwnames[] = {
10097 (char *) "self",(char *) "pt", NULL
10098 };
10099
10100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10102 if (!SWIG_IsOK(res1)) {
10103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10104 }
10105 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10106 {
10107 arg2 = &temp2;
10108 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10109 }
10110 {
10111 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10112 if (PyErr_Occurred()) SWIG_fail;
10113 }
10114 resultobj = SWIG_Py_Void();
10115 return resultobj;
10116 fail:
10117 return NULL;
10118 }
10119
10120
10121 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10122 PyObject *resultobj = 0;
10123 wxRect2D *arg1 = (wxRect2D *) 0 ;
10124 wxPoint2D result;
10125 void *argp1 = 0 ;
10126 int res1 = 0 ;
10127 PyObject *swig_obj[1] ;
10128
10129 if (!args) SWIG_fail;
10130 swig_obj[0] = args;
10131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10132 if (!SWIG_IsOK(res1)) {
10133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10134 }
10135 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10136 {
10137 result = ((wxRect2D const *)arg1)->GetCentre();
10138 if (PyErr_Occurred()) SWIG_fail;
10139 }
10140 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10141 return resultobj;
10142 fail:
10143 return NULL;
10144 }
10145
10146
10147 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10148 PyObject *resultobj = 0;
10149 wxRect2D *arg1 = (wxRect2D *) 0 ;
10150 wxPoint2D *arg2 = 0 ;
10151 void *argp1 = 0 ;
10152 int res1 = 0 ;
10153 wxPoint2D temp2 ;
10154 PyObject * obj0 = 0 ;
10155 PyObject * obj1 = 0 ;
10156 char * kwnames[] = {
10157 (char *) "self",(char *) "pt", NULL
10158 };
10159
10160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10162 if (!SWIG_IsOK(res1)) {
10163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10164 }
10165 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10166 {
10167 arg2 = &temp2;
10168 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10169 }
10170 {
10171 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10172 if (PyErr_Occurred()) SWIG_fail;
10173 }
10174 resultobj = SWIG_Py_Void();
10175 return resultobj;
10176 fail:
10177 return NULL;
10178 }
10179
10180
10181 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10182 PyObject *resultobj = 0;
10183 wxRect2D *arg1 = (wxRect2D *) 0 ;
10184 wxPoint2D *arg2 = 0 ;
10185 void *argp1 = 0 ;
10186 int res1 = 0 ;
10187 wxPoint2D temp2 ;
10188 PyObject * obj0 = 0 ;
10189 PyObject * obj1 = 0 ;
10190 char * kwnames[] = {
10191 (char *) "self",(char *) "pt", NULL
10192 };
10193
10194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10196 if (!SWIG_IsOK(res1)) {
10197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10198 }
10199 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10200 {
10201 arg2 = &temp2;
10202 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10203 }
10204 {
10205 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10206 if (PyErr_Occurred()) SWIG_fail;
10207 }
10208 resultobj = SWIG_Py_Void();
10209 return resultobj;
10210 fail:
10211 return NULL;
10212 }
10213
10214
10215 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10216 PyObject *resultobj = 0;
10217 wxRect2D *arg1 = (wxRect2D *) 0 ;
10218 wxPoint2D *arg2 = 0 ;
10219 wxOutCode result;
10220 void *argp1 = 0 ;
10221 int res1 = 0 ;
10222 wxPoint2D temp2 ;
10223 PyObject * obj0 = 0 ;
10224 PyObject * obj1 = 0 ;
10225 char * kwnames[] = {
10226 (char *) "self",(char *) "pt", NULL
10227 };
10228
10229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10231 if (!SWIG_IsOK(res1)) {
10232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10233 }
10234 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10235 {
10236 arg2 = &temp2;
10237 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10238 }
10239 {
10240 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10241 if (PyErr_Occurred()) SWIG_fail;
10242 }
10243 resultobj = SWIG_From_int(static_cast< int >(result));
10244 return resultobj;
10245 fail:
10246 return NULL;
10247 }
10248
10249
10250 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10251 PyObject *resultobj = 0;
10252 wxRect2D *arg1 = (wxRect2D *) 0 ;
10253 wxPoint2D *arg2 = 0 ;
10254 bool result;
10255 void *argp1 = 0 ;
10256 int res1 = 0 ;
10257 wxPoint2D temp2 ;
10258 PyObject * obj0 = 0 ;
10259 PyObject * obj1 = 0 ;
10260 char * kwnames[] = {
10261 (char *) "self",(char *) "pt", NULL
10262 };
10263
10264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10266 if (!SWIG_IsOK(res1)) {
10267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10268 }
10269 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10270 {
10271 arg2 = &temp2;
10272 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10273 }
10274 {
10275 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10276 if (PyErr_Occurred()) SWIG_fail;
10277 }
10278 {
10279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10280 }
10281 return resultobj;
10282 fail:
10283 return NULL;
10284 }
10285
10286
10287 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10288 PyObject *resultobj = 0;
10289 wxRect2D *arg1 = (wxRect2D *) 0 ;
10290 wxRect2D *arg2 = 0 ;
10291 bool result;
10292 void *argp1 = 0 ;
10293 int res1 = 0 ;
10294 wxRect2D temp2 ;
10295 PyObject * obj0 = 0 ;
10296 PyObject * obj1 = 0 ;
10297 char * kwnames[] = {
10298 (char *) "self",(char *) "rect", NULL
10299 };
10300
10301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10303 if (!SWIG_IsOK(res1)) {
10304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10305 }
10306 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10307 {
10308 arg2 = &temp2;
10309 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10310 }
10311 {
10312 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10313 if (PyErr_Occurred()) SWIG_fail;
10314 }
10315 {
10316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10317 }
10318 return resultobj;
10319 fail:
10320 return NULL;
10321 }
10322
10323
10324 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10325 PyObject *resultobj = 0;
10326 wxRect2D *arg1 = (wxRect2D *) 0 ;
10327 bool result;
10328 void *argp1 = 0 ;
10329 int res1 = 0 ;
10330 PyObject *swig_obj[1] ;
10331
10332 if (!args) SWIG_fail;
10333 swig_obj[0] = args;
10334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10335 if (!SWIG_IsOK(res1)) {
10336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10337 }
10338 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10339 {
10340 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10341 if (PyErr_Occurred()) SWIG_fail;
10342 }
10343 {
10344 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10345 }
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj = 0;
10354 wxRect2D *arg1 = (wxRect2D *) 0 ;
10355 wxRect2D *arg2 = 0 ;
10356 bool result;
10357 void *argp1 = 0 ;
10358 int res1 = 0 ;
10359 wxRect2D temp2 ;
10360 PyObject * obj0 = 0 ;
10361 PyObject * obj1 = 0 ;
10362 char * kwnames[] = {
10363 (char *) "self",(char *) "rect", NULL
10364 };
10365
10366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10368 if (!SWIG_IsOK(res1)) {
10369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10370 }
10371 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10372 {
10373 arg2 = &temp2;
10374 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10375 }
10376 {
10377 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10382 }
10383 return resultobj;
10384 fail:
10385 return NULL;
10386 }
10387
10388
10389 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10390 PyObject *resultobj = 0;
10391 wxRect2D *arg1 = (wxRect2D *) 0 ;
10392 wxDouble arg2 ;
10393 wxDouble arg3 ;
10394 void *argp1 = 0 ;
10395 int res1 = 0 ;
10396 void *argp2 ;
10397 int res2 = 0 ;
10398 void *argp3 ;
10399 int res3 = 0 ;
10400
10401 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10403 if (!SWIG_IsOK(res1)) {
10404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10405 }
10406 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10407 {
10408 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10409 if (!SWIG_IsOK(res2)) {
10410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10411 }
10412 if (!argp2) {
10413 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10414 } else {
10415 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10416 arg2 = *temp;
10417 if (SWIG_IsNewObj(res2)) delete temp;
10418 }
10419 }
10420 {
10421 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10422 if (!SWIG_IsOK(res3)) {
10423 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10424 }
10425 if (!argp3) {
10426 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10427 } else {
10428 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10429 arg3 = *temp;
10430 if (SWIG_IsNewObj(res3)) delete temp;
10431 }
10432 }
10433 {
10434 (arg1)->Inset(arg2,arg3);
10435 if (PyErr_Occurred()) SWIG_fail;
10436 }
10437 resultobj = SWIG_Py_Void();
10438 return resultobj;
10439 fail:
10440 return NULL;
10441 }
10442
10443
10444 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10445 PyObject *resultobj = 0;
10446 wxRect2D *arg1 = (wxRect2D *) 0 ;
10447 wxDouble arg2 ;
10448 wxDouble arg3 ;
10449 wxDouble arg4 ;
10450 wxDouble arg5 ;
10451 void *argp1 = 0 ;
10452 int res1 = 0 ;
10453 void *argp2 ;
10454 int res2 = 0 ;
10455 void *argp3 ;
10456 int res3 = 0 ;
10457 void *argp4 ;
10458 int res4 = 0 ;
10459 void *argp5 ;
10460 int res5 = 0 ;
10461
10462 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10464 if (!SWIG_IsOK(res1)) {
10465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10466 }
10467 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10468 {
10469 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10470 if (!SWIG_IsOK(res2)) {
10471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10472 }
10473 if (!argp2) {
10474 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10475 } else {
10476 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10477 arg2 = *temp;
10478 if (SWIG_IsNewObj(res2)) delete temp;
10479 }
10480 }
10481 {
10482 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10483 if (!SWIG_IsOK(res3)) {
10484 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10485 }
10486 if (!argp3) {
10487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10488 } else {
10489 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10490 arg3 = *temp;
10491 if (SWIG_IsNewObj(res3)) delete temp;
10492 }
10493 }
10494 {
10495 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10496 if (!SWIG_IsOK(res4)) {
10497 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10498 }
10499 if (!argp4) {
10500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10501 } else {
10502 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10503 arg4 = *temp;
10504 if (SWIG_IsNewObj(res4)) delete temp;
10505 }
10506 }
10507 {
10508 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10509 if (!SWIG_IsOK(res5)) {
10510 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10511 }
10512 if (!argp5) {
10513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10514 } else {
10515 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10516 arg5 = *temp;
10517 if (SWIG_IsNewObj(res5)) delete temp;
10518 }
10519 }
10520 {
10521 (arg1)->Inset(arg2,arg3,arg4,arg5);
10522 if (PyErr_Occurred()) SWIG_fail;
10523 }
10524 resultobj = SWIG_Py_Void();
10525 return resultobj;
10526 fail:
10527 return NULL;
10528 }
10529
10530
10531 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10532 int argc;
10533 PyObject *argv[6];
10534
10535 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10536 --argc;
10537 if (argc == 3) {
10538 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10539 }
10540 if (argc == 5) {
10541 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10542 }
10543
10544 fail:
10545 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10546 return NULL;
10547 }
10548
10549
10550 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10551 PyObject *resultobj = 0;
10552 wxRect2D *arg1 = (wxRect2D *) 0 ;
10553 wxPoint2D *arg2 = 0 ;
10554 void *argp1 = 0 ;
10555 int res1 = 0 ;
10556 wxPoint2D temp2 ;
10557 PyObject * obj0 = 0 ;
10558 PyObject * obj1 = 0 ;
10559 char * kwnames[] = {
10560 (char *) "self",(char *) "pt", NULL
10561 };
10562
10563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10565 if (!SWIG_IsOK(res1)) {
10566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10567 }
10568 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10569 {
10570 arg2 = &temp2;
10571 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10572 }
10573 {
10574 (arg1)->Offset((wxPoint2D const &)*arg2);
10575 if (PyErr_Occurred()) SWIG_fail;
10576 }
10577 resultobj = SWIG_Py_Void();
10578 return resultobj;
10579 fail:
10580 return NULL;
10581 }
10582
10583
10584 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10585 PyObject *resultobj = 0;
10586 wxRect2D *arg1 = (wxRect2D *) 0 ;
10587 wxRect2D *arg2 = 0 ;
10588 void *argp1 = 0 ;
10589 int res1 = 0 ;
10590 wxRect2D temp2 ;
10591 PyObject * obj0 = 0 ;
10592 PyObject * obj1 = 0 ;
10593 char * kwnames[] = {
10594 (char *) "self",(char *) "rect", NULL
10595 };
10596
10597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10599 if (!SWIG_IsOK(res1)) {
10600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10601 }
10602 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10603 {
10604 arg2 = &temp2;
10605 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10606 }
10607 {
10608 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10609 if (PyErr_Occurred()) SWIG_fail;
10610 }
10611 resultobj = SWIG_Py_Void();
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj = 0;
10620 wxRect2D *arg1 = (wxRect2D *) 0 ;
10621 int arg2 ;
10622 int arg3 ;
10623 wxPoint2D result;
10624 void *argp1 = 0 ;
10625 int res1 = 0 ;
10626 int val2 ;
10627 int ecode2 = 0 ;
10628 int val3 ;
10629 int ecode3 = 0 ;
10630 PyObject * obj0 = 0 ;
10631 PyObject * obj1 = 0 ;
10632 PyObject * obj2 = 0 ;
10633 char * kwnames[] = {
10634 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10635 };
10636
10637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10639 if (!SWIG_IsOK(res1)) {
10640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10641 }
10642 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10643 ecode2 = SWIG_AsVal_int(obj1, &val2);
10644 if (!SWIG_IsOK(ecode2)) {
10645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10646 }
10647 arg2 = static_cast< int >(val2);
10648 ecode3 = SWIG_AsVal_int(obj2, &val3);
10649 if (!SWIG_IsOK(ecode3)) {
10650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10651 }
10652 arg3 = static_cast< int >(val3);
10653 {
10654 result = (arg1)->Interpolate(arg2,arg3);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10665 PyObject *resultobj = 0;
10666 wxRect2D *arg1 = (wxRect2D *) 0 ;
10667 wxRect2D *arg2 = 0 ;
10668 void *argp1 = 0 ;
10669 int res1 = 0 ;
10670 wxRect2D temp2 ;
10671 PyObject * obj0 = 0 ;
10672 PyObject * obj1 = 0 ;
10673 char * kwnames[] = {
10674 (char *) "self",(char *) "otherRect", NULL
10675 };
10676
10677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10678 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10679 if (!SWIG_IsOK(res1)) {
10680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10681 }
10682 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10683 {
10684 arg2 = &temp2;
10685 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10686 }
10687 {
10688 (arg1)->Intersect((wxRect2D const &)*arg2);
10689 if (PyErr_Occurred()) SWIG_fail;
10690 }
10691 resultobj = SWIG_Py_Void();
10692 return resultobj;
10693 fail:
10694 return NULL;
10695 }
10696
10697
10698 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10699 PyObject *resultobj = 0;
10700 wxRect2D *arg1 = (wxRect2D *) 0 ;
10701 wxRect2D *arg2 = 0 ;
10702 wxRect2D result;
10703 void *argp1 = 0 ;
10704 int res1 = 0 ;
10705 wxRect2D temp2 ;
10706 PyObject * obj0 = 0 ;
10707 PyObject * obj1 = 0 ;
10708 char * kwnames[] = {
10709 (char *) "self",(char *) "otherRect", NULL
10710 };
10711
10712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10714 if (!SWIG_IsOK(res1)) {
10715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10716 }
10717 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10718 {
10719 arg2 = &temp2;
10720 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10721 }
10722 {
10723 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10724 if (PyErr_Occurred()) SWIG_fail;
10725 }
10726 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10727 return resultobj;
10728 fail:
10729 return NULL;
10730 }
10731
10732
10733 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10734 PyObject *resultobj = 0;
10735 wxRect2D *arg1 = (wxRect2D *) 0 ;
10736 wxRect2D *arg2 = 0 ;
10737 bool result;
10738 void *argp1 = 0 ;
10739 int res1 = 0 ;
10740 wxRect2D temp2 ;
10741 PyObject * obj0 = 0 ;
10742 PyObject * obj1 = 0 ;
10743 char * kwnames[] = {
10744 (char *) "self",(char *) "rect", NULL
10745 };
10746
10747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) 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_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10751 }
10752 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10753 {
10754 arg2 = &temp2;
10755 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10756 }
10757 {
10758 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10759 if (PyErr_Occurred()) SWIG_fail;
10760 }
10761 {
10762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10763 }
10764 return resultobj;
10765 fail:
10766 return NULL;
10767 }
10768
10769
10770 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10771 PyObject *resultobj = 0;
10772 wxRect2D *arg1 = (wxRect2D *) 0 ;
10773 wxRect2D *arg2 = 0 ;
10774 void *argp1 = 0 ;
10775 int res1 = 0 ;
10776 wxRect2D temp2 ;
10777 PyObject * obj0 = 0 ;
10778 PyObject * obj1 = 0 ;
10779 char * kwnames[] = {
10780 (char *) "self",(char *) "otherRect", NULL
10781 };
10782
10783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10785 if (!SWIG_IsOK(res1)) {
10786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10787 }
10788 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10789 {
10790 arg2 = &temp2;
10791 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10792 }
10793 {
10794 (arg1)->Union((wxRect2D const &)*arg2);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 resultobj = SWIG_Py_Void();
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj = 0;
10806 wxRect2D *arg1 = (wxRect2D *) 0 ;
10807 wxRect2D *arg2 = 0 ;
10808 wxRect2D result;
10809 void *argp1 = 0 ;
10810 int res1 = 0 ;
10811 wxRect2D temp2 ;
10812 PyObject * obj0 = 0 ;
10813 PyObject * obj1 = 0 ;
10814 char * kwnames[] = {
10815 (char *) "self",(char *) "otherRect", NULL
10816 };
10817
10818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10820 if (!SWIG_IsOK(res1)) {
10821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10822 }
10823 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10824 {
10825 arg2 = &temp2;
10826 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10827 }
10828 {
10829 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10830 if (PyErr_Occurred()) SWIG_fail;
10831 }
10832 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10833 return resultobj;
10834 fail:
10835 return NULL;
10836 }
10837
10838
10839 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10840 PyObject *resultobj = 0;
10841 wxRect2D *arg1 = (wxRect2D *) 0 ;
10842 wxDouble arg2 ;
10843 void *argp1 = 0 ;
10844 int res1 = 0 ;
10845 void *argp2 ;
10846 int res2 = 0 ;
10847
10848 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10850 if (!SWIG_IsOK(res1)) {
10851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10852 }
10853 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10854 {
10855 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10856 if (!SWIG_IsOK(res2)) {
10857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10858 }
10859 if (!argp2) {
10860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10861 } else {
10862 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10863 arg2 = *temp;
10864 if (SWIG_IsNewObj(res2)) delete temp;
10865 }
10866 }
10867 {
10868 (arg1)->Scale(arg2);
10869 if (PyErr_Occurred()) SWIG_fail;
10870 }
10871 resultobj = SWIG_Py_Void();
10872 return resultobj;
10873 fail:
10874 return NULL;
10875 }
10876
10877
10878 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10879 PyObject *resultobj = 0;
10880 wxRect2D *arg1 = (wxRect2D *) 0 ;
10881 int arg2 ;
10882 int arg3 ;
10883 void *argp1 = 0 ;
10884 int res1 = 0 ;
10885 int val2 ;
10886 int ecode2 = 0 ;
10887 int val3 ;
10888 int ecode3 = 0 ;
10889
10890 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10892 if (!SWIG_IsOK(res1)) {
10893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10894 }
10895 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10896 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10897 if (!SWIG_IsOK(ecode2)) {
10898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10899 }
10900 arg2 = static_cast< int >(val2);
10901 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10902 if (!SWIG_IsOK(ecode3)) {
10903 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10904 }
10905 arg3 = static_cast< int >(val3);
10906 {
10907 (arg1)->Scale(arg2,arg3);
10908 if (PyErr_Occurred()) SWIG_fail;
10909 }
10910 resultobj = SWIG_Py_Void();
10911 return resultobj;
10912 fail:
10913 return NULL;
10914 }
10915
10916
10917 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10918 int argc;
10919 PyObject *argv[4];
10920
10921 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10922 --argc;
10923 if (argc == 2) {
10924 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10925 }
10926 if (argc == 3) {
10927 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10928 }
10929
10930 fail:
10931 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10932 return NULL;
10933 }
10934
10935
10936 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10937 PyObject *resultobj = 0;
10938 wxRect2D *arg1 = (wxRect2D *) 0 ;
10939 PyObject *arg2 = (PyObject *) 0 ;
10940 bool result;
10941 void *argp1 = 0 ;
10942 int res1 = 0 ;
10943 PyObject * obj0 = 0 ;
10944 PyObject * obj1 = 0 ;
10945 char * kwnames[] = {
10946 (char *) "self",(char *) "other", NULL
10947 };
10948
10949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10951 if (!SWIG_IsOK(res1)) {
10952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10953 }
10954 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10955 arg2 = obj1;
10956 {
10957 result = (bool)wxRect2D___eq__(arg1,arg2);
10958 if (PyErr_Occurred()) SWIG_fail;
10959 }
10960 {
10961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10962 }
10963 return resultobj;
10964 fail:
10965 return NULL;
10966 }
10967
10968
10969 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10970 PyObject *resultobj = 0;
10971 wxRect2D *arg1 = (wxRect2D *) 0 ;
10972 PyObject *arg2 = (PyObject *) 0 ;
10973 bool result;
10974 void *argp1 = 0 ;
10975 int res1 = 0 ;
10976 PyObject * obj0 = 0 ;
10977 PyObject * obj1 = 0 ;
10978 char * kwnames[] = {
10979 (char *) "self",(char *) "other", NULL
10980 };
10981
10982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10984 if (!SWIG_IsOK(res1)) {
10985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10986 }
10987 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10988 arg2 = obj1;
10989 {
10990 result = (bool)wxRect2D___ne__(arg1,arg2);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 {
10994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10995 }
10996 return resultobj;
10997 fail:
10998 return NULL;
10999 }
11000
11001
11002 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11003 PyObject *resultobj = 0;
11004 wxRect2D *arg1 = (wxRect2D *) 0 ;
11005 wxDouble arg2 ;
11006 void *argp1 = 0 ;
11007 int res1 = 0 ;
11008 void *argp2 ;
11009 int res2 = 0 ;
11010 PyObject *swig_obj[2] ;
11011
11012 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11014 if (!SWIG_IsOK(res1)) {
11015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11016 }
11017 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11018 {
11019 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11020 if (!SWIG_IsOK(res2)) {
11021 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11022 }
11023 if (!argp2) {
11024 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11025 } else {
11026 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11027 arg2 = *temp;
11028 if (SWIG_IsNewObj(res2)) delete temp;
11029 }
11030 }
11031 if (arg1) (arg1)->m_x = arg2;
11032
11033 resultobj = SWIG_Py_Void();
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11041 PyObject *resultobj = 0;
11042 wxRect2D *arg1 = (wxRect2D *) 0 ;
11043 wxDouble result;
11044 void *argp1 = 0 ;
11045 int res1 = 0 ;
11046 PyObject *swig_obj[1] ;
11047
11048 if (!args) SWIG_fail;
11049 swig_obj[0] = args;
11050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11051 if (!SWIG_IsOK(res1)) {
11052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11053 }
11054 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11055 result = ((arg1)->m_x);
11056 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11057 return resultobj;
11058 fail:
11059 return NULL;
11060 }
11061
11062
11063 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11064 PyObject *resultobj = 0;
11065 wxRect2D *arg1 = (wxRect2D *) 0 ;
11066 wxDouble arg2 ;
11067 void *argp1 = 0 ;
11068 int res1 = 0 ;
11069 void *argp2 ;
11070 int res2 = 0 ;
11071 PyObject *swig_obj[2] ;
11072
11073 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11075 if (!SWIG_IsOK(res1)) {
11076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11077 }
11078 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11079 {
11080 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11081 if (!SWIG_IsOK(res2)) {
11082 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11083 }
11084 if (!argp2) {
11085 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11086 } else {
11087 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11088 arg2 = *temp;
11089 if (SWIG_IsNewObj(res2)) delete temp;
11090 }
11091 }
11092 if (arg1) (arg1)->m_y = arg2;
11093
11094 resultobj = SWIG_Py_Void();
11095 return resultobj;
11096 fail:
11097 return NULL;
11098 }
11099
11100
11101 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11102 PyObject *resultobj = 0;
11103 wxRect2D *arg1 = (wxRect2D *) 0 ;
11104 wxDouble result;
11105 void *argp1 = 0 ;
11106 int res1 = 0 ;
11107 PyObject *swig_obj[1] ;
11108
11109 if (!args) SWIG_fail;
11110 swig_obj[0] = args;
11111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11112 if (!SWIG_IsOK(res1)) {
11113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11114 }
11115 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11116 result = ((arg1)->m_y);
11117 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11118 return resultobj;
11119 fail:
11120 return NULL;
11121 }
11122
11123
11124 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11125 PyObject *resultobj = 0;
11126 wxRect2D *arg1 = (wxRect2D *) 0 ;
11127 wxDouble arg2 ;
11128 void *argp1 = 0 ;
11129 int res1 = 0 ;
11130 void *argp2 ;
11131 int res2 = 0 ;
11132 PyObject *swig_obj[2] ;
11133
11134 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11136 if (!SWIG_IsOK(res1)) {
11137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11138 }
11139 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11140 {
11141 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11142 if (!SWIG_IsOK(res2)) {
11143 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11144 }
11145 if (!argp2) {
11146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11147 } else {
11148 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11149 arg2 = *temp;
11150 if (SWIG_IsNewObj(res2)) delete temp;
11151 }
11152 }
11153 if (arg1) (arg1)->m_width = arg2;
11154
11155 resultobj = SWIG_Py_Void();
11156 return resultobj;
11157 fail:
11158 return NULL;
11159 }
11160
11161
11162 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163 PyObject *resultobj = 0;
11164 wxRect2D *arg1 = (wxRect2D *) 0 ;
11165 wxDouble result;
11166 void *argp1 = 0 ;
11167 int res1 = 0 ;
11168 PyObject *swig_obj[1] ;
11169
11170 if (!args) SWIG_fail;
11171 swig_obj[0] = args;
11172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11173 if (!SWIG_IsOK(res1)) {
11174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11175 }
11176 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11177 result = ((arg1)->m_width);
11178 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11179 return resultobj;
11180 fail:
11181 return NULL;
11182 }
11183
11184
11185 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11186 PyObject *resultobj = 0;
11187 wxRect2D *arg1 = (wxRect2D *) 0 ;
11188 wxDouble arg2 ;
11189 void *argp1 = 0 ;
11190 int res1 = 0 ;
11191 void *argp2 ;
11192 int res2 = 0 ;
11193 PyObject *swig_obj[2] ;
11194
11195 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11197 if (!SWIG_IsOK(res1)) {
11198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11199 }
11200 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11201 {
11202 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11203 if (!SWIG_IsOK(res2)) {
11204 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11205 }
11206 if (!argp2) {
11207 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11208 } else {
11209 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11210 arg2 = *temp;
11211 if (SWIG_IsNewObj(res2)) delete temp;
11212 }
11213 }
11214 if (arg1) (arg1)->m_height = arg2;
11215
11216 resultobj = SWIG_Py_Void();
11217 return resultobj;
11218 fail:
11219 return NULL;
11220 }
11221
11222
11223 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11224 PyObject *resultobj = 0;
11225 wxRect2D *arg1 = (wxRect2D *) 0 ;
11226 wxDouble result;
11227 void *argp1 = 0 ;
11228 int res1 = 0 ;
11229 PyObject *swig_obj[1] ;
11230
11231 if (!args) SWIG_fail;
11232 swig_obj[0] = args;
11233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11234 if (!SWIG_IsOK(res1)) {
11235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11236 }
11237 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11238 result = ((arg1)->m_height);
11239 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11240 return resultobj;
11241 fail:
11242 return NULL;
11243 }
11244
11245
11246 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11247 PyObject *resultobj = 0;
11248 wxRect2D *arg1 = (wxRect2D *) 0 ;
11249 wxDouble arg2 = (wxDouble) 0 ;
11250 wxDouble arg3 = (wxDouble) 0 ;
11251 wxDouble arg4 = (wxDouble) 0 ;
11252 wxDouble arg5 = (wxDouble) 0 ;
11253 void *argp1 = 0 ;
11254 int res1 = 0 ;
11255 void *argp2 ;
11256 int res2 = 0 ;
11257 void *argp3 ;
11258 int res3 = 0 ;
11259 void *argp4 ;
11260 int res4 = 0 ;
11261 void *argp5 ;
11262 int res5 = 0 ;
11263 PyObject * obj0 = 0 ;
11264 PyObject * obj1 = 0 ;
11265 PyObject * obj2 = 0 ;
11266 PyObject * obj3 = 0 ;
11267 PyObject * obj4 = 0 ;
11268 char * kwnames[] = {
11269 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11270 };
11271
11272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11274 if (!SWIG_IsOK(res1)) {
11275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11276 }
11277 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11278 if (obj1) {
11279 {
11280 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11281 if (!SWIG_IsOK(res2)) {
11282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11283 }
11284 if (!argp2) {
11285 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11286 } else {
11287 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11288 arg2 = *temp;
11289 if (SWIG_IsNewObj(res2)) delete temp;
11290 }
11291 }
11292 }
11293 if (obj2) {
11294 {
11295 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11296 if (!SWIG_IsOK(res3)) {
11297 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11298 }
11299 if (!argp3) {
11300 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11301 } else {
11302 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11303 arg3 = *temp;
11304 if (SWIG_IsNewObj(res3)) delete temp;
11305 }
11306 }
11307 }
11308 if (obj3) {
11309 {
11310 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11311 if (!SWIG_IsOK(res4)) {
11312 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11313 }
11314 if (!argp4) {
11315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11316 } else {
11317 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11318 arg4 = *temp;
11319 if (SWIG_IsNewObj(res4)) delete temp;
11320 }
11321 }
11322 }
11323 if (obj4) {
11324 {
11325 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11326 if (!SWIG_IsOK(res5)) {
11327 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11328 }
11329 if (!argp5) {
11330 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11331 } else {
11332 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11333 arg5 = *temp;
11334 if (SWIG_IsNewObj(res5)) delete temp;
11335 }
11336 }
11337 }
11338 {
11339 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11340 if (PyErr_Occurred()) SWIG_fail;
11341 }
11342 resultobj = SWIG_Py_Void();
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11350 PyObject *resultobj = 0;
11351 wxRect2D *arg1 = (wxRect2D *) 0 ;
11352 PyObject *result = 0 ;
11353 void *argp1 = 0 ;
11354 int res1 = 0 ;
11355 PyObject *swig_obj[1] ;
11356
11357 if (!args) SWIG_fail;
11358 swig_obj[0] = args;
11359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11360 if (!SWIG_IsOK(res1)) {
11361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11362 }
11363 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11364 {
11365 result = (PyObject *)wxRect2D_Get(arg1);
11366 if (PyErr_Occurred()) SWIG_fail;
11367 }
11368 resultobj = result;
11369 return resultobj;
11370 fail:
11371 return NULL;
11372 }
11373
11374
11375 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11376 PyObject *obj;
11377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11378 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11379 return SWIG_Py_Void();
11380 }
11381
11382 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11383 return SWIG_Python_InitShadowInstance(args);
11384 }
11385
11386 SWIGINTERN int DefaultPosition_set(PyObject *) {
11387 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11388 return 1;
11389 }
11390
11391
11392 SWIGINTERN PyObject *DefaultPosition_get(void) {
11393 PyObject *pyobj = 0;
11394
11395 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11396 return pyobj;
11397 }
11398
11399
11400 SWIGINTERN int DefaultSize_set(PyObject *) {
11401 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11402 return 1;
11403 }
11404
11405
11406 SWIGINTERN PyObject *DefaultSize_get(void) {
11407 PyObject *pyobj = 0;
11408
11409 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11410 return pyobj;
11411 }
11412
11413
11414 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11415 PyObject *resultobj = 0;
11416 PyObject *arg1 = (PyObject *) 0 ;
11417 wxPyInputStream *result = 0 ;
11418 PyObject * obj0 = 0 ;
11419 char * kwnames[] = {
11420 (char *) "p", NULL
11421 };
11422
11423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11424 arg1 = obj0;
11425 {
11426 PyThreadState* __tstate = wxPyBeginAllowThreads();
11427 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11428 wxPyEndAllowThreads(__tstate);
11429 if (PyErr_Occurred()) SWIG_fail;
11430 }
11431 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11432 return resultobj;
11433 fail:
11434 return NULL;
11435 }
11436
11437
11438 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11439 PyObject *resultobj = 0;
11440 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11441 void *argp1 = 0 ;
11442 int res1 = 0 ;
11443 PyObject *swig_obj[1] ;
11444
11445 if (!args) SWIG_fail;
11446 swig_obj[0] = args;
11447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11448 if (!SWIG_IsOK(res1)) {
11449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11450 }
11451 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11452 {
11453 PyThreadState* __tstate = wxPyBeginAllowThreads();
11454 delete arg1;
11455
11456 wxPyEndAllowThreads(__tstate);
11457 if (PyErr_Occurred()) SWIG_fail;
11458 }
11459 resultobj = SWIG_Py_Void();
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11467 PyObject *resultobj = 0;
11468 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11469 void *argp1 = 0 ;
11470 int res1 = 0 ;
11471 PyObject *swig_obj[1] ;
11472
11473 if (!args) SWIG_fail;
11474 swig_obj[0] = args;
11475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11476 if (!SWIG_IsOK(res1)) {
11477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11478 }
11479 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11480 {
11481 PyThreadState* __tstate = wxPyBeginAllowThreads();
11482 (arg1)->close();
11483 wxPyEndAllowThreads(__tstate);
11484 if (PyErr_Occurred()) SWIG_fail;
11485 }
11486 resultobj = SWIG_Py_Void();
11487 return resultobj;
11488 fail:
11489 return NULL;
11490 }
11491
11492
11493 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11494 PyObject *resultobj = 0;
11495 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11496 void *argp1 = 0 ;
11497 int res1 = 0 ;
11498 PyObject *swig_obj[1] ;
11499
11500 if (!args) SWIG_fail;
11501 swig_obj[0] = args;
11502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11503 if (!SWIG_IsOK(res1)) {
11504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11505 }
11506 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11507 {
11508 PyThreadState* __tstate = wxPyBeginAllowThreads();
11509 (arg1)->flush();
11510 wxPyEndAllowThreads(__tstate);
11511 if (PyErr_Occurred()) SWIG_fail;
11512 }
11513 resultobj = SWIG_Py_Void();
11514 return resultobj;
11515 fail:
11516 return NULL;
11517 }
11518
11519
11520 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11521 PyObject *resultobj = 0;
11522 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11523 bool result;
11524 void *argp1 = 0 ;
11525 int res1 = 0 ;
11526 PyObject *swig_obj[1] ;
11527
11528 if (!args) SWIG_fail;
11529 swig_obj[0] = args;
11530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11531 if (!SWIG_IsOK(res1)) {
11532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11533 }
11534 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11535 {
11536 PyThreadState* __tstate = wxPyBeginAllowThreads();
11537 result = (bool)(arg1)->eof();
11538 wxPyEndAllowThreads(__tstate);
11539 if (PyErr_Occurred()) SWIG_fail;
11540 }
11541 {
11542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11543 }
11544 return resultobj;
11545 fail:
11546 return NULL;
11547 }
11548
11549
11550 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11551 PyObject *resultobj = 0;
11552 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11553 int arg2 = (int) -1 ;
11554 PyObject *result = 0 ;
11555 void *argp1 = 0 ;
11556 int res1 = 0 ;
11557 int val2 ;
11558 int ecode2 = 0 ;
11559 PyObject * obj0 = 0 ;
11560 PyObject * obj1 = 0 ;
11561 char * kwnames[] = {
11562 (char *) "self",(char *) "size", NULL
11563 };
11564
11565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11567 if (!SWIG_IsOK(res1)) {
11568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11569 }
11570 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11571 if (obj1) {
11572 ecode2 = SWIG_AsVal_int(obj1, &val2);
11573 if (!SWIG_IsOK(ecode2)) {
11574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11575 }
11576 arg2 = static_cast< int >(val2);
11577 }
11578 {
11579 PyThreadState* __tstate = wxPyBeginAllowThreads();
11580 result = (PyObject *)(arg1)->read(arg2);
11581 wxPyEndAllowThreads(__tstate);
11582 if (PyErr_Occurred()) SWIG_fail;
11583 }
11584 resultobj = result;
11585 return resultobj;
11586 fail:
11587 return NULL;
11588 }
11589
11590
11591 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11592 PyObject *resultobj = 0;
11593 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11594 int arg2 = (int) -1 ;
11595 PyObject *result = 0 ;
11596 void *argp1 = 0 ;
11597 int res1 = 0 ;
11598 int val2 ;
11599 int ecode2 = 0 ;
11600 PyObject * obj0 = 0 ;
11601 PyObject * obj1 = 0 ;
11602 char * kwnames[] = {
11603 (char *) "self",(char *) "size", NULL
11604 };
11605
11606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11608 if (!SWIG_IsOK(res1)) {
11609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11610 }
11611 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11612 if (obj1) {
11613 ecode2 = SWIG_AsVal_int(obj1, &val2);
11614 if (!SWIG_IsOK(ecode2)) {
11615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11616 }
11617 arg2 = static_cast< int >(val2);
11618 }
11619 {
11620 PyThreadState* __tstate = wxPyBeginAllowThreads();
11621 result = (PyObject *)(arg1)->readline(arg2);
11622 wxPyEndAllowThreads(__tstate);
11623 if (PyErr_Occurred()) SWIG_fail;
11624 }
11625 resultobj = result;
11626 return resultobj;
11627 fail:
11628 return NULL;
11629 }
11630
11631
11632 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11633 PyObject *resultobj = 0;
11634 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11635 int arg2 = (int) -1 ;
11636 PyObject *result = 0 ;
11637 void *argp1 = 0 ;
11638 int res1 = 0 ;
11639 int val2 ;
11640 int ecode2 = 0 ;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 char * kwnames[] = {
11644 (char *) "self",(char *) "sizehint", NULL
11645 };
11646
11647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11649 if (!SWIG_IsOK(res1)) {
11650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11651 }
11652 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11653 if (obj1) {
11654 ecode2 = SWIG_AsVal_int(obj1, &val2);
11655 if (!SWIG_IsOK(ecode2)) {
11656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11657 }
11658 arg2 = static_cast< int >(val2);
11659 }
11660 {
11661 PyThreadState* __tstate = wxPyBeginAllowThreads();
11662 result = (PyObject *)(arg1)->readlines(arg2);
11663 wxPyEndAllowThreads(__tstate);
11664 if (PyErr_Occurred()) SWIG_fail;
11665 }
11666 resultobj = result;
11667 return resultobj;
11668 fail:
11669 return NULL;
11670 }
11671
11672
11673 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11674 PyObject *resultobj = 0;
11675 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11676 int arg2 ;
11677 int arg3 = (int) 0 ;
11678 void *argp1 = 0 ;
11679 int res1 = 0 ;
11680 int val2 ;
11681 int ecode2 = 0 ;
11682 int val3 ;
11683 int ecode3 = 0 ;
11684 PyObject * obj0 = 0 ;
11685 PyObject * obj1 = 0 ;
11686 PyObject * obj2 = 0 ;
11687 char * kwnames[] = {
11688 (char *) "self",(char *) "offset",(char *) "whence", NULL
11689 };
11690
11691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11695 }
11696 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11697 ecode2 = SWIG_AsVal_int(obj1, &val2);
11698 if (!SWIG_IsOK(ecode2)) {
11699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11700 }
11701 arg2 = static_cast< int >(val2);
11702 if (obj2) {
11703 ecode3 = SWIG_AsVal_int(obj2, &val3);
11704 if (!SWIG_IsOK(ecode3)) {
11705 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11706 }
11707 arg3 = static_cast< int >(val3);
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 (arg1)->seek(arg2,arg3);
11712 wxPyEndAllowThreads(__tstate);
11713 if (PyErr_Occurred()) SWIG_fail;
11714 }
11715 resultobj = SWIG_Py_Void();
11716 return resultobj;
11717 fail:
11718 return NULL;
11719 }
11720
11721
11722 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11723 PyObject *resultobj = 0;
11724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11725 int result;
11726 void *argp1 = 0 ;
11727 int res1 = 0 ;
11728 PyObject *swig_obj[1] ;
11729
11730 if (!args) SWIG_fail;
11731 swig_obj[0] = args;
11732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11733 if (!SWIG_IsOK(res1)) {
11734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11735 }
11736 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11737 {
11738 PyThreadState* __tstate = wxPyBeginAllowThreads();
11739 result = (int)(arg1)->tell();
11740 wxPyEndAllowThreads(__tstate);
11741 if (PyErr_Occurred()) SWIG_fail;
11742 }
11743 resultobj = SWIG_From_int(static_cast< int >(result));
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11753 char result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject *swig_obj[1] ;
11757
11758 if (!args) SWIG_fail;
11759 swig_obj[0] = args;
11760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11761 if (!SWIG_IsOK(res1)) {
11762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11763 }
11764 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (char)(arg1)->Peek();
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 resultobj = SWIG_From_char(static_cast< char >(result));
11772 return resultobj;
11773 fail:
11774 return NULL;
11775 }
11776
11777
11778 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11779 PyObject *resultobj = 0;
11780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11781 char result;
11782 void *argp1 = 0 ;
11783 int res1 = 0 ;
11784 PyObject *swig_obj[1] ;
11785
11786 if (!args) SWIG_fail;
11787 swig_obj[0] = args;
11788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11789 if (!SWIG_IsOK(res1)) {
11790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11791 }
11792 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (char)(arg1)->GetC();
11796 wxPyEndAllowThreads(__tstate);
11797 if (PyErr_Occurred()) SWIG_fail;
11798 }
11799 resultobj = SWIG_From_char(static_cast< char >(result));
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11809 size_t result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 PyObject *swig_obj[1] ;
11813
11814 if (!args) SWIG_fail;
11815 swig_obj[0] = args;
11816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11819 }
11820 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (size_t)(arg1)->LastRead();
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11837 bool result;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 PyObject *swig_obj[1] ;
11841
11842 if (!args) SWIG_fail;
11843 swig_obj[0] = args;
11844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11845 if (!SWIG_IsOK(res1)) {
11846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11847 }
11848 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (bool)(arg1)->CanRead();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11857 }
11858 return resultobj;
11859 fail:
11860 return NULL;
11861 }
11862
11863
11864 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11865 PyObject *resultobj = 0;
11866 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11867 bool result;
11868 void *argp1 = 0 ;
11869 int res1 = 0 ;
11870 PyObject *swig_obj[1] ;
11871
11872 if (!args) SWIG_fail;
11873 swig_obj[0] = args;
11874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11877 }
11878 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11879 {
11880 PyThreadState* __tstate = wxPyBeginAllowThreads();
11881 result = (bool)(arg1)->Eof();
11882 wxPyEndAllowThreads(__tstate);
11883 if (PyErr_Occurred()) SWIG_fail;
11884 }
11885 {
11886 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11887 }
11888 return resultobj;
11889 fail:
11890 return NULL;
11891 }
11892
11893
11894 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11895 PyObject *resultobj = 0;
11896 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11897 char arg2 ;
11898 bool result;
11899 void *argp1 = 0 ;
11900 int res1 = 0 ;
11901 char val2 ;
11902 int ecode2 = 0 ;
11903 PyObject * obj0 = 0 ;
11904 PyObject * obj1 = 0 ;
11905 char * kwnames[] = {
11906 (char *) "self",(char *) "c", NULL
11907 };
11908
11909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11911 if (!SWIG_IsOK(res1)) {
11912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11913 }
11914 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11915 ecode2 = SWIG_AsVal_char(obj1, &val2);
11916 if (!SWIG_IsOK(ecode2)) {
11917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11918 }
11919 arg2 = static_cast< char >(val2);
11920 {
11921 PyThreadState* __tstate = wxPyBeginAllowThreads();
11922 result = (bool)(arg1)->Ungetch(arg2);
11923 wxPyEndAllowThreads(__tstate);
11924 if (PyErr_Occurred()) SWIG_fail;
11925 }
11926 {
11927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11928 }
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj = 0;
11937 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11938 long arg2 ;
11939 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11940 long result;
11941 void *argp1 = 0 ;
11942 int res1 = 0 ;
11943 long val2 ;
11944 int ecode2 = 0 ;
11945 int val3 ;
11946 int ecode3 = 0 ;
11947 PyObject * obj0 = 0 ;
11948 PyObject * obj1 = 0 ;
11949 PyObject * obj2 = 0 ;
11950 char * kwnames[] = {
11951 (char *) "self",(char *) "pos",(char *) "mode", NULL
11952 };
11953
11954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11956 if (!SWIG_IsOK(res1)) {
11957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11958 }
11959 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11960 ecode2 = SWIG_AsVal_long(obj1, &val2);
11961 if (!SWIG_IsOK(ecode2)) {
11962 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11963 }
11964 arg2 = static_cast< long >(val2);
11965 if (obj2) {
11966 ecode3 = SWIG_AsVal_int(obj2, &val3);
11967 if (!SWIG_IsOK(ecode3)) {
11968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11969 }
11970 arg3 = static_cast< wxSeekMode >(val3);
11971 }
11972 {
11973 PyThreadState* __tstate = wxPyBeginAllowThreads();
11974 result = (long)(arg1)->SeekI(arg2,arg3);
11975 wxPyEndAllowThreads(__tstate);
11976 if (PyErr_Occurred()) SWIG_fail;
11977 }
11978 resultobj = SWIG_From_long(static_cast< long >(result));
11979 return resultobj;
11980 fail:
11981 return NULL;
11982 }
11983
11984
11985 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11986 PyObject *resultobj = 0;
11987 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11988 long result;
11989 void *argp1 = 0 ;
11990 int res1 = 0 ;
11991 PyObject *swig_obj[1] ;
11992
11993 if (!args) SWIG_fail;
11994 swig_obj[0] = args;
11995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11996 if (!SWIG_IsOK(res1)) {
11997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11998 }
11999 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12000 {
12001 PyThreadState* __tstate = wxPyBeginAllowThreads();
12002 result = (long)(arg1)->TellI();
12003 wxPyEndAllowThreads(__tstate);
12004 if (PyErr_Occurred()) SWIG_fail;
12005 }
12006 resultobj = SWIG_From_long(static_cast< long >(result));
12007 return resultobj;
12008 fail:
12009 return NULL;
12010 }
12011
12012
12013 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12014 PyObject *obj;
12015 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12016 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12017 return SWIG_Py_Void();
12018 }
12019
12020 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12021 return SWIG_Python_InitShadowInstance(args);
12022 }
12023
12024 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12025 PyObject *resultobj = 0;
12026 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12027 PyObject *arg2 = (PyObject *) 0 ;
12028 void *argp1 = 0 ;
12029 int res1 = 0 ;
12030 PyObject * obj0 = 0 ;
12031 PyObject * obj1 = 0 ;
12032 char * kwnames[] = {
12033 (char *) "self",(char *) "obj", NULL
12034 };
12035
12036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12038 if (!SWIG_IsOK(res1)) {
12039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12040 }
12041 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12042 arg2 = obj1;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 wxOutputStream_write(arg1,arg2);
12046 wxPyEndAllowThreads(__tstate);
12047 if (PyErr_Occurred()) SWIG_fail;
12048 }
12049 resultobj = SWIG_Py_Void();
12050 return resultobj;
12051 fail:
12052 return NULL;
12053 }
12054
12055
12056 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12057 PyObject *resultobj = 0;
12058 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12059 size_t result;
12060 void *argp1 = 0 ;
12061 int res1 = 0 ;
12062 PyObject *swig_obj[1] ;
12063
12064 if (!args) SWIG_fail;
12065 swig_obj[0] = args;
12066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12067 if (!SWIG_IsOK(res1)) {
12068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12069 }
12070 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12071 {
12072 PyThreadState* __tstate = wxPyBeginAllowThreads();
12073 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12074 wxPyEndAllowThreads(__tstate);
12075 if (PyErr_Occurred()) SWIG_fail;
12076 }
12077 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12078 return resultobj;
12079 fail:
12080 return NULL;
12081 }
12082
12083
12084 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12085 PyObject *obj;
12086 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12087 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12088 return SWIG_Py_Void();
12089 }
12090
12091 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj = 0;
12093 wxInputStream *arg1 = (wxInputStream *) 0 ;
12094 wxString *arg2 = 0 ;
12095 wxString *arg3 = 0 ;
12096 wxString *arg4 = 0 ;
12097 wxDateTime arg5 ;
12098 wxFSFile *result = 0 ;
12099 wxPyInputStream *temp1 ;
12100 bool temp2 = false ;
12101 bool temp3 = false ;
12102 bool temp4 = false ;
12103 void *argp5 ;
12104 int res5 = 0 ;
12105 PyObject * obj0 = 0 ;
12106 PyObject * obj1 = 0 ;
12107 PyObject * obj2 = 0 ;
12108 PyObject * obj3 = 0 ;
12109 PyObject * obj4 = 0 ;
12110 char * kwnames[] = {
12111 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12112 };
12113
12114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12115 {
12116 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12117 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12118 } else {
12119 PyErr_Clear(); // clear the failure of the wxPyConvert above
12120 arg1 = wxPyCBInputStream_create(obj0, true);
12121 if (arg1 == NULL) {
12122 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12123 SWIG_fail;
12124 }
12125 }
12126 }
12127 {
12128 arg2 = wxString_in_helper(obj1);
12129 if (arg2 == NULL) SWIG_fail;
12130 temp2 = true;
12131 }
12132 {
12133 arg3 = wxString_in_helper(obj2);
12134 if (arg3 == NULL) SWIG_fail;
12135 temp3 = true;
12136 }
12137 {
12138 arg4 = wxString_in_helper(obj3);
12139 if (arg4 == NULL) SWIG_fail;
12140 temp4 = true;
12141 }
12142 {
12143 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12144 if (!SWIG_IsOK(res5)) {
12145 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12146 }
12147 if (!argp5) {
12148 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12149 } else {
12150 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12151 arg5 = *temp;
12152 if (SWIG_IsNewObj(res5)) delete temp;
12153 }
12154 }
12155 {
12156 PyThreadState* __tstate = wxPyBeginAllowThreads();
12157 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12158 wxPyEndAllowThreads(__tstate);
12159 if (PyErr_Occurred()) SWIG_fail;
12160 }
12161 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12162 {
12163 if (temp2)
12164 delete arg2;
12165 }
12166 {
12167 if (temp3)
12168 delete arg3;
12169 }
12170 {
12171 if (temp4)
12172 delete arg4;
12173 }
12174 return resultobj;
12175 fail:
12176 {
12177 if (temp2)
12178 delete arg2;
12179 }
12180 {
12181 if (temp3)
12182 delete arg3;
12183 }
12184 {
12185 if (temp4)
12186 delete arg4;
12187 }
12188 return NULL;
12189 }
12190
12191
12192 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12193 PyObject *resultobj = 0;
12194 wxFSFile *arg1 = (wxFSFile *) 0 ;
12195 void *argp1 = 0 ;
12196 int res1 = 0 ;
12197 PyObject *swig_obj[1] ;
12198
12199 if (!args) SWIG_fail;
12200 swig_obj[0] = args;
12201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12202 if (!SWIG_IsOK(res1)) {
12203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12204 }
12205 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12206 {
12207 PyThreadState* __tstate = wxPyBeginAllowThreads();
12208 delete arg1;
12209
12210 wxPyEndAllowThreads(__tstate);
12211 if (PyErr_Occurred()) SWIG_fail;
12212 }
12213 resultobj = SWIG_Py_Void();
12214 return resultobj;
12215 fail:
12216 return NULL;
12217 }
12218
12219
12220 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12221 PyObject *resultobj = 0;
12222 wxFSFile *arg1 = (wxFSFile *) 0 ;
12223 wxInputStream *result = 0 ;
12224 void *argp1 = 0 ;
12225 int res1 = 0 ;
12226 PyObject *swig_obj[1] ;
12227
12228 if (!args) SWIG_fail;
12229 swig_obj[0] = args;
12230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12231 if (!SWIG_IsOK(res1)) {
12232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12233 }
12234 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 result = (wxInputStream *)(arg1)->GetStream();
12238 wxPyEndAllowThreads(__tstate);
12239 if (PyErr_Occurred()) SWIG_fail;
12240 }
12241 {
12242 wxPyInputStream * _ptr = NULL;
12243
12244 if (result) {
12245 _ptr = new wxPyInputStream(result);
12246 }
12247 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12248 }
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12256 PyObject *resultobj = 0;
12257 wxFSFile *arg1 = (wxFSFile *) 0 ;
12258 void *argp1 = 0 ;
12259 int res1 = 0 ;
12260 PyObject *swig_obj[1] ;
12261
12262 if (!args) SWIG_fail;
12263 swig_obj[0] = args;
12264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12265 if (!SWIG_IsOK(res1)) {
12266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12267 }
12268 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 (arg1)->DetachStream();
12272 wxPyEndAllowThreads(__tstate);
12273 if (PyErr_Occurred()) SWIG_fail;
12274 }
12275 resultobj = SWIG_Py_Void();
12276 return resultobj;
12277 fail:
12278 return NULL;
12279 }
12280
12281
12282 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12283 PyObject *resultobj = 0;
12284 wxFSFile *arg1 = (wxFSFile *) 0 ;
12285 wxString *result = 0 ;
12286 void *argp1 = 0 ;
12287 int res1 = 0 ;
12288 PyObject *swig_obj[1] ;
12289
12290 if (!args) SWIG_fail;
12291 swig_obj[0] = args;
12292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12293 if (!SWIG_IsOK(res1)) {
12294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12295 }
12296 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12297 {
12298 PyThreadState* __tstate = wxPyBeginAllowThreads();
12299 {
12300 wxString const &_result_ref = (arg1)->GetMimeType();
12301 result = (wxString *) &_result_ref;
12302 }
12303 wxPyEndAllowThreads(__tstate);
12304 if (PyErr_Occurred()) SWIG_fail;
12305 }
12306 {
12307 #if wxUSE_UNICODE
12308 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12309 #else
12310 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12311 #endif
12312 }
12313 return resultobj;
12314 fail:
12315 return NULL;
12316 }
12317
12318
12319 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12320 PyObject *resultobj = 0;
12321 wxFSFile *arg1 = (wxFSFile *) 0 ;
12322 wxString *result = 0 ;
12323 void *argp1 = 0 ;
12324 int res1 = 0 ;
12325 PyObject *swig_obj[1] ;
12326
12327 if (!args) SWIG_fail;
12328 swig_obj[0] = args;
12329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12330 if (!SWIG_IsOK(res1)) {
12331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12332 }
12333 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12334 {
12335 PyThreadState* __tstate = wxPyBeginAllowThreads();
12336 {
12337 wxString const &_result_ref = (arg1)->GetLocation();
12338 result = (wxString *) &_result_ref;
12339 }
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 {
12344 #if wxUSE_UNICODE
12345 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12346 #else
12347 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12348 #endif
12349 }
12350 return resultobj;
12351 fail:
12352 return NULL;
12353 }
12354
12355
12356 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12357 PyObject *resultobj = 0;
12358 wxFSFile *arg1 = (wxFSFile *) 0 ;
12359 wxString *result = 0 ;
12360 void *argp1 = 0 ;
12361 int res1 = 0 ;
12362 PyObject *swig_obj[1] ;
12363
12364 if (!args) SWIG_fail;
12365 swig_obj[0] = args;
12366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12367 if (!SWIG_IsOK(res1)) {
12368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12369 }
12370 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12371 {
12372 PyThreadState* __tstate = wxPyBeginAllowThreads();
12373 {
12374 wxString const &_result_ref = (arg1)->GetAnchor();
12375 result = (wxString *) &_result_ref;
12376 }
12377 wxPyEndAllowThreads(__tstate);
12378 if (PyErr_Occurred()) SWIG_fail;
12379 }
12380 {
12381 #if wxUSE_UNICODE
12382 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12383 #else
12384 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12385 #endif
12386 }
12387 return resultobj;
12388 fail:
12389 return NULL;
12390 }
12391
12392
12393 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12394 PyObject *resultobj = 0;
12395 wxFSFile *arg1 = (wxFSFile *) 0 ;
12396 wxDateTime result;
12397 void *argp1 = 0 ;
12398 int res1 = 0 ;
12399 PyObject *swig_obj[1] ;
12400
12401 if (!args) SWIG_fail;
12402 swig_obj[0] = args;
12403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12404 if (!SWIG_IsOK(res1)) {
12405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12406 }
12407 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12408 {
12409 PyThreadState* __tstate = wxPyBeginAllowThreads();
12410 result = (arg1)->GetModificationTime();
12411 wxPyEndAllowThreads(__tstate);
12412 if (PyErr_Occurred()) SWIG_fail;
12413 }
12414 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12415 return resultobj;
12416 fail:
12417 return NULL;
12418 }
12419
12420
12421 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12422 PyObject *obj;
12423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12424 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12425 return SWIG_Py_Void();
12426 }
12427
12428 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12429 return SWIG_Python_InitShadowInstance(args);
12430 }
12431
12432 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12433 PyObject *resultobj = 0;
12434 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12435 void *argp1 = 0 ;
12436 int res1 = 0 ;
12437 PyObject *swig_obj[1] ;
12438
12439 if (!args) SWIG_fail;
12440 swig_obj[0] = args;
12441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12442 if (!SWIG_IsOK(res1)) {
12443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12444 }
12445 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 delete arg1;
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 resultobj = SWIG_Py_Void();
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12461 PyObject *obj;
12462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12463 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12464 return SWIG_Py_Void();
12465 }
12466
12467 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12468 PyObject *resultobj = 0;
12469 wxPyFileSystemHandler *result = 0 ;
12470
12471 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12472 {
12473 PyThreadState* __tstate = wxPyBeginAllowThreads();
12474 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12475 wxPyEndAllowThreads(__tstate);
12476 if (PyErr_Occurred()) SWIG_fail;
12477 }
12478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12479 return resultobj;
12480 fail:
12481 return NULL;
12482 }
12483
12484
12485 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12486 PyObject *resultobj = 0;
12487 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12488 PyObject *arg2 = (PyObject *) 0 ;
12489 PyObject *arg3 = (PyObject *) 0 ;
12490 void *argp1 = 0 ;
12491 int res1 = 0 ;
12492 PyObject * obj0 = 0 ;
12493 PyObject * obj1 = 0 ;
12494 PyObject * obj2 = 0 ;
12495 char * kwnames[] = {
12496 (char *) "self",(char *) "self",(char *) "_class", NULL
12497 };
12498
12499 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12500 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12501 if (!SWIG_IsOK(res1)) {
12502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12503 }
12504 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12505 arg2 = obj1;
12506 arg3 = obj2;
12507 {
12508 PyThreadState* __tstate = wxPyBeginAllowThreads();
12509 (arg1)->_setCallbackInfo(arg2,arg3);
12510 wxPyEndAllowThreads(__tstate);
12511 if (PyErr_Occurred()) SWIG_fail;
12512 }
12513 resultobj = SWIG_Py_Void();
12514 return resultobj;
12515 fail:
12516 return NULL;
12517 }
12518
12519
12520 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = 0;
12522 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12523 wxString *arg2 = 0 ;
12524 bool result;
12525 void *argp1 = 0 ;
12526 int res1 = 0 ;
12527 bool temp2 = false ;
12528 PyObject * obj0 = 0 ;
12529 PyObject * obj1 = 0 ;
12530 char * kwnames[] = {
12531 (char *) "self",(char *) "location", NULL
12532 };
12533
12534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12536 if (!SWIG_IsOK(res1)) {
12537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12538 }
12539 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12540 {
12541 arg2 = wxString_in_helper(obj1);
12542 if (arg2 == NULL) SWIG_fail;
12543 temp2 = true;
12544 }
12545 {
12546 PyThreadState* __tstate = wxPyBeginAllowThreads();
12547 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12548 wxPyEndAllowThreads(__tstate);
12549 if (PyErr_Occurred()) SWIG_fail;
12550 }
12551 {
12552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12553 }
12554 {
12555 if (temp2)
12556 delete arg2;
12557 }
12558 return resultobj;
12559 fail:
12560 {
12561 if (temp2)
12562 delete arg2;
12563 }
12564 return NULL;
12565 }
12566
12567
12568 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12569 PyObject *resultobj = 0;
12570 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12571 wxFileSystem *arg2 = 0 ;
12572 wxString *arg3 = 0 ;
12573 wxFSFile *result = 0 ;
12574 void *argp1 = 0 ;
12575 int res1 = 0 ;
12576 void *argp2 = 0 ;
12577 int res2 = 0 ;
12578 bool temp3 = false ;
12579 PyObject * obj0 = 0 ;
12580 PyObject * obj1 = 0 ;
12581 PyObject * obj2 = 0 ;
12582 char * kwnames[] = {
12583 (char *) "self",(char *) "fs",(char *) "location", NULL
12584 };
12585
12586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12588 if (!SWIG_IsOK(res1)) {
12589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12590 }
12591 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12592 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12593 if (!SWIG_IsOK(res2)) {
12594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12595 }
12596 if (!argp2) {
12597 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12598 }
12599 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12600 {
12601 arg3 = wxString_in_helper(obj2);
12602 if (arg3 == NULL) SWIG_fail;
12603 temp3 = true;
12604 }
12605 {
12606 PyThreadState* __tstate = wxPyBeginAllowThreads();
12607 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12608 wxPyEndAllowThreads(__tstate);
12609 if (PyErr_Occurred()) SWIG_fail;
12610 }
12611 {
12612 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12613 }
12614 {
12615 if (temp3)
12616 delete arg3;
12617 }
12618 return resultobj;
12619 fail:
12620 {
12621 if (temp3)
12622 delete arg3;
12623 }
12624 return NULL;
12625 }
12626
12627
12628 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12629 PyObject *resultobj = 0;
12630 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12631 wxString *arg2 = 0 ;
12632 int arg3 = (int) 0 ;
12633 wxString result;
12634 void *argp1 = 0 ;
12635 int res1 = 0 ;
12636 bool temp2 = false ;
12637 int val3 ;
12638 int ecode3 = 0 ;
12639 PyObject * obj0 = 0 ;
12640 PyObject * obj1 = 0 ;
12641 PyObject * obj2 = 0 ;
12642 char * kwnames[] = {
12643 (char *) "self",(char *) "spec",(char *) "flags", NULL
12644 };
12645
12646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12648 if (!SWIG_IsOK(res1)) {
12649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12650 }
12651 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12652 {
12653 arg2 = wxString_in_helper(obj1);
12654 if (arg2 == NULL) SWIG_fail;
12655 temp2 = true;
12656 }
12657 if (obj2) {
12658 ecode3 = SWIG_AsVal_int(obj2, &val3);
12659 if (!SWIG_IsOK(ecode3)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12661 }
12662 arg3 = static_cast< int >(val3);
12663 }
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12667 wxPyEndAllowThreads(__tstate);
12668 if (PyErr_Occurred()) SWIG_fail;
12669 }
12670 {
12671 #if wxUSE_UNICODE
12672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12673 #else
12674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12675 #endif
12676 }
12677 {
12678 if (temp2)
12679 delete arg2;
12680 }
12681 return resultobj;
12682 fail:
12683 {
12684 if (temp2)
12685 delete arg2;
12686 }
12687 return NULL;
12688 }
12689
12690
12691 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12692 PyObject *resultobj = 0;
12693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12694 wxString result;
12695 void *argp1 = 0 ;
12696 int res1 = 0 ;
12697 PyObject *swig_obj[1] ;
12698
12699 if (!args) SWIG_fail;
12700 swig_obj[0] = args;
12701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12702 if (!SWIG_IsOK(res1)) {
12703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12704 }
12705 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12706 {
12707 PyThreadState* __tstate = wxPyBeginAllowThreads();
12708 result = (arg1)->FindNext();
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 {
12713 #if wxUSE_UNICODE
12714 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12715 #else
12716 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12717 #endif
12718 }
12719 return resultobj;
12720 fail:
12721 return NULL;
12722 }
12723
12724
12725 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12726 PyObject *resultobj = 0;
12727 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12728 wxString *arg2 = 0 ;
12729 wxString result;
12730 void *argp1 = 0 ;
12731 int res1 = 0 ;
12732 bool temp2 = false ;
12733 PyObject * obj0 = 0 ;
12734 PyObject * obj1 = 0 ;
12735 char * kwnames[] = {
12736 (char *) "self",(char *) "location", NULL
12737 };
12738
12739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12741 if (!SWIG_IsOK(res1)) {
12742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12743 }
12744 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12745 {
12746 arg2 = wxString_in_helper(obj1);
12747 if (arg2 == NULL) SWIG_fail;
12748 temp2 = true;
12749 }
12750 {
12751 PyThreadState* __tstate = wxPyBeginAllowThreads();
12752 result = (arg1)->GetProtocol((wxString const &)*arg2);
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 {
12757 #if wxUSE_UNICODE
12758 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12759 #else
12760 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12761 #endif
12762 }
12763 {
12764 if (temp2)
12765 delete arg2;
12766 }
12767 return resultobj;
12768 fail:
12769 {
12770 if (temp2)
12771 delete arg2;
12772 }
12773 return NULL;
12774 }
12775
12776
12777 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12778 PyObject *resultobj = 0;
12779 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12780 wxString *arg2 = 0 ;
12781 wxString result;
12782 void *argp1 = 0 ;
12783 int res1 = 0 ;
12784 bool temp2 = false ;
12785 PyObject * obj0 = 0 ;
12786 PyObject * obj1 = 0 ;
12787 char * kwnames[] = {
12788 (char *) "self",(char *) "location", NULL
12789 };
12790
12791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12793 if (!SWIG_IsOK(res1)) {
12794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12795 }
12796 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12797 {
12798 arg2 = wxString_in_helper(obj1);
12799 if (arg2 == NULL) SWIG_fail;
12800 temp2 = true;
12801 }
12802 {
12803 PyThreadState* __tstate = wxPyBeginAllowThreads();
12804 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12805 wxPyEndAllowThreads(__tstate);
12806 if (PyErr_Occurred()) SWIG_fail;
12807 }
12808 {
12809 #if wxUSE_UNICODE
12810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12811 #else
12812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12813 #endif
12814 }
12815 {
12816 if (temp2)
12817 delete arg2;
12818 }
12819 return resultobj;
12820 fail:
12821 {
12822 if (temp2)
12823 delete arg2;
12824 }
12825 return NULL;
12826 }
12827
12828
12829 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12830 PyObject *resultobj = 0;
12831 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12832 wxString *arg2 = 0 ;
12833 wxString result;
12834 void *argp1 = 0 ;
12835 int res1 = 0 ;
12836 bool temp2 = false ;
12837 PyObject * obj0 = 0 ;
12838 PyObject * obj1 = 0 ;
12839 char * kwnames[] = {
12840 (char *) "self",(char *) "location", NULL
12841 };
12842
12843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12845 if (!SWIG_IsOK(res1)) {
12846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12847 }
12848 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12849 {
12850 arg2 = wxString_in_helper(obj1);
12851 if (arg2 == NULL) SWIG_fail;
12852 temp2 = true;
12853 }
12854 {
12855 PyThreadState* __tstate = wxPyBeginAllowThreads();
12856 result = (arg1)->GetAnchor((wxString const &)*arg2);
12857 wxPyEndAllowThreads(__tstate);
12858 if (PyErr_Occurred()) SWIG_fail;
12859 }
12860 {
12861 #if wxUSE_UNICODE
12862 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12863 #else
12864 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12865 #endif
12866 }
12867 {
12868 if (temp2)
12869 delete arg2;
12870 }
12871 return resultobj;
12872 fail:
12873 {
12874 if (temp2)
12875 delete arg2;
12876 }
12877 return NULL;
12878 }
12879
12880
12881 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12882 PyObject *resultobj = 0;
12883 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12884 wxString *arg2 = 0 ;
12885 wxString result;
12886 void *argp1 = 0 ;
12887 int res1 = 0 ;
12888 bool temp2 = false ;
12889 PyObject * obj0 = 0 ;
12890 PyObject * obj1 = 0 ;
12891 char * kwnames[] = {
12892 (char *) "self",(char *) "location", NULL
12893 };
12894
12895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12897 if (!SWIG_IsOK(res1)) {
12898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12899 }
12900 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12901 {
12902 arg2 = wxString_in_helper(obj1);
12903 if (arg2 == NULL) SWIG_fail;
12904 temp2 = true;
12905 }
12906 {
12907 PyThreadState* __tstate = wxPyBeginAllowThreads();
12908 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 {
12913 #if wxUSE_UNICODE
12914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12915 #else
12916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12917 #endif
12918 }
12919 {
12920 if (temp2)
12921 delete arg2;
12922 }
12923 return resultobj;
12924 fail:
12925 {
12926 if (temp2)
12927 delete arg2;
12928 }
12929 return NULL;
12930 }
12931
12932
12933 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12934 PyObject *resultobj = 0;
12935 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12936 wxString *arg2 = 0 ;
12937 wxString result;
12938 void *argp1 = 0 ;
12939 int res1 = 0 ;
12940 bool temp2 = false ;
12941 PyObject * obj0 = 0 ;
12942 PyObject * obj1 = 0 ;
12943 char * kwnames[] = {
12944 (char *) "self",(char *) "location", NULL
12945 };
12946
12947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12949 if (!SWIG_IsOK(res1)) {
12950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12951 }
12952 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12953 {
12954 arg2 = wxString_in_helper(obj1);
12955 if (arg2 == NULL) SWIG_fail;
12956 temp2 = true;
12957 }
12958 {
12959 PyThreadState* __tstate = wxPyBeginAllowThreads();
12960 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12961 wxPyEndAllowThreads(__tstate);
12962 if (PyErr_Occurred()) SWIG_fail;
12963 }
12964 {
12965 #if wxUSE_UNICODE
12966 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12967 #else
12968 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12969 #endif
12970 }
12971 {
12972 if (temp2)
12973 delete arg2;
12974 }
12975 return resultobj;
12976 fail:
12977 {
12978 if (temp2)
12979 delete arg2;
12980 }
12981 return NULL;
12982 }
12983
12984
12985 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12986 PyObject *obj;
12987 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12988 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
12989 return SWIG_Py_Void();
12990 }
12991
12992 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12993 return SWIG_Python_InitShadowInstance(args);
12994 }
12995
12996 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12997 PyObject *resultobj = 0;
12998 wxFileSystem *result = 0 ;
12999
13000 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13001 {
13002 PyThreadState* __tstate = wxPyBeginAllowThreads();
13003 result = (wxFileSystem *)new wxFileSystem();
13004 wxPyEndAllowThreads(__tstate);
13005 if (PyErr_Occurred()) SWIG_fail;
13006 }
13007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13008 return resultobj;
13009 fail:
13010 return NULL;
13011 }
13012
13013
13014 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13015 PyObject *resultobj = 0;
13016 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13017 void *argp1 = 0 ;
13018 int res1 = 0 ;
13019 PyObject *swig_obj[1] ;
13020
13021 if (!args) SWIG_fail;
13022 swig_obj[0] = args;
13023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13024 if (!SWIG_IsOK(res1)) {
13025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13026 }
13027 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13028 {
13029 PyThreadState* __tstate = wxPyBeginAllowThreads();
13030 delete arg1;
13031
13032 wxPyEndAllowThreads(__tstate);
13033 if (PyErr_Occurred()) SWIG_fail;
13034 }
13035 resultobj = SWIG_Py_Void();
13036 return resultobj;
13037 fail:
13038 return NULL;
13039 }
13040
13041
13042 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13043 PyObject *resultobj = 0;
13044 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13045 wxString *arg2 = 0 ;
13046 bool arg3 = (bool) false ;
13047 void *argp1 = 0 ;
13048 int res1 = 0 ;
13049 bool temp2 = false ;
13050 bool val3 ;
13051 int ecode3 = 0 ;
13052 PyObject * obj0 = 0 ;
13053 PyObject * obj1 = 0 ;
13054 PyObject * obj2 = 0 ;
13055 char * kwnames[] = {
13056 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13057 };
13058
13059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13061 if (!SWIG_IsOK(res1)) {
13062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13063 }
13064 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13065 {
13066 arg2 = wxString_in_helper(obj1);
13067 if (arg2 == NULL) SWIG_fail;
13068 temp2 = true;
13069 }
13070 if (obj2) {
13071 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13072 if (!SWIG_IsOK(ecode3)) {
13073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13074 }
13075 arg3 = static_cast< bool >(val3);
13076 }
13077 {
13078 PyThreadState* __tstate = wxPyBeginAllowThreads();
13079 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13080 wxPyEndAllowThreads(__tstate);
13081 if (PyErr_Occurred()) SWIG_fail;
13082 }
13083 resultobj = SWIG_Py_Void();
13084 {
13085 if (temp2)
13086 delete arg2;
13087 }
13088 return resultobj;
13089 fail:
13090 {
13091 if (temp2)
13092 delete arg2;
13093 }
13094 return NULL;
13095 }
13096
13097
13098 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13099 PyObject *resultobj = 0;
13100 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13101 wxString result;
13102 void *argp1 = 0 ;
13103 int res1 = 0 ;
13104 PyObject *swig_obj[1] ;
13105
13106 if (!args) SWIG_fail;
13107 swig_obj[0] = args;
13108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13109 if (!SWIG_IsOK(res1)) {
13110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13111 }
13112 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13113 {
13114 PyThreadState* __tstate = wxPyBeginAllowThreads();
13115 result = (arg1)->GetPath();
13116 wxPyEndAllowThreads(__tstate);
13117 if (PyErr_Occurred()) SWIG_fail;
13118 }
13119 {
13120 #if wxUSE_UNICODE
13121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13122 #else
13123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13124 #endif
13125 }
13126 return resultobj;
13127 fail:
13128 return NULL;
13129 }
13130
13131
13132 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13133 PyObject *resultobj = 0;
13134 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13135 wxString *arg2 = 0 ;
13136 wxFSFile *result = 0 ;
13137 void *argp1 = 0 ;
13138 int res1 = 0 ;
13139 bool temp2 = false ;
13140 PyObject * obj0 = 0 ;
13141 PyObject * obj1 = 0 ;
13142 char * kwnames[] = {
13143 (char *) "self",(char *) "location", NULL
13144 };
13145
13146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13148 if (!SWIG_IsOK(res1)) {
13149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13150 }
13151 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13152 {
13153 arg2 = wxString_in_helper(obj1);
13154 if (arg2 == NULL) SWIG_fail;
13155 temp2 = true;
13156 }
13157 {
13158 PyThreadState* __tstate = wxPyBeginAllowThreads();
13159 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13160 wxPyEndAllowThreads(__tstate);
13161 if (PyErr_Occurred()) SWIG_fail;
13162 }
13163 {
13164 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13165 }
13166 {
13167 if (temp2)
13168 delete arg2;
13169 }
13170 return resultobj;
13171 fail:
13172 {
13173 if (temp2)
13174 delete arg2;
13175 }
13176 return NULL;
13177 }
13178
13179
13180 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13181 PyObject *resultobj = 0;
13182 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13183 wxString *arg2 = 0 ;
13184 int arg3 = (int) 0 ;
13185 wxString result;
13186 void *argp1 = 0 ;
13187 int res1 = 0 ;
13188 bool temp2 = false ;
13189 int val3 ;
13190 int ecode3 = 0 ;
13191 PyObject * obj0 = 0 ;
13192 PyObject * obj1 = 0 ;
13193 PyObject * obj2 = 0 ;
13194 char * kwnames[] = {
13195 (char *) "self",(char *) "spec",(char *) "flags", NULL
13196 };
13197
13198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13200 if (!SWIG_IsOK(res1)) {
13201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13202 }
13203 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13204 {
13205 arg2 = wxString_in_helper(obj1);
13206 if (arg2 == NULL) SWIG_fail;
13207 temp2 = true;
13208 }
13209 if (obj2) {
13210 ecode3 = SWIG_AsVal_int(obj2, &val3);
13211 if (!SWIG_IsOK(ecode3)) {
13212 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13213 }
13214 arg3 = static_cast< int >(val3);
13215 }
13216 {
13217 PyThreadState* __tstate = wxPyBeginAllowThreads();
13218 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13219 wxPyEndAllowThreads(__tstate);
13220 if (PyErr_Occurred()) SWIG_fail;
13221 }
13222 {
13223 #if wxUSE_UNICODE
13224 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13225 #else
13226 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13227 #endif
13228 }
13229 {
13230 if (temp2)
13231 delete arg2;
13232 }
13233 return resultobj;
13234 fail:
13235 {
13236 if (temp2)
13237 delete arg2;
13238 }
13239 return NULL;
13240 }
13241
13242
13243 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13244 PyObject *resultobj = 0;
13245 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13246 wxString result;
13247 void *argp1 = 0 ;
13248 int res1 = 0 ;
13249 PyObject *swig_obj[1] ;
13250
13251 if (!args) SWIG_fail;
13252 swig_obj[0] = args;
13253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13254 if (!SWIG_IsOK(res1)) {
13255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13256 }
13257 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13258 {
13259 PyThreadState* __tstate = wxPyBeginAllowThreads();
13260 result = (arg1)->FindNext();
13261 wxPyEndAllowThreads(__tstate);
13262 if (PyErr_Occurred()) SWIG_fail;
13263 }
13264 {
13265 #if wxUSE_UNICODE
13266 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13267 #else
13268 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13269 #endif
13270 }
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13278 PyObject *resultobj = 0;
13279 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13280 int res1 = 0 ;
13281 PyObject * obj0 = 0 ;
13282 char * kwnames[] = {
13283 (char *) "handler", NULL
13284 };
13285
13286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13287 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13288 if (!SWIG_IsOK(res1)) {
13289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13290 }
13291 {
13292 PyThreadState* __tstate = wxPyBeginAllowThreads();
13293 wxFileSystem::AddHandler(arg1);
13294 wxPyEndAllowThreads(__tstate);
13295 if (PyErr_Occurred()) SWIG_fail;
13296 }
13297 resultobj = SWIG_Py_Void();
13298 return resultobj;
13299 fail:
13300 return NULL;
13301 }
13302
13303
13304 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13305 PyObject *resultobj = 0;
13306 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13307 wxFileSystemHandler *result = 0 ;
13308 void *argp1 = 0 ;
13309 int res1 = 0 ;
13310 PyObject * obj0 = 0 ;
13311 char * kwnames[] = {
13312 (char *) "handler", NULL
13313 };
13314
13315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13317 if (!SWIG_IsOK(res1)) {
13318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13319 }
13320 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13321 {
13322 PyThreadState* __tstate = wxPyBeginAllowThreads();
13323 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13324 wxPyEndAllowThreads(__tstate);
13325 if (PyErr_Occurred()) SWIG_fail;
13326 }
13327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13328 return resultobj;
13329 fail:
13330 return NULL;
13331 }
13332
13333
13334 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13335 PyObject *resultobj = 0;
13336
13337 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 wxFileSystem::CleanUpHandlers();
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_Py_Void();
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj = 0;
13353 wxString *arg1 = 0 ;
13354 wxString result;
13355 bool temp1 = false ;
13356 PyObject * obj0 = 0 ;
13357 char * kwnames[] = {
13358 (char *) "filename", NULL
13359 };
13360
13361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13362 {
13363 arg1 = wxString_in_helper(obj0);
13364 if (arg1 == NULL) SWIG_fail;
13365 temp1 = true;
13366 }
13367 {
13368 PyThreadState* __tstate = wxPyBeginAllowThreads();
13369 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13370 wxPyEndAllowThreads(__tstate);
13371 if (PyErr_Occurred()) SWIG_fail;
13372 }
13373 {
13374 #if wxUSE_UNICODE
13375 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13376 #else
13377 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13378 #endif
13379 }
13380 {
13381 if (temp1)
13382 delete arg1;
13383 }
13384 return resultobj;
13385 fail:
13386 {
13387 if (temp1)
13388 delete arg1;
13389 }
13390 return NULL;
13391 }
13392
13393
13394 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13395 PyObject *resultobj = 0;
13396 wxString *arg1 = 0 ;
13397 wxString result;
13398 bool temp1 = false ;
13399 PyObject * obj0 = 0 ;
13400 char * kwnames[] = {
13401 (char *) "url", NULL
13402 };
13403
13404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13405 {
13406 arg1 = wxString_in_helper(obj0);
13407 if (arg1 == NULL) SWIG_fail;
13408 temp1 = true;
13409 }
13410 {
13411 PyThreadState* __tstate = wxPyBeginAllowThreads();
13412 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13413 wxPyEndAllowThreads(__tstate);
13414 if (PyErr_Occurred()) SWIG_fail;
13415 }
13416 {
13417 #if wxUSE_UNICODE
13418 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13419 #else
13420 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13421 #endif
13422 }
13423 {
13424 if (temp1)
13425 delete arg1;
13426 }
13427 return resultobj;
13428 fail:
13429 {
13430 if (temp1)
13431 delete arg1;
13432 }
13433 return NULL;
13434 }
13435
13436
13437 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13438 PyObject *obj;
13439 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13440 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13441 return SWIG_Py_Void();
13442 }
13443
13444 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13445 return SWIG_Python_InitShadowInstance(args);
13446 }
13447
13448 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13449 PyObject *resultobj = 0;
13450 wxInternetFSHandler *result = 0 ;
13451
13452 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13453 {
13454 PyThreadState* __tstate = wxPyBeginAllowThreads();
13455 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13460 return resultobj;
13461 fail:
13462 return NULL;
13463 }
13464
13465
13466 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13467 PyObject *resultobj = 0;
13468 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13469 wxString *arg2 = 0 ;
13470 bool result;
13471 void *argp1 = 0 ;
13472 int res1 = 0 ;
13473 bool temp2 = false ;
13474 PyObject * obj0 = 0 ;
13475 PyObject * obj1 = 0 ;
13476 char * kwnames[] = {
13477 (char *) "self",(char *) "location", NULL
13478 };
13479
13480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13482 if (!SWIG_IsOK(res1)) {
13483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13484 }
13485 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13486 {
13487 arg2 = wxString_in_helper(obj1);
13488 if (arg2 == NULL) SWIG_fail;
13489 temp2 = true;
13490 }
13491 {
13492 PyThreadState* __tstate = wxPyBeginAllowThreads();
13493 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13494 wxPyEndAllowThreads(__tstate);
13495 if (PyErr_Occurred()) SWIG_fail;
13496 }
13497 {
13498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13499 }
13500 {
13501 if (temp2)
13502 delete arg2;
13503 }
13504 return resultobj;
13505 fail:
13506 {
13507 if (temp2)
13508 delete arg2;
13509 }
13510 return NULL;
13511 }
13512
13513
13514 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13515 PyObject *resultobj = 0;
13516 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13517 wxFileSystem *arg2 = 0 ;
13518 wxString *arg3 = 0 ;
13519 wxFSFile *result = 0 ;
13520 void *argp1 = 0 ;
13521 int res1 = 0 ;
13522 void *argp2 = 0 ;
13523 int res2 = 0 ;
13524 bool temp3 = false ;
13525 PyObject * obj0 = 0 ;
13526 PyObject * obj1 = 0 ;
13527 PyObject * obj2 = 0 ;
13528 char * kwnames[] = {
13529 (char *) "self",(char *) "fs",(char *) "location", NULL
13530 };
13531
13532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13534 if (!SWIG_IsOK(res1)) {
13535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13536 }
13537 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13539 if (!SWIG_IsOK(res2)) {
13540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13541 }
13542 if (!argp2) {
13543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13544 }
13545 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13546 {
13547 arg3 = wxString_in_helper(obj2);
13548 if (arg3 == NULL) SWIG_fail;
13549 temp3 = true;
13550 }
13551 {
13552 PyThreadState* __tstate = wxPyBeginAllowThreads();
13553 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13554 wxPyEndAllowThreads(__tstate);
13555 if (PyErr_Occurred()) SWIG_fail;
13556 }
13557 {
13558 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13559 }
13560 {
13561 if (temp3)
13562 delete arg3;
13563 }
13564 return resultobj;
13565 fail:
13566 {
13567 if (temp3)
13568 delete arg3;
13569 }
13570 return NULL;
13571 }
13572
13573
13574 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13575 PyObject *obj;
13576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13577 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13578 return SWIG_Py_Void();
13579 }
13580
13581 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13582 return SWIG_Python_InitShadowInstance(args);
13583 }
13584
13585 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13586 PyObject *resultobj = 0;
13587 wxZipFSHandler *result = 0 ;
13588
13589 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13590 {
13591 PyThreadState* __tstate = wxPyBeginAllowThreads();
13592 result = (wxZipFSHandler *)new wxZipFSHandler();
13593 wxPyEndAllowThreads(__tstate);
13594 if (PyErr_Occurred()) SWIG_fail;
13595 }
13596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13597 return resultobj;
13598 fail:
13599 return NULL;
13600 }
13601
13602
13603 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13604 PyObject *resultobj = 0;
13605 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13606 wxString *arg2 = 0 ;
13607 bool result;
13608 void *argp1 = 0 ;
13609 int res1 = 0 ;
13610 bool temp2 = false ;
13611 PyObject * obj0 = 0 ;
13612 PyObject * obj1 = 0 ;
13613 char * kwnames[] = {
13614 (char *) "self",(char *) "location", NULL
13615 };
13616
13617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13619 if (!SWIG_IsOK(res1)) {
13620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13621 }
13622 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13623 {
13624 arg2 = wxString_in_helper(obj1);
13625 if (arg2 == NULL) SWIG_fail;
13626 temp2 = true;
13627 }
13628 {
13629 PyThreadState* __tstate = wxPyBeginAllowThreads();
13630 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13631 wxPyEndAllowThreads(__tstate);
13632 if (PyErr_Occurred()) SWIG_fail;
13633 }
13634 {
13635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13636 }
13637 {
13638 if (temp2)
13639 delete arg2;
13640 }
13641 return resultobj;
13642 fail:
13643 {
13644 if (temp2)
13645 delete arg2;
13646 }
13647 return NULL;
13648 }
13649
13650
13651 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13652 PyObject *resultobj = 0;
13653 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13654 wxFileSystem *arg2 = 0 ;
13655 wxString *arg3 = 0 ;
13656 wxFSFile *result = 0 ;
13657 void *argp1 = 0 ;
13658 int res1 = 0 ;
13659 void *argp2 = 0 ;
13660 int res2 = 0 ;
13661 bool temp3 = false ;
13662 PyObject * obj0 = 0 ;
13663 PyObject * obj1 = 0 ;
13664 PyObject * obj2 = 0 ;
13665 char * kwnames[] = {
13666 (char *) "self",(char *) "fs",(char *) "location", NULL
13667 };
13668
13669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13671 if (!SWIG_IsOK(res1)) {
13672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13673 }
13674 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13675 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13676 if (!SWIG_IsOK(res2)) {
13677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13678 }
13679 if (!argp2) {
13680 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13681 }
13682 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13683 {
13684 arg3 = wxString_in_helper(obj2);
13685 if (arg3 == NULL) SWIG_fail;
13686 temp3 = true;
13687 }
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13691 wxPyEndAllowThreads(__tstate);
13692 if (PyErr_Occurred()) SWIG_fail;
13693 }
13694 {
13695 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13696 }
13697 {
13698 if (temp3)
13699 delete arg3;
13700 }
13701 return resultobj;
13702 fail:
13703 {
13704 if (temp3)
13705 delete arg3;
13706 }
13707 return NULL;
13708 }
13709
13710
13711 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13712 PyObject *resultobj = 0;
13713 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13714 wxString *arg2 = 0 ;
13715 int arg3 = (int) 0 ;
13716 wxString result;
13717 void *argp1 = 0 ;
13718 int res1 = 0 ;
13719 bool temp2 = false ;
13720 int val3 ;
13721 int ecode3 = 0 ;
13722 PyObject * obj0 = 0 ;
13723 PyObject * obj1 = 0 ;
13724 PyObject * obj2 = 0 ;
13725 char * kwnames[] = {
13726 (char *) "self",(char *) "spec",(char *) "flags", NULL
13727 };
13728
13729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13731 if (!SWIG_IsOK(res1)) {
13732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13733 }
13734 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13735 {
13736 arg2 = wxString_in_helper(obj1);
13737 if (arg2 == NULL) SWIG_fail;
13738 temp2 = true;
13739 }
13740 if (obj2) {
13741 ecode3 = SWIG_AsVal_int(obj2, &val3);
13742 if (!SWIG_IsOK(ecode3)) {
13743 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13744 }
13745 arg3 = static_cast< int >(val3);
13746 }
13747 {
13748 PyThreadState* __tstate = wxPyBeginAllowThreads();
13749 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13750 wxPyEndAllowThreads(__tstate);
13751 if (PyErr_Occurred()) SWIG_fail;
13752 }
13753 {
13754 #if wxUSE_UNICODE
13755 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13756 #else
13757 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13758 #endif
13759 }
13760 {
13761 if (temp2)
13762 delete arg2;
13763 }
13764 return resultobj;
13765 fail:
13766 {
13767 if (temp2)
13768 delete arg2;
13769 }
13770 return NULL;
13771 }
13772
13773
13774 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13775 PyObject *resultobj = 0;
13776 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13777 wxString result;
13778 void *argp1 = 0 ;
13779 int res1 = 0 ;
13780 PyObject *swig_obj[1] ;
13781
13782 if (!args) SWIG_fail;
13783 swig_obj[0] = args;
13784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13785 if (!SWIG_IsOK(res1)) {
13786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13787 }
13788 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13789 {
13790 PyThreadState* __tstate = wxPyBeginAllowThreads();
13791 result = (arg1)->FindNext();
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 {
13796 #if wxUSE_UNICODE
13797 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13798 #else
13799 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13800 #endif
13801 }
13802 return resultobj;
13803 fail:
13804 return NULL;
13805 }
13806
13807
13808 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13809 PyObject *obj;
13810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13811 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13812 return SWIG_Py_Void();
13813 }
13814
13815 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13816 return SWIG_Python_InitShadowInstance(args);
13817 }
13818
13819 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13820 PyObject *resultobj = 0;
13821 wxString *arg1 = 0 ;
13822 wxImage *arg2 = 0 ;
13823 long arg3 ;
13824 bool temp1 = false ;
13825 void *argp2 = 0 ;
13826 int res2 = 0 ;
13827 long val3 ;
13828 int ecode3 = 0 ;
13829 PyObject * obj0 = 0 ;
13830 PyObject * obj1 = 0 ;
13831 PyObject * obj2 = 0 ;
13832 char * kwnames[] = {
13833 (char *) "filename",(char *) "image",(char *) "type", NULL
13834 };
13835
13836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13837 {
13838 arg1 = wxString_in_helper(obj0);
13839 if (arg1 == NULL) SWIG_fail;
13840 temp1 = true;
13841 }
13842 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13843 if (!SWIG_IsOK(res2)) {
13844 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13845 }
13846 if (!argp2) {
13847 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13848 }
13849 arg2 = reinterpret_cast< wxImage * >(argp2);
13850 ecode3 = SWIG_AsVal_long(obj2, &val3);
13851 if (!SWIG_IsOK(ecode3)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13853 }
13854 arg3 = static_cast< long >(val3);
13855 {
13856 PyThreadState* __tstate = wxPyBeginAllowThreads();
13857 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13858 wxPyEndAllowThreads(__tstate);
13859 if (PyErr_Occurred()) SWIG_fail;
13860 }
13861 resultobj = SWIG_Py_Void();
13862 {
13863 if (temp1)
13864 delete arg1;
13865 }
13866 return resultobj;
13867 fail:
13868 {
13869 if (temp1)
13870 delete arg1;
13871 }
13872 return NULL;
13873 }
13874
13875
13876 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13877 PyObject *resultobj = 0;
13878 wxString *arg1 = 0 ;
13879 wxBitmap *arg2 = 0 ;
13880 long arg3 ;
13881 bool temp1 = false ;
13882 void *argp2 = 0 ;
13883 int res2 = 0 ;
13884 long val3 ;
13885 int ecode3 = 0 ;
13886 PyObject * obj0 = 0 ;
13887 PyObject * obj1 = 0 ;
13888 PyObject * obj2 = 0 ;
13889 char * kwnames[] = {
13890 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13891 };
13892
13893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13894 {
13895 arg1 = wxString_in_helper(obj0);
13896 if (arg1 == NULL) SWIG_fail;
13897 temp1 = true;
13898 }
13899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13900 if (!SWIG_IsOK(res2)) {
13901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13902 }
13903 if (!argp2) {
13904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13905 }
13906 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13907 ecode3 = SWIG_AsVal_long(obj2, &val3);
13908 if (!SWIG_IsOK(ecode3)) {
13909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13910 }
13911 arg3 = static_cast< long >(val3);
13912 {
13913 PyThreadState* __tstate = wxPyBeginAllowThreads();
13914 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13915 wxPyEndAllowThreads(__tstate);
13916 if (PyErr_Occurred()) SWIG_fail;
13917 }
13918 resultobj = SWIG_Py_Void();
13919 {
13920 if (temp1)
13921 delete arg1;
13922 }
13923 return resultobj;
13924 fail:
13925 {
13926 if (temp1)
13927 delete arg1;
13928 }
13929 return NULL;
13930 }
13931
13932
13933 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13934 PyObject *resultobj = 0;
13935 wxString *arg1 = 0 ;
13936 PyObject *arg2 = (PyObject *) 0 ;
13937 bool temp1 = false ;
13938 PyObject * obj0 = 0 ;
13939 PyObject * obj1 = 0 ;
13940 char * kwnames[] = {
13941 (char *) "filename",(char *) "data", NULL
13942 };
13943
13944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13945 {
13946 arg1 = wxString_in_helper(obj0);
13947 if (arg1 == NULL) SWIG_fail;
13948 temp1 = true;
13949 }
13950 arg2 = obj1;
13951 {
13952 PyThreadState* __tstate = wxPyBeginAllowThreads();
13953 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13954 wxPyEndAllowThreads(__tstate);
13955 if (PyErr_Occurred()) SWIG_fail;
13956 }
13957 resultobj = SWIG_Py_Void();
13958 {
13959 if (temp1)
13960 delete arg1;
13961 }
13962 return resultobj;
13963 fail:
13964 {
13965 if (temp1)
13966 delete arg1;
13967 }
13968 return NULL;
13969 }
13970
13971
13972 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13973 PyObject *resultobj = 0;
13974 wxMemoryFSHandler *result = 0 ;
13975
13976 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13977 {
13978 PyThreadState* __tstate = wxPyBeginAllowThreads();
13979 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13980 wxPyEndAllowThreads(__tstate);
13981 if (PyErr_Occurred()) SWIG_fail;
13982 }
13983 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13984 return resultobj;
13985 fail:
13986 return NULL;
13987 }
13988
13989
13990 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13991 PyObject *resultobj = 0;
13992 wxString *arg1 = 0 ;
13993 bool temp1 = false ;
13994 PyObject * obj0 = 0 ;
13995 char * kwnames[] = {
13996 (char *) "filename", NULL
13997 };
13998
13999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14000 {
14001 arg1 = wxString_in_helper(obj0);
14002 if (arg1 == NULL) SWIG_fail;
14003 temp1 = true;
14004 }
14005 {
14006 PyThreadState* __tstate = wxPyBeginAllowThreads();
14007 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 resultobj = SWIG_Py_Void();
14012 {
14013 if (temp1)
14014 delete arg1;
14015 }
14016 return resultobj;
14017 fail:
14018 {
14019 if (temp1)
14020 delete arg1;
14021 }
14022 return NULL;
14023 }
14024
14025
14026 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14027 PyObject *resultobj = 0;
14028 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14029 wxString *arg2 = 0 ;
14030 bool result;
14031 void *argp1 = 0 ;
14032 int res1 = 0 ;
14033 bool temp2 = false ;
14034 PyObject * obj0 = 0 ;
14035 PyObject * obj1 = 0 ;
14036 char * kwnames[] = {
14037 (char *) "self",(char *) "location", NULL
14038 };
14039
14040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14042 if (!SWIG_IsOK(res1)) {
14043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14044 }
14045 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14046 {
14047 arg2 = wxString_in_helper(obj1);
14048 if (arg2 == NULL) SWIG_fail;
14049 temp2 = true;
14050 }
14051 {
14052 PyThreadState* __tstate = wxPyBeginAllowThreads();
14053 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14059 }
14060 {
14061 if (temp2)
14062 delete arg2;
14063 }
14064 return resultobj;
14065 fail:
14066 {
14067 if (temp2)
14068 delete arg2;
14069 }
14070 return NULL;
14071 }
14072
14073
14074 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14075 PyObject *resultobj = 0;
14076 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14077 wxFileSystem *arg2 = 0 ;
14078 wxString *arg3 = 0 ;
14079 wxFSFile *result = 0 ;
14080 void *argp1 = 0 ;
14081 int res1 = 0 ;
14082 void *argp2 = 0 ;
14083 int res2 = 0 ;
14084 bool temp3 = false ;
14085 PyObject * obj0 = 0 ;
14086 PyObject * obj1 = 0 ;
14087 PyObject * obj2 = 0 ;
14088 char * kwnames[] = {
14089 (char *) "self",(char *) "fs",(char *) "location", NULL
14090 };
14091
14092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14094 if (!SWIG_IsOK(res1)) {
14095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14096 }
14097 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14098 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14099 if (!SWIG_IsOK(res2)) {
14100 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14101 }
14102 if (!argp2) {
14103 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14104 }
14105 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14106 {
14107 arg3 = wxString_in_helper(obj2);
14108 if (arg3 == NULL) SWIG_fail;
14109 temp3 = true;
14110 }
14111 {
14112 PyThreadState* __tstate = wxPyBeginAllowThreads();
14113 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 {
14118 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14119 }
14120 {
14121 if (temp3)
14122 delete arg3;
14123 }
14124 return resultobj;
14125 fail:
14126 {
14127 if (temp3)
14128 delete arg3;
14129 }
14130 return NULL;
14131 }
14132
14133
14134 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14135 PyObject *resultobj = 0;
14136 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14137 wxString *arg2 = 0 ;
14138 int arg3 = (int) 0 ;
14139 wxString result;
14140 void *argp1 = 0 ;
14141 int res1 = 0 ;
14142 bool temp2 = false ;
14143 int val3 ;
14144 int ecode3 = 0 ;
14145 PyObject * obj0 = 0 ;
14146 PyObject * obj1 = 0 ;
14147 PyObject * obj2 = 0 ;
14148 char * kwnames[] = {
14149 (char *) "self",(char *) "spec",(char *) "flags", NULL
14150 };
14151
14152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14154 if (!SWIG_IsOK(res1)) {
14155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14156 }
14157 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14158 {
14159 arg2 = wxString_in_helper(obj1);
14160 if (arg2 == NULL) SWIG_fail;
14161 temp2 = true;
14162 }
14163 if (obj2) {
14164 ecode3 = SWIG_AsVal_int(obj2, &val3);
14165 if (!SWIG_IsOK(ecode3)) {
14166 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14167 }
14168 arg3 = static_cast< int >(val3);
14169 }
14170 {
14171 PyThreadState* __tstate = wxPyBeginAllowThreads();
14172 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 {
14177 #if wxUSE_UNICODE
14178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14179 #else
14180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14181 #endif
14182 }
14183 {
14184 if (temp2)
14185 delete arg2;
14186 }
14187 return resultobj;
14188 fail:
14189 {
14190 if (temp2)
14191 delete arg2;
14192 }
14193 return NULL;
14194 }
14195
14196
14197 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14198 PyObject *resultobj = 0;
14199 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14200 wxString result;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 PyObject *swig_obj[1] ;
14204
14205 if (!args) SWIG_fail;
14206 swig_obj[0] = args;
14207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14208 if (!SWIG_IsOK(res1)) {
14209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14210 }
14211 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14212 {
14213 PyThreadState* __tstate = wxPyBeginAllowThreads();
14214 result = (arg1)->FindNext();
14215 wxPyEndAllowThreads(__tstate);
14216 if (PyErr_Occurred()) SWIG_fail;
14217 }
14218 {
14219 #if wxUSE_UNICODE
14220 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14221 #else
14222 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14223 #endif
14224 }
14225 return resultobj;
14226 fail:
14227 return NULL;
14228 }
14229
14230
14231 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14232 PyObject *obj;
14233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14234 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14235 return SWIG_Py_Void();
14236 }
14237
14238 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14239 return SWIG_Python_InitShadowInstance(args);
14240 }
14241
14242 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14243 PyObject *resultobj = 0;
14244 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14245 wxString result;
14246 void *argp1 = 0 ;
14247 int res1 = 0 ;
14248 PyObject *swig_obj[1] ;
14249
14250 if (!args) SWIG_fail;
14251 swig_obj[0] = args;
14252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14253 if (!SWIG_IsOK(res1)) {
14254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14255 }
14256 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14257 {
14258 PyThreadState* __tstate = wxPyBeginAllowThreads();
14259 result = (arg1)->GetName();
14260 wxPyEndAllowThreads(__tstate);
14261 if (PyErr_Occurred()) SWIG_fail;
14262 }
14263 {
14264 #if wxUSE_UNICODE
14265 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14266 #else
14267 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14268 #endif
14269 }
14270 return resultobj;
14271 fail:
14272 return NULL;
14273 }
14274
14275
14276 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14277 PyObject *resultobj = 0;
14278 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14279 wxString result;
14280 void *argp1 = 0 ;
14281 int res1 = 0 ;
14282 PyObject *swig_obj[1] ;
14283
14284 if (!args) SWIG_fail;
14285 swig_obj[0] = args;
14286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14287 if (!SWIG_IsOK(res1)) {
14288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14289 }
14290 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14291 {
14292 PyThreadState* __tstate = wxPyBeginAllowThreads();
14293 result = (arg1)->GetExtension();
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 {
14298 #if wxUSE_UNICODE
14299 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14300 #else
14301 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14302 #endif
14303 }
14304 return resultobj;
14305 fail:
14306 return NULL;
14307 }
14308
14309
14310 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14311 PyObject *resultobj = 0;
14312 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14313 long result;
14314 void *argp1 = 0 ;
14315 int res1 = 0 ;
14316 PyObject *swig_obj[1] ;
14317
14318 if (!args) SWIG_fail;
14319 swig_obj[0] = args;
14320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14321 if (!SWIG_IsOK(res1)) {
14322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14323 }
14324 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (long)(arg1)->GetType();
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 resultobj = SWIG_From_long(static_cast< long >(result));
14332 return resultobj;
14333 fail:
14334 return NULL;
14335 }
14336
14337
14338 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14339 PyObject *resultobj = 0;
14340 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14341 wxString result;
14342 void *argp1 = 0 ;
14343 int res1 = 0 ;
14344 PyObject *swig_obj[1] ;
14345
14346 if (!args) SWIG_fail;
14347 swig_obj[0] = args;
14348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14349 if (!SWIG_IsOK(res1)) {
14350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14351 }
14352 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14353 {
14354 PyThreadState* __tstate = wxPyBeginAllowThreads();
14355 result = (arg1)->GetMimeType();
14356 wxPyEndAllowThreads(__tstate);
14357 if (PyErr_Occurred()) SWIG_fail;
14358 }
14359 {
14360 #if wxUSE_UNICODE
14361 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14362 #else
14363 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14364 #endif
14365 }
14366 return resultobj;
14367 fail:
14368 return NULL;
14369 }
14370
14371
14372 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14373 PyObject *resultobj = 0;
14374 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14375 wxString *arg2 = 0 ;
14376 bool result;
14377 void *argp1 = 0 ;
14378 int res1 = 0 ;
14379 bool temp2 = false ;
14380 PyObject * obj0 = 0 ;
14381 PyObject * obj1 = 0 ;
14382 char * kwnames[] = {
14383 (char *) "self",(char *) "name", NULL
14384 };
14385
14386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14388 if (!SWIG_IsOK(res1)) {
14389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14390 }
14391 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14392 {
14393 arg2 = wxString_in_helper(obj1);
14394 if (arg2 == NULL) SWIG_fail;
14395 temp2 = true;
14396 }
14397 {
14398 PyThreadState* __tstate = wxPyBeginAllowThreads();
14399 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14400 wxPyEndAllowThreads(__tstate);
14401 if (PyErr_Occurred()) SWIG_fail;
14402 }
14403 {
14404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14405 }
14406 {
14407 if (temp2)
14408 delete arg2;
14409 }
14410 return resultobj;
14411 fail:
14412 {
14413 if (temp2)
14414 delete arg2;
14415 }
14416 return NULL;
14417 }
14418
14419
14420 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14421 PyObject *resultobj = 0;
14422 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14423 wxInputStream *arg2 = 0 ;
14424 bool result;
14425 void *argp1 = 0 ;
14426 int res1 = 0 ;
14427 wxPyInputStream *temp2 ;
14428 bool created2 ;
14429 PyObject * obj0 = 0 ;
14430 PyObject * obj1 = 0 ;
14431 char * kwnames[] = {
14432 (char *) "self",(char *) "stream", NULL
14433 };
14434
14435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14437 if (!SWIG_IsOK(res1)) {
14438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14439 }
14440 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14441 {
14442 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14443 arg2 = temp2->m_wxis;
14444 created2 = false;
14445 } else {
14446 PyErr_Clear(); // clear the failure of the wxPyConvert above
14447 arg2 = wxPyCBInputStream_create(obj1, false);
14448 if (arg2 == NULL) {
14449 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14450 SWIG_fail;
14451 }
14452 created2 = true;
14453 }
14454 }
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 result = (bool)(arg1)->CanRead(*arg2);
14458 wxPyEndAllowThreads(__tstate);
14459 if (PyErr_Occurred()) SWIG_fail;
14460 }
14461 {
14462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14463 }
14464 {
14465 if (created2) delete arg2;
14466 }
14467 return resultobj;
14468 fail:
14469 {
14470 if (created2) delete arg2;
14471 }
14472 return NULL;
14473 }
14474
14475
14476 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14477 PyObject *resultobj = 0;
14478 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14479 wxString *arg2 = 0 ;
14480 void *argp1 = 0 ;
14481 int res1 = 0 ;
14482 bool temp2 = false ;
14483 PyObject * obj0 = 0 ;
14484 PyObject * obj1 = 0 ;
14485 char * kwnames[] = {
14486 (char *) "self",(char *) "name", NULL
14487 };
14488
14489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14491 if (!SWIG_IsOK(res1)) {
14492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14493 }
14494 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14495 {
14496 arg2 = wxString_in_helper(obj1);
14497 if (arg2 == NULL) SWIG_fail;
14498 temp2 = true;
14499 }
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 (arg1)->SetName((wxString const &)*arg2);
14503 wxPyEndAllowThreads(__tstate);
14504 if (PyErr_Occurred()) SWIG_fail;
14505 }
14506 resultobj = SWIG_Py_Void();
14507 {
14508 if (temp2)
14509 delete arg2;
14510 }
14511 return resultobj;
14512 fail:
14513 {
14514 if (temp2)
14515 delete arg2;
14516 }
14517 return NULL;
14518 }
14519
14520
14521 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14522 PyObject *resultobj = 0;
14523 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14524 wxString *arg2 = 0 ;
14525 void *argp1 = 0 ;
14526 int res1 = 0 ;
14527 bool temp2 = false ;
14528 PyObject * obj0 = 0 ;
14529 PyObject * obj1 = 0 ;
14530 char * kwnames[] = {
14531 (char *) "self",(char *) "extension", NULL
14532 };
14533
14534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14536 if (!SWIG_IsOK(res1)) {
14537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14538 }
14539 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14540 {
14541 arg2 = wxString_in_helper(obj1);
14542 if (arg2 == NULL) SWIG_fail;
14543 temp2 = true;
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 (arg1)->SetExtension((wxString const &)*arg2);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 resultobj = SWIG_Py_Void();
14552 {
14553 if (temp2)
14554 delete arg2;
14555 }
14556 return resultobj;
14557 fail:
14558 {
14559 if (temp2)
14560 delete arg2;
14561 }
14562 return NULL;
14563 }
14564
14565
14566 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14567 PyObject *resultobj = 0;
14568 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14569 long arg2 ;
14570 void *argp1 = 0 ;
14571 int res1 = 0 ;
14572 long val2 ;
14573 int ecode2 = 0 ;
14574 PyObject * obj0 = 0 ;
14575 PyObject * obj1 = 0 ;
14576 char * kwnames[] = {
14577 (char *) "self",(char *) "type", NULL
14578 };
14579
14580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14582 if (!SWIG_IsOK(res1)) {
14583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14584 }
14585 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14586 ecode2 = SWIG_AsVal_long(obj1, &val2);
14587 if (!SWIG_IsOK(ecode2)) {
14588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14589 }
14590 arg2 = static_cast< long >(val2);
14591 {
14592 PyThreadState* __tstate = wxPyBeginAllowThreads();
14593 (arg1)->SetType(arg2);
14594 wxPyEndAllowThreads(__tstate);
14595 if (PyErr_Occurred()) SWIG_fail;
14596 }
14597 resultobj = SWIG_Py_Void();
14598 return resultobj;
14599 fail:
14600 return NULL;
14601 }
14602
14603
14604 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14605 PyObject *resultobj = 0;
14606 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14607 wxString *arg2 = 0 ;
14608 void *argp1 = 0 ;
14609 int res1 = 0 ;
14610 bool temp2 = false ;
14611 PyObject * obj0 = 0 ;
14612 PyObject * obj1 = 0 ;
14613 char * kwnames[] = {
14614 (char *) "self",(char *) "mimetype", NULL
14615 };
14616
14617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14619 if (!SWIG_IsOK(res1)) {
14620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14621 }
14622 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14623 {
14624 arg2 = wxString_in_helper(obj1);
14625 if (arg2 == NULL) SWIG_fail;
14626 temp2 = true;
14627 }
14628 {
14629 PyThreadState* __tstate = wxPyBeginAllowThreads();
14630 (arg1)->SetMimeType((wxString const &)*arg2);
14631 wxPyEndAllowThreads(__tstate);
14632 if (PyErr_Occurred()) SWIG_fail;
14633 }
14634 resultobj = SWIG_Py_Void();
14635 {
14636 if (temp2)
14637 delete arg2;
14638 }
14639 return resultobj;
14640 fail:
14641 {
14642 if (temp2)
14643 delete arg2;
14644 }
14645 return NULL;
14646 }
14647
14648
14649 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14650 PyObject *obj;
14651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14652 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14653 return SWIG_Py_Void();
14654 }
14655
14656 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14657 PyObject *resultobj = 0;
14658 wxPyImageHandler *result = 0 ;
14659
14660 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14661 {
14662 PyThreadState* __tstate = wxPyBeginAllowThreads();
14663 result = (wxPyImageHandler *)new wxPyImageHandler();
14664 wxPyEndAllowThreads(__tstate);
14665 if (PyErr_Occurred()) SWIG_fail;
14666 }
14667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj = 0;
14676 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14677 PyObject *arg2 = (PyObject *) 0 ;
14678 void *argp1 = 0 ;
14679 int res1 = 0 ;
14680 PyObject * obj0 = 0 ;
14681 PyObject * obj1 = 0 ;
14682 char * kwnames[] = {
14683 (char *) "self",(char *) "self", NULL
14684 };
14685
14686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14688 if (!SWIG_IsOK(res1)) {
14689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14690 }
14691 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14692 arg2 = obj1;
14693 {
14694 PyThreadState* __tstate = wxPyBeginAllowThreads();
14695 (arg1)->_SetSelf(arg2);
14696 wxPyEndAllowThreads(__tstate);
14697 if (PyErr_Occurred()) SWIG_fail;
14698 }
14699 resultobj = SWIG_Py_Void();
14700 return resultobj;
14701 fail:
14702 return NULL;
14703 }
14704
14705
14706 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14707 PyObject *obj;
14708 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14709 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14710 return SWIG_Py_Void();
14711 }
14712
14713 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14714 return SWIG_Python_InitShadowInstance(args);
14715 }
14716
14717 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14718 PyObject *resultobj = 0;
14719 wxImageHistogram *result = 0 ;
14720
14721 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14722 {
14723 PyThreadState* __tstate = wxPyBeginAllowThreads();
14724 result = (wxImageHistogram *)new wxImageHistogram();
14725 wxPyEndAllowThreads(__tstate);
14726 if (PyErr_Occurred()) SWIG_fail;
14727 }
14728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14729 return resultobj;
14730 fail:
14731 return NULL;
14732 }
14733
14734
14735 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14736 PyObject *resultobj = 0;
14737 byte arg1 ;
14738 byte arg2 ;
14739 byte arg3 ;
14740 unsigned long result;
14741 unsigned char val1 ;
14742 int ecode1 = 0 ;
14743 unsigned char val2 ;
14744 int ecode2 = 0 ;
14745 unsigned char val3 ;
14746 int ecode3 = 0 ;
14747 PyObject * obj0 = 0 ;
14748 PyObject * obj1 = 0 ;
14749 PyObject * obj2 = 0 ;
14750 char * kwnames[] = {
14751 (char *) "r",(char *) "g",(char *) "b", NULL
14752 };
14753
14754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14755 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14756 if (!SWIG_IsOK(ecode1)) {
14757 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14758 }
14759 arg1 = static_cast< byte >(val1);
14760 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14761 if (!SWIG_IsOK(ecode2)) {
14762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14763 }
14764 arg2 = static_cast< byte >(val2);
14765 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14766 if (!SWIG_IsOK(ecode3)) {
14767 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14768 }
14769 arg3 = static_cast< byte >(val3);
14770 {
14771 PyThreadState* __tstate = wxPyBeginAllowThreads();
14772 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14773 wxPyEndAllowThreads(__tstate);
14774 if (PyErr_Occurred()) SWIG_fail;
14775 }
14776 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14777 return resultobj;
14778 fail:
14779 return NULL;
14780 }
14781
14782
14783 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14784 PyObject *resultobj = 0;
14785 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14786 byte *arg2 = (byte *) 0 ;
14787 byte *arg3 = (byte *) 0 ;
14788 byte *arg4 = (byte *) 0 ;
14789 byte arg5 = (byte) 1 ;
14790 byte arg6 = (byte) 0 ;
14791 byte arg7 = (byte) 0 ;
14792 bool result;
14793 void *argp1 = 0 ;
14794 int res1 = 0 ;
14795 byte temp2 ;
14796 int res2 = SWIG_TMPOBJ ;
14797 byte temp3 ;
14798 int res3 = SWIG_TMPOBJ ;
14799 byte temp4 ;
14800 int res4 = SWIG_TMPOBJ ;
14801 unsigned char val5 ;
14802 int ecode5 = 0 ;
14803 unsigned char val6 ;
14804 int ecode6 = 0 ;
14805 unsigned char val7 ;
14806 int ecode7 = 0 ;
14807 PyObject * obj0 = 0 ;
14808 PyObject * obj1 = 0 ;
14809 PyObject * obj2 = 0 ;
14810 PyObject * obj3 = 0 ;
14811 char * kwnames[] = {
14812 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14813 };
14814
14815 arg2 = &temp2;
14816 arg3 = &temp3;
14817 arg4 = &temp4;
14818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14820 if (!SWIG_IsOK(res1)) {
14821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14822 }
14823 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14824 if (obj1) {
14825 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14826 if (!SWIG_IsOK(ecode5)) {
14827 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14828 }
14829 arg5 = static_cast< byte >(val5);
14830 }
14831 if (obj2) {
14832 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14833 if (!SWIG_IsOK(ecode6)) {
14834 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14835 }
14836 arg6 = static_cast< byte >(val6);
14837 }
14838 if (obj3) {
14839 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14840 if (!SWIG_IsOK(ecode7)) {
14841 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14842 }
14843 arg7 = static_cast< byte >(val7);
14844 }
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 if (SWIG_IsTmpObj(res2)) {
14855 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14856 } else {
14857 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14858 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14859 }
14860 if (SWIG_IsTmpObj(res3)) {
14861 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14862 } else {
14863 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14864 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14865 }
14866 if (SWIG_IsTmpObj(res4)) {
14867 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14868 } else {
14869 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14870 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14871 }
14872 return resultobj;
14873 fail:
14874 return NULL;
14875 }
14876
14877
14878 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14879 PyObject *resultobj = 0;
14880 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14881 unsigned long arg2 ;
14882 unsigned long result;
14883 void *argp1 = 0 ;
14884 int res1 = 0 ;
14885 unsigned long val2 ;
14886 int ecode2 = 0 ;
14887 PyObject * obj0 = 0 ;
14888 PyObject * obj1 = 0 ;
14889 char * kwnames[] = {
14890 (char *) "self",(char *) "key", NULL
14891 };
14892
14893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14895 if (!SWIG_IsOK(res1)) {
14896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14897 }
14898 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14899 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14900 if (!SWIG_IsOK(ecode2)) {
14901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14902 }
14903 arg2 = static_cast< unsigned long >(val2);
14904 {
14905 PyThreadState* __tstate = wxPyBeginAllowThreads();
14906 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14907 wxPyEndAllowThreads(__tstate);
14908 if (PyErr_Occurred()) SWIG_fail;
14909 }
14910 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14911 return resultobj;
14912 fail:
14913 return NULL;
14914 }
14915
14916
14917 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14918 PyObject *resultobj = 0;
14919 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14920 byte arg2 ;
14921 byte arg3 ;
14922 byte arg4 ;
14923 unsigned long result;
14924 void *argp1 = 0 ;
14925 int res1 = 0 ;
14926 unsigned char val2 ;
14927 int ecode2 = 0 ;
14928 unsigned char val3 ;
14929 int ecode3 = 0 ;
14930 unsigned char val4 ;
14931 int ecode4 = 0 ;
14932 PyObject * obj0 = 0 ;
14933 PyObject * obj1 = 0 ;
14934 PyObject * obj2 = 0 ;
14935 PyObject * obj3 = 0 ;
14936 char * kwnames[] = {
14937 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14938 };
14939
14940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14942 if (!SWIG_IsOK(res1)) {
14943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14944 }
14945 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14946 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14947 if (!SWIG_IsOK(ecode2)) {
14948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14949 }
14950 arg2 = static_cast< byte >(val2);
14951 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14952 if (!SWIG_IsOK(ecode3)) {
14953 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14954 }
14955 arg3 = static_cast< byte >(val3);
14956 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14957 if (!SWIG_IsOK(ecode4)) {
14958 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14959 }
14960 arg4 = static_cast< byte >(val4);
14961 {
14962 PyThreadState* __tstate = wxPyBeginAllowThreads();
14963 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14964 wxPyEndAllowThreads(__tstate);
14965 if (PyErr_Occurred()) SWIG_fail;
14966 }
14967 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14968 return resultobj;
14969 fail:
14970 return NULL;
14971 }
14972
14973
14974 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14975 PyObject *resultobj = 0;
14976 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14977 wxColour *arg2 = 0 ;
14978 unsigned long result;
14979 void *argp1 = 0 ;
14980 int res1 = 0 ;
14981 wxColour temp2 ;
14982 PyObject * obj0 = 0 ;
14983 PyObject * obj1 = 0 ;
14984 char * kwnames[] = {
14985 (char *) "self",(char *) "colour", NULL
14986 };
14987
14988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
14989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14990 if (!SWIG_IsOK(res1)) {
14991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14992 }
14993 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14994 {
14995 arg2 = &temp2;
14996 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14997 }
14998 {
14999 PyThreadState* __tstate = wxPyBeginAllowThreads();
15000 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15001 wxPyEndAllowThreads(__tstate);
15002 if (PyErr_Occurred()) SWIG_fail;
15003 }
15004 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15005 return resultobj;
15006 fail:
15007 return NULL;
15008 }
15009
15010
15011 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15012 PyObject *obj;
15013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15014 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15015 return SWIG_Py_Void();
15016 }
15017
15018 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15019 return SWIG_Python_InitShadowInstance(args);
15020 }
15021
15022 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15023 PyObject *resultobj = 0;
15024 byte arg1 = (byte) 0 ;
15025 byte arg2 = (byte) 0 ;
15026 byte arg3 = (byte) 0 ;
15027 wxImage_RGBValue *result = 0 ;
15028 unsigned char val1 ;
15029 int ecode1 = 0 ;
15030 unsigned char val2 ;
15031 int ecode2 = 0 ;
15032 unsigned char val3 ;
15033 int ecode3 = 0 ;
15034 PyObject * obj0 = 0 ;
15035 PyObject * obj1 = 0 ;
15036 PyObject * obj2 = 0 ;
15037 char * kwnames[] = {
15038 (char *) "r",(char *) "g",(char *) "b", NULL
15039 };
15040
15041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15042 if (obj0) {
15043 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15044 if (!SWIG_IsOK(ecode1)) {
15045 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15046 }
15047 arg1 = static_cast< byte >(val1);
15048 }
15049 if (obj1) {
15050 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15051 if (!SWIG_IsOK(ecode2)) {
15052 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15053 }
15054 arg2 = static_cast< byte >(val2);
15055 }
15056 if (obj2) {
15057 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15058 if (!SWIG_IsOK(ecode3)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15060 }
15061 arg3 = static_cast< byte >(val3);
15062 }
15063 {
15064 PyThreadState* __tstate = wxPyBeginAllowThreads();
15065 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15066 wxPyEndAllowThreads(__tstate);
15067 if (PyErr_Occurred()) SWIG_fail;
15068 }
15069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15070 return resultobj;
15071 fail:
15072 return NULL;
15073 }
15074
15075
15076 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15077 PyObject *resultobj = 0;
15078 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15079 byte arg2 ;
15080 void *argp1 = 0 ;
15081 int res1 = 0 ;
15082 unsigned char val2 ;
15083 int ecode2 = 0 ;
15084 PyObject *swig_obj[2] ;
15085
15086 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15088 if (!SWIG_IsOK(res1)) {
15089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15090 }
15091 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15092 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15093 if (!SWIG_IsOK(ecode2)) {
15094 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15095 }
15096 arg2 = static_cast< byte >(val2);
15097 if (arg1) (arg1)->red = arg2;
15098
15099 resultobj = SWIG_Py_Void();
15100 return resultobj;
15101 fail:
15102 return NULL;
15103 }
15104
15105
15106 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15107 PyObject *resultobj = 0;
15108 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15109 byte result;
15110 void *argp1 = 0 ;
15111 int res1 = 0 ;
15112 PyObject *swig_obj[1] ;
15113
15114 if (!args) SWIG_fail;
15115 swig_obj[0] = args;
15116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15117 if (!SWIG_IsOK(res1)) {
15118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15119 }
15120 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15121 result = (byte) ((arg1)->red);
15122 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15123 return resultobj;
15124 fail:
15125 return NULL;
15126 }
15127
15128
15129 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15130 PyObject *resultobj = 0;
15131 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15132 byte arg2 ;
15133 void *argp1 = 0 ;
15134 int res1 = 0 ;
15135 unsigned char val2 ;
15136 int ecode2 = 0 ;
15137 PyObject *swig_obj[2] ;
15138
15139 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15141 if (!SWIG_IsOK(res1)) {
15142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15143 }
15144 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15145 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15146 if (!SWIG_IsOK(ecode2)) {
15147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15148 }
15149 arg2 = static_cast< byte >(val2);
15150 if (arg1) (arg1)->green = arg2;
15151
15152 resultobj = SWIG_Py_Void();
15153 return resultobj;
15154 fail:
15155 return NULL;
15156 }
15157
15158
15159 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15160 PyObject *resultobj = 0;
15161 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15162 byte result;
15163 void *argp1 = 0 ;
15164 int res1 = 0 ;
15165 PyObject *swig_obj[1] ;
15166
15167 if (!args) SWIG_fail;
15168 swig_obj[0] = args;
15169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15170 if (!SWIG_IsOK(res1)) {
15171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15172 }
15173 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15174 result = (byte) ((arg1)->green);
15175 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15176 return resultobj;
15177 fail:
15178 return NULL;
15179 }
15180
15181
15182 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15183 PyObject *resultobj = 0;
15184 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15185 byte arg2 ;
15186 void *argp1 = 0 ;
15187 int res1 = 0 ;
15188 unsigned char val2 ;
15189 int ecode2 = 0 ;
15190 PyObject *swig_obj[2] ;
15191
15192 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15194 if (!SWIG_IsOK(res1)) {
15195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15196 }
15197 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15198 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15199 if (!SWIG_IsOK(ecode2)) {
15200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15201 }
15202 arg2 = static_cast< byte >(val2);
15203 if (arg1) (arg1)->blue = arg2;
15204
15205 resultobj = SWIG_Py_Void();
15206 return resultobj;
15207 fail:
15208 return NULL;
15209 }
15210
15211
15212 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15213 PyObject *resultobj = 0;
15214 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15215 byte result;
15216 void *argp1 = 0 ;
15217 int res1 = 0 ;
15218 PyObject *swig_obj[1] ;
15219
15220 if (!args) SWIG_fail;
15221 swig_obj[0] = args;
15222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15223 if (!SWIG_IsOK(res1)) {
15224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15225 }
15226 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15227 result = (byte) ((arg1)->blue);
15228 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15236 PyObject *obj;
15237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15238 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15239 return SWIG_Py_Void();
15240 }
15241
15242 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15243 return SWIG_Python_InitShadowInstance(args);
15244 }
15245
15246 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15247 PyObject *resultobj = 0;
15248 double arg1 = (double) 0.0 ;
15249 double arg2 = (double) 0.0 ;
15250 double arg3 = (double) 0.0 ;
15251 wxImage_HSVValue *result = 0 ;
15252 double val1 ;
15253 int ecode1 = 0 ;
15254 double val2 ;
15255 int ecode2 = 0 ;
15256 double val3 ;
15257 int ecode3 = 0 ;
15258 PyObject * obj0 = 0 ;
15259 PyObject * obj1 = 0 ;
15260 PyObject * obj2 = 0 ;
15261 char * kwnames[] = {
15262 (char *) "h",(char *) "s",(char *) "v", NULL
15263 };
15264
15265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15266 if (obj0) {
15267 ecode1 = SWIG_AsVal_double(obj0, &val1);
15268 if (!SWIG_IsOK(ecode1)) {
15269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15270 }
15271 arg1 = static_cast< double >(val1);
15272 }
15273 if (obj1) {
15274 ecode2 = SWIG_AsVal_double(obj1, &val2);
15275 if (!SWIG_IsOK(ecode2)) {
15276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15277 }
15278 arg2 = static_cast< double >(val2);
15279 }
15280 if (obj2) {
15281 ecode3 = SWIG_AsVal_double(obj2, &val3);
15282 if (!SWIG_IsOK(ecode3)) {
15283 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15284 }
15285 arg3 = static_cast< double >(val3);
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15290 wxPyEndAllowThreads(__tstate);
15291 if (PyErr_Occurred()) SWIG_fail;
15292 }
15293 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15294 return resultobj;
15295 fail:
15296 return NULL;
15297 }
15298
15299
15300 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15301 PyObject *resultobj = 0;
15302 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15303 double arg2 ;
15304 void *argp1 = 0 ;
15305 int res1 = 0 ;
15306 double val2 ;
15307 int ecode2 = 0 ;
15308 PyObject *swig_obj[2] ;
15309
15310 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15312 if (!SWIG_IsOK(res1)) {
15313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15314 }
15315 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15316 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15317 if (!SWIG_IsOK(ecode2)) {
15318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15319 }
15320 arg2 = static_cast< double >(val2);
15321 if (arg1) (arg1)->hue = arg2;
15322
15323 resultobj = SWIG_Py_Void();
15324 return resultobj;
15325 fail:
15326 return NULL;
15327 }
15328
15329
15330 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15331 PyObject *resultobj = 0;
15332 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15333 double result;
15334 void *argp1 = 0 ;
15335 int res1 = 0 ;
15336 PyObject *swig_obj[1] ;
15337
15338 if (!args) SWIG_fail;
15339 swig_obj[0] = args;
15340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15341 if (!SWIG_IsOK(res1)) {
15342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15343 }
15344 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15345 result = (double) ((arg1)->hue);
15346 resultobj = SWIG_From_double(static_cast< double >(result));
15347 return resultobj;
15348 fail:
15349 return NULL;
15350 }
15351
15352
15353 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15354 PyObject *resultobj = 0;
15355 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15356 double arg2 ;
15357 void *argp1 = 0 ;
15358 int res1 = 0 ;
15359 double val2 ;
15360 int ecode2 = 0 ;
15361 PyObject *swig_obj[2] ;
15362
15363 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15365 if (!SWIG_IsOK(res1)) {
15366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15367 }
15368 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15369 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15370 if (!SWIG_IsOK(ecode2)) {
15371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15372 }
15373 arg2 = static_cast< double >(val2);
15374 if (arg1) (arg1)->saturation = arg2;
15375
15376 resultobj = SWIG_Py_Void();
15377 return resultobj;
15378 fail:
15379 return NULL;
15380 }
15381
15382
15383 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15384 PyObject *resultobj = 0;
15385 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15386 double result;
15387 void *argp1 = 0 ;
15388 int res1 = 0 ;
15389 PyObject *swig_obj[1] ;
15390
15391 if (!args) SWIG_fail;
15392 swig_obj[0] = args;
15393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15394 if (!SWIG_IsOK(res1)) {
15395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15396 }
15397 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15398 result = (double) ((arg1)->saturation);
15399 resultobj = SWIG_From_double(static_cast< double >(result));
15400 return resultobj;
15401 fail:
15402 return NULL;
15403 }
15404
15405
15406 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15407 PyObject *resultobj = 0;
15408 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15409 double arg2 ;
15410 void *argp1 = 0 ;
15411 int res1 = 0 ;
15412 double val2 ;
15413 int ecode2 = 0 ;
15414 PyObject *swig_obj[2] ;
15415
15416 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15418 if (!SWIG_IsOK(res1)) {
15419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15420 }
15421 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15422 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15423 if (!SWIG_IsOK(ecode2)) {
15424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15425 }
15426 arg2 = static_cast< double >(val2);
15427 if (arg1) (arg1)->value = arg2;
15428
15429 resultobj = SWIG_Py_Void();
15430 return resultobj;
15431 fail:
15432 return NULL;
15433 }
15434
15435
15436 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15437 PyObject *resultobj = 0;
15438 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15439 double result;
15440 void *argp1 = 0 ;
15441 int res1 = 0 ;
15442 PyObject *swig_obj[1] ;
15443
15444 if (!args) SWIG_fail;
15445 swig_obj[0] = args;
15446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15447 if (!SWIG_IsOK(res1)) {
15448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15449 }
15450 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15451 result = (double) ((arg1)->value);
15452 resultobj = SWIG_From_double(static_cast< double >(result));
15453 return resultobj;
15454 fail:
15455 return NULL;
15456 }
15457
15458
15459 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15460 PyObject *obj;
15461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15462 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15463 return SWIG_Py_Void();
15464 }
15465
15466 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15467 return SWIG_Python_InitShadowInstance(args);
15468 }
15469
15470 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15471 PyObject *resultobj = 0;
15472 wxString *arg1 = 0 ;
15473 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15474 int arg3 = (int) -1 ;
15475 wxImage *result = 0 ;
15476 bool temp1 = false ;
15477 long val2 ;
15478 int ecode2 = 0 ;
15479 int val3 ;
15480 int ecode3 = 0 ;
15481 PyObject * obj0 = 0 ;
15482 PyObject * obj1 = 0 ;
15483 PyObject * obj2 = 0 ;
15484 char * kwnames[] = {
15485 (char *) "name",(char *) "type",(char *) "index", NULL
15486 };
15487
15488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15489 {
15490 arg1 = wxString_in_helper(obj0);
15491 if (arg1 == NULL) SWIG_fail;
15492 temp1 = true;
15493 }
15494 if (obj1) {
15495 ecode2 = SWIG_AsVal_long(obj1, &val2);
15496 if (!SWIG_IsOK(ecode2)) {
15497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15498 }
15499 arg2 = static_cast< long >(val2);
15500 }
15501 if (obj2) {
15502 ecode3 = SWIG_AsVal_int(obj2, &val3);
15503 if (!SWIG_IsOK(ecode3)) {
15504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15505 }
15506 arg3 = static_cast< int >(val3);
15507 }
15508 {
15509 PyThreadState* __tstate = wxPyBeginAllowThreads();
15510 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15515 {
15516 if (temp1)
15517 delete arg1;
15518 }
15519 return resultobj;
15520 fail:
15521 {
15522 if (temp1)
15523 delete arg1;
15524 }
15525 return NULL;
15526 }
15527
15528
15529 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15530 PyObject *resultobj = 0;
15531 wxImage *arg1 = (wxImage *) 0 ;
15532 void *argp1 = 0 ;
15533 int res1 = 0 ;
15534 PyObject *swig_obj[1] ;
15535
15536 if (!args) SWIG_fail;
15537 swig_obj[0] = args;
15538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15539 if (!SWIG_IsOK(res1)) {
15540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15541 }
15542 arg1 = reinterpret_cast< wxImage * >(argp1);
15543 {
15544 PyThreadState* __tstate = wxPyBeginAllowThreads();
15545 delete arg1;
15546
15547 wxPyEndAllowThreads(__tstate);
15548 if (PyErr_Occurred()) SWIG_fail;
15549 }
15550 resultobj = SWIG_Py_Void();
15551 return resultobj;
15552 fail:
15553 return NULL;
15554 }
15555
15556
15557 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15558 PyObject *resultobj = 0;
15559 wxString *arg1 = 0 ;
15560 wxString *arg2 = 0 ;
15561 int arg3 = (int) -1 ;
15562 wxImage *result = 0 ;
15563 bool temp1 = false ;
15564 bool temp2 = false ;
15565 int val3 ;
15566 int ecode3 = 0 ;
15567 PyObject * obj0 = 0 ;
15568 PyObject * obj1 = 0 ;
15569 PyObject * obj2 = 0 ;
15570 char * kwnames[] = {
15571 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15572 };
15573
15574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15575 {
15576 arg1 = wxString_in_helper(obj0);
15577 if (arg1 == NULL) SWIG_fail;
15578 temp1 = true;
15579 }
15580 {
15581 arg2 = wxString_in_helper(obj1);
15582 if (arg2 == NULL) SWIG_fail;
15583 temp2 = true;
15584 }
15585 if (obj2) {
15586 ecode3 = SWIG_AsVal_int(obj2, &val3);
15587 if (!SWIG_IsOK(ecode3)) {
15588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15589 }
15590 arg3 = static_cast< int >(val3);
15591 }
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15595 wxPyEndAllowThreads(__tstate);
15596 if (PyErr_Occurred()) SWIG_fail;
15597 }
15598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15599 {
15600 if (temp1)
15601 delete arg1;
15602 }
15603 {
15604 if (temp2)
15605 delete arg2;
15606 }
15607 return resultobj;
15608 fail:
15609 {
15610 if (temp1)
15611 delete arg1;
15612 }
15613 {
15614 if (temp2)
15615 delete arg2;
15616 }
15617 return NULL;
15618 }
15619
15620
15621 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15622 PyObject *resultobj = 0;
15623 wxInputStream *arg1 = 0 ;
15624 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15625 int arg3 = (int) -1 ;
15626 wxImage *result = 0 ;
15627 wxPyInputStream *temp1 ;
15628 bool created1 ;
15629 long val2 ;
15630 int ecode2 = 0 ;
15631 int val3 ;
15632 int ecode3 = 0 ;
15633 PyObject * obj0 = 0 ;
15634 PyObject * obj1 = 0 ;
15635 PyObject * obj2 = 0 ;
15636 char * kwnames[] = {
15637 (char *) "stream",(char *) "type",(char *) "index", NULL
15638 };
15639
15640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15641 {
15642 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15643 arg1 = temp1->m_wxis;
15644 created1 = false;
15645 } else {
15646 PyErr_Clear(); // clear the failure of the wxPyConvert above
15647 arg1 = wxPyCBInputStream_create(obj0, false);
15648 if (arg1 == NULL) {
15649 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15650 SWIG_fail;
15651 }
15652 created1 = true;
15653 }
15654 }
15655 if (obj1) {
15656 ecode2 = SWIG_AsVal_long(obj1, &val2);
15657 if (!SWIG_IsOK(ecode2)) {
15658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15659 }
15660 arg2 = static_cast< long >(val2);
15661 }
15662 if (obj2) {
15663 ecode3 = SWIG_AsVal_int(obj2, &val3);
15664 if (!SWIG_IsOK(ecode3)) {
15665 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15666 }
15667 arg3 = static_cast< int >(val3);
15668 }
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15672 wxPyEndAllowThreads(__tstate);
15673 if (PyErr_Occurred()) SWIG_fail;
15674 }
15675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15676 {
15677 if (created1) delete arg1;
15678 }
15679 return resultobj;
15680 fail:
15681 {
15682 if (created1) delete arg1;
15683 }
15684 return NULL;
15685 }
15686
15687
15688 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15689 PyObject *resultobj = 0;
15690 wxInputStream *arg1 = 0 ;
15691 wxString *arg2 = 0 ;
15692 int arg3 = (int) -1 ;
15693 wxImage *result = 0 ;
15694 wxPyInputStream *temp1 ;
15695 bool created1 ;
15696 bool temp2 = false ;
15697 int val3 ;
15698 int ecode3 = 0 ;
15699 PyObject * obj0 = 0 ;
15700 PyObject * obj1 = 0 ;
15701 PyObject * obj2 = 0 ;
15702 char * kwnames[] = {
15703 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15704 };
15705
15706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15707 {
15708 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15709 arg1 = temp1->m_wxis;
15710 created1 = false;
15711 } else {
15712 PyErr_Clear(); // clear the failure of the wxPyConvert above
15713 arg1 = wxPyCBInputStream_create(obj0, false);
15714 if (arg1 == NULL) {
15715 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15716 SWIG_fail;
15717 }
15718 created1 = true;
15719 }
15720 }
15721 {
15722 arg2 = wxString_in_helper(obj1);
15723 if (arg2 == NULL) SWIG_fail;
15724 temp2 = true;
15725 }
15726 if (obj2) {
15727 ecode3 = SWIG_AsVal_int(obj2, &val3);
15728 if (!SWIG_IsOK(ecode3)) {
15729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15730 }
15731 arg3 = static_cast< int >(val3);
15732 }
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15740 {
15741 if (created1) delete arg1;
15742 }
15743 {
15744 if (temp2)
15745 delete arg2;
15746 }
15747 return resultobj;
15748 fail:
15749 {
15750 if (created1) delete arg1;
15751 }
15752 {
15753 if (temp2)
15754 delete arg2;
15755 }
15756 return NULL;
15757 }
15758
15759
15760 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15761 PyObject *resultobj = 0;
15762 int arg1 = (int) 0 ;
15763 int arg2 = (int) 0 ;
15764 bool arg3 = (bool) true ;
15765 wxImage *result = 0 ;
15766 int val1 ;
15767 int ecode1 = 0 ;
15768 int val2 ;
15769 int ecode2 = 0 ;
15770 bool val3 ;
15771 int ecode3 = 0 ;
15772 PyObject * obj0 = 0 ;
15773 PyObject * obj1 = 0 ;
15774 PyObject * obj2 = 0 ;
15775 char * kwnames[] = {
15776 (char *) "width",(char *) "height",(char *) "clear", NULL
15777 };
15778
15779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15780 if (obj0) {
15781 ecode1 = SWIG_AsVal_int(obj0, &val1);
15782 if (!SWIG_IsOK(ecode1)) {
15783 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15784 }
15785 arg1 = static_cast< int >(val1);
15786 }
15787 if (obj1) {
15788 ecode2 = SWIG_AsVal_int(obj1, &val2);
15789 if (!SWIG_IsOK(ecode2)) {
15790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15791 }
15792 arg2 = static_cast< int >(val2);
15793 }
15794 if (obj2) {
15795 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15796 if (!SWIG_IsOK(ecode3)) {
15797 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15798 }
15799 arg3 = static_cast< bool >(val3);
15800 }
15801 {
15802 PyThreadState* __tstate = wxPyBeginAllowThreads();
15803 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15804 wxPyEndAllowThreads(__tstate);
15805 if (PyErr_Occurred()) SWIG_fail;
15806 }
15807 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15808 return resultobj;
15809 fail:
15810 return NULL;
15811 }
15812
15813
15814 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15815 PyObject *resultobj = 0;
15816 wxBitmap *arg1 = 0 ;
15817 wxImage *result = 0 ;
15818 void *argp1 = 0 ;
15819 int res1 = 0 ;
15820 PyObject * obj0 = 0 ;
15821 char * kwnames[] = {
15822 (char *) "bitmap", NULL
15823 };
15824
15825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15826 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15827 if (!SWIG_IsOK(res1)) {
15828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15829 }
15830 if (!argp1) {
15831 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15832 }
15833 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15834 {
15835 if (!wxPyCheckForApp()) SWIG_fail;
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 int arg1 ;
15851 int arg2 ;
15852 buffer arg3 ;
15853 int arg4 ;
15854 wxImage *result = 0 ;
15855 int val1 ;
15856 int ecode1 = 0 ;
15857 int val2 ;
15858 int ecode2 = 0 ;
15859 Py_ssize_t temp3 ;
15860 PyObject * obj0 = 0 ;
15861 PyObject * obj1 = 0 ;
15862 PyObject * obj2 = 0 ;
15863 char * kwnames[] = {
15864 (char *) "width",(char *) "height",(char *) "data", NULL
15865 };
15866
15867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15868 ecode1 = SWIG_AsVal_int(obj0, &val1);
15869 if (!SWIG_IsOK(ecode1)) {
15870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15871 }
15872 arg1 = static_cast< int >(val1);
15873 ecode2 = SWIG_AsVal_int(obj1, &val2);
15874 if (!SWIG_IsOK(ecode2)) {
15875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15876 }
15877 arg2 = static_cast< int >(val2);
15878 {
15879 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15880 arg4 = (int)temp3;
15881 }
15882 {
15883 PyThreadState* __tstate = wxPyBeginAllowThreads();
15884 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15885 wxPyEndAllowThreads(__tstate);
15886 if (PyErr_Occurred()) SWIG_fail;
15887 }
15888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15889 return resultobj;
15890 fail:
15891 return NULL;
15892 }
15893
15894
15895 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15896 PyObject *resultobj = 0;
15897 int arg1 ;
15898 int arg2 ;
15899 buffer arg3 ;
15900 int arg4 ;
15901 buffer arg5 ;
15902 int arg6 ;
15903 wxImage *result = 0 ;
15904 int val1 ;
15905 int ecode1 = 0 ;
15906 int val2 ;
15907 int ecode2 = 0 ;
15908 Py_ssize_t temp3 ;
15909 Py_ssize_t temp5 ;
15910 PyObject * obj0 = 0 ;
15911 PyObject * obj1 = 0 ;
15912 PyObject * obj2 = 0 ;
15913 PyObject * obj3 = 0 ;
15914 char * kwnames[] = {
15915 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15916 };
15917
15918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15919 ecode1 = SWIG_AsVal_int(obj0, &val1);
15920 if (!SWIG_IsOK(ecode1)) {
15921 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15922 }
15923 arg1 = static_cast< int >(val1);
15924 ecode2 = SWIG_AsVal_int(obj1, &val2);
15925 if (!SWIG_IsOK(ecode2)) {
15926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15927 }
15928 arg2 = static_cast< int >(val2);
15929 {
15930 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15931 arg4 = (int)temp3;
15932 }
15933 {
15934 if (obj3 != Py_None) {
15935 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15936 arg6 = (int)temp5;
15937 }
15938 }
15939 {
15940 PyThreadState* __tstate = wxPyBeginAllowThreads();
15941 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15942 wxPyEndAllowThreads(__tstate);
15943 if (PyErr_Occurred()) SWIG_fail;
15944 }
15945 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15946 return resultobj;
15947 fail:
15948 return NULL;
15949 }
15950
15951
15952 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15953 PyObject *resultobj = 0;
15954 wxImage *arg1 = (wxImage *) 0 ;
15955 int arg2 ;
15956 int arg3 ;
15957 bool arg4 = (bool) true ;
15958 void *argp1 = 0 ;
15959 int res1 = 0 ;
15960 int val2 ;
15961 int ecode2 = 0 ;
15962 int val3 ;
15963 int ecode3 = 0 ;
15964 bool val4 ;
15965 int ecode4 = 0 ;
15966 PyObject * obj0 = 0 ;
15967 PyObject * obj1 = 0 ;
15968 PyObject * obj2 = 0 ;
15969 PyObject * obj3 = 0 ;
15970 char * kwnames[] = {
15971 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15972 };
15973
15974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15976 if (!SWIG_IsOK(res1)) {
15977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15978 }
15979 arg1 = reinterpret_cast< wxImage * >(argp1);
15980 ecode2 = SWIG_AsVal_int(obj1, &val2);
15981 if (!SWIG_IsOK(ecode2)) {
15982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15983 }
15984 arg2 = static_cast< int >(val2);
15985 ecode3 = SWIG_AsVal_int(obj2, &val3);
15986 if (!SWIG_IsOK(ecode3)) {
15987 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15988 }
15989 arg3 = static_cast< int >(val3);
15990 if (obj3) {
15991 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15992 if (!SWIG_IsOK(ecode4)) {
15993 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
15994 }
15995 arg4 = static_cast< bool >(val4);
15996 }
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->Create(arg2,arg3,arg4);
16000 wxPyEndAllowThreads(__tstate);
16001 if (PyErr_Occurred()) SWIG_fail;
16002 }
16003 resultobj = SWIG_Py_Void();
16004 return resultobj;
16005 fail:
16006 return NULL;
16007 }
16008
16009
16010 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16011 PyObject *resultobj = 0;
16012 wxImage *arg1 = (wxImage *) 0 ;
16013 void *argp1 = 0 ;
16014 int res1 = 0 ;
16015 PyObject *swig_obj[1] ;
16016
16017 if (!args) SWIG_fail;
16018 swig_obj[0] = args;
16019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16020 if (!SWIG_IsOK(res1)) {
16021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16022 }
16023 arg1 = reinterpret_cast< wxImage * >(argp1);
16024 {
16025 PyThreadState* __tstate = wxPyBeginAllowThreads();
16026 (arg1)->Destroy();
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 resultobj = SWIG_Py_Void();
16031 return resultobj;
16032 fail:
16033 return NULL;
16034 }
16035
16036
16037 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16038 PyObject *resultobj = 0;
16039 wxImage *arg1 = (wxImage *) 0 ;
16040 int arg2 ;
16041 int arg3 ;
16042 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16043 SwigValueWrapper<wxImage > result;
16044 void *argp1 = 0 ;
16045 int res1 = 0 ;
16046 int val2 ;
16047 int ecode2 = 0 ;
16048 int val3 ;
16049 int ecode3 = 0 ;
16050 int val4 ;
16051 int ecode4 = 0 ;
16052 PyObject * obj0 = 0 ;
16053 PyObject * obj1 = 0 ;
16054 PyObject * obj2 = 0 ;
16055 PyObject * obj3 = 0 ;
16056 char * kwnames[] = {
16057 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16058 };
16059
16060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16062 if (!SWIG_IsOK(res1)) {
16063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16064 }
16065 arg1 = reinterpret_cast< wxImage * >(argp1);
16066 ecode2 = SWIG_AsVal_int(obj1, &val2);
16067 if (!SWIG_IsOK(ecode2)) {
16068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16069 }
16070 arg2 = static_cast< int >(val2);
16071 ecode3 = SWIG_AsVal_int(obj2, &val3);
16072 if (!SWIG_IsOK(ecode3)) {
16073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16074 }
16075 arg3 = static_cast< int >(val3);
16076 if (obj3) {
16077 ecode4 = SWIG_AsVal_int(obj3, &val4);
16078 if (!SWIG_IsOK(ecode4)) {
16079 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16080 }
16081 arg4 = static_cast< int >(val4);
16082 }
16083 {
16084 PyThreadState* __tstate = wxPyBeginAllowThreads();
16085 result = (arg1)->Scale(arg2,arg3,arg4);
16086 wxPyEndAllowThreads(__tstate);
16087 if (PyErr_Occurred()) SWIG_fail;
16088 }
16089 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16090 return resultobj;
16091 fail:
16092 return NULL;
16093 }
16094
16095
16096 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16097 PyObject *resultobj = 0;
16098 wxImage *arg1 = (wxImage *) 0 ;
16099 int arg2 ;
16100 int arg3 ;
16101 SwigValueWrapper<wxImage > result;
16102 void *argp1 = 0 ;
16103 int res1 = 0 ;
16104 int val2 ;
16105 int ecode2 = 0 ;
16106 int val3 ;
16107 int ecode3 = 0 ;
16108 PyObject * obj0 = 0 ;
16109 PyObject * obj1 = 0 ;
16110 PyObject * obj2 = 0 ;
16111 char * kwnames[] = {
16112 (char *) "self",(char *) "width",(char *) "height", NULL
16113 };
16114
16115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16117 if (!SWIG_IsOK(res1)) {
16118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16119 }
16120 arg1 = reinterpret_cast< wxImage * >(argp1);
16121 ecode2 = SWIG_AsVal_int(obj1, &val2);
16122 if (!SWIG_IsOK(ecode2)) {
16123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16124 }
16125 arg2 = static_cast< int >(val2);
16126 ecode3 = SWIG_AsVal_int(obj2, &val3);
16127 if (!SWIG_IsOK(ecode3)) {
16128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16129 }
16130 arg3 = static_cast< int >(val3);
16131 {
16132 PyThreadState* __tstate = wxPyBeginAllowThreads();
16133 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16134 wxPyEndAllowThreads(__tstate);
16135 if (PyErr_Occurred()) SWIG_fail;
16136 }
16137 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16138 return resultobj;
16139 fail:
16140 return NULL;
16141 }
16142
16143
16144 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16145 PyObject *resultobj = 0;
16146 wxImage *arg1 = (wxImage *) 0 ;
16147 int arg2 ;
16148 int arg3 ;
16149 SwigValueWrapper<wxImage > result;
16150 void *argp1 = 0 ;
16151 int res1 = 0 ;
16152 int val2 ;
16153 int ecode2 = 0 ;
16154 int val3 ;
16155 int ecode3 = 0 ;
16156 PyObject * obj0 = 0 ;
16157 PyObject * obj1 = 0 ;
16158 PyObject * obj2 = 0 ;
16159 char * kwnames[] = {
16160 (char *) "self",(char *) "width",(char *) "height", NULL
16161 };
16162
16163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16165 if (!SWIG_IsOK(res1)) {
16166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16167 }
16168 arg1 = reinterpret_cast< wxImage * >(argp1);
16169 ecode2 = SWIG_AsVal_int(obj1, &val2);
16170 if (!SWIG_IsOK(ecode2)) {
16171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16172 }
16173 arg2 = static_cast< int >(val2);
16174 ecode3 = SWIG_AsVal_int(obj2, &val3);
16175 if (!SWIG_IsOK(ecode3)) {
16176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16177 }
16178 arg3 = static_cast< int >(val3);
16179 {
16180 PyThreadState* __tstate = wxPyBeginAllowThreads();
16181 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16182 wxPyEndAllowThreads(__tstate);
16183 if (PyErr_Occurred()) SWIG_fail;
16184 }
16185 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16186 return resultobj;
16187 fail:
16188 return NULL;
16189 }
16190
16191
16192 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16193 PyObject *resultobj = 0;
16194 wxImage *arg1 = (wxImage *) 0 ;
16195 int arg2 ;
16196 SwigValueWrapper<wxImage > result;
16197 void *argp1 = 0 ;
16198 int res1 = 0 ;
16199 int val2 ;
16200 int ecode2 = 0 ;
16201 PyObject * obj0 = 0 ;
16202 PyObject * obj1 = 0 ;
16203 char * kwnames[] = {
16204 (char *) "self",(char *) "radius", NULL
16205 };
16206
16207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16209 if (!SWIG_IsOK(res1)) {
16210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16211 }
16212 arg1 = reinterpret_cast< wxImage * >(argp1);
16213 ecode2 = SWIG_AsVal_int(obj1, &val2);
16214 if (!SWIG_IsOK(ecode2)) {
16215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16216 }
16217 arg2 = static_cast< int >(val2);
16218 {
16219 PyThreadState* __tstate = wxPyBeginAllowThreads();
16220 result = (arg1)->Blur(arg2);
16221 wxPyEndAllowThreads(__tstate);
16222 if (PyErr_Occurred()) SWIG_fail;
16223 }
16224 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16225 return resultobj;
16226 fail:
16227 return NULL;
16228 }
16229
16230
16231 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16232 PyObject *resultobj = 0;
16233 wxImage *arg1 = (wxImage *) 0 ;
16234 int arg2 ;
16235 SwigValueWrapper<wxImage > result;
16236 void *argp1 = 0 ;
16237 int res1 = 0 ;
16238 int val2 ;
16239 int ecode2 = 0 ;
16240 PyObject * obj0 = 0 ;
16241 PyObject * obj1 = 0 ;
16242 char * kwnames[] = {
16243 (char *) "self",(char *) "radius", NULL
16244 };
16245
16246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16248 if (!SWIG_IsOK(res1)) {
16249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16250 }
16251 arg1 = reinterpret_cast< wxImage * >(argp1);
16252 ecode2 = SWIG_AsVal_int(obj1, &val2);
16253 if (!SWIG_IsOK(ecode2)) {
16254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16255 }
16256 arg2 = static_cast< int >(val2);
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 result = (arg1)->BlurHorizontal(arg2);
16260 wxPyEndAllowThreads(__tstate);
16261 if (PyErr_Occurred()) SWIG_fail;
16262 }
16263 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16264 return resultobj;
16265 fail:
16266 return NULL;
16267 }
16268
16269
16270 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16271 PyObject *resultobj = 0;
16272 wxImage *arg1 = (wxImage *) 0 ;
16273 int arg2 ;
16274 SwigValueWrapper<wxImage > result;
16275 void *argp1 = 0 ;
16276 int res1 = 0 ;
16277 int val2 ;
16278 int ecode2 = 0 ;
16279 PyObject * obj0 = 0 ;
16280 PyObject * obj1 = 0 ;
16281 char * kwnames[] = {
16282 (char *) "self",(char *) "radius", NULL
16283 };
16284
16285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16287 if (!SWIG_IsOK(res1)) {
16288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16289 }
16290 arg1 = reinterpret_cast< wxImage * >(argp1);
16291 ecode2 = SWIG_AsVal_int(obj1, &val2);
16292 if (!SWIG_IsOK(ecode2)) {
16293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16294 }
16295 arg2 = static_cast< int >(val2);
16296 {
16297 PyThreadState* __tstate = wxPyBeginAllowThreads();
16298 result = (arg1)->BlurVertical(arg2);
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16303 return resultobj;
16304 fail:
16305 return NULL;
16306 }
16307
16308
16309 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16310 PyObject *resultobj = 0;
16311 wxImage *arg1 = (wxImage *) 0 ;
16312 int arg2 ;
16313 int arg3 ;
16314 SwigValueWrapper<wxImage > result;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 int val2 ;
16318 int ecode2 = 0 ;
16319 int val3 ;
16320 int ecode3 = 0 ;
16321 PyObject * obj0 = 0 ;
16322 PyObject * obj1 = 0 ;
16323 PyObject * obj2 = 0 ;
16324 char * kwnames[] = {
16325 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16326 };
16327
16328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16330 if (!SWIG_IsOK(res1)) {
16331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16332 }
16333 arg1 = reinterpret_cast< wxImage * >(argp1);
16334 ecode2 = SWIG_AsVal_int(obj1, &val2);
16335 if (!SWIG_IsOK(ecode2)) {
16336 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16337 }
16338 arg2 = static_cast< int >(val2);
16339 ecode3 = SWIG_AsVal_int(obj2, &val3);
16340 if (!SWIG_IsOK(ecode3)) {
16341 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16342 }
16343 arg3 = static_cast< int >(val3);
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16347 wxPyEndAllowThreads(__tstate);
16348 if (PyErr_Occurred()) SWIG_fail;
16349 }
16350 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16351 return resultobj;
16352 fail:
16353 return NULL;
16354 }
16355
16356
16357 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16358 PyObject *resultobj = 0;
16359 wxImage *arg1 = (wxImage *) 0 ;
16360 int arg2 ;
16361 int arg3 ;
16362 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16363 wxImage *result = 0 ;
16364 void *argp1 = 0 ;
16365 int res1 = 0 ;
16366 int val2 ;
16367 int ecode2 = 0 ;
16368 int val3 ;
16369 int ecode3 = 0 ;
16370 int val4 ;
16371 int ecode4 = 0 ;
16372 PyObject * obj0 = 0 ;
16373 PyObject * obj1 = 0 ;
16374 PyObject * obj2 = 0 ;
16375 PyObject * obj3 = 0 ;
16376 char * kwnames[] = {
16377 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16378 };
16379
16380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16382 if (!SWIG_IsOK(res1)) {
16383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16384 }
16385 arg1 = reinterpret_cast< wxImage * >(argp1);
16386 ecode2 = SWIG_AsVal_int(obj1, &val2);
16387 if (!SWIG_IsOK(ecode2)) {
16388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16389 }
16390 arg2 = static_cast< int >(val2);
16391 ecode3 = SWIG_AsVal_int(obj2, &val3);
16392 if (!SWIG_IsOK(ecode3)) {
16393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16394 }
16395 arg3 = static_cast< int >(val3);
16396 if (obj3) {
16397 ecode4 = SWIG_AsVal_int(obj3, &val4);
16398 if (!SWIG_IsOK(ecode4)) {
16399 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16400 }
16401 arg4 = static_cast< int >(val4);
16402 }
16403 {
16404 PyThreadState* __tstate = wxPyBeginAllowThreads();
16405 {
16406 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16407 result = (wxImage *) &_result_ref;
16408 }
16409 wxPyEndAllowThreads(__tstate);
16410 if (PyErr_Occurred()) SWIG_fail;
16411 }
16412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16413 return resultobj;
16414 fail:
16415 return NULL;
16416 }
16417
16418
16419 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16420 PyObject *resultobj = 0;
16421 wxImage *arg1 = (wxImage *) 0 ;
16422 wxSize *arg2 = 0 ;
16423 wxPoint *arg3 = 0 ;
16424 int arg4 = (int) -1 ;
16425 int arg5 = (int) -1 ;
16426 int arg6 = (int) -1 ;
16427 wxImage *result = 0 ;
16428 void *argp1 = 0 ;
16429 int res1 = 0 ;
16430 wxSize temp2 ;
16431 wxPoint temp3 ;
16432 int val4 ;
16433 int ecode4 = 0 ;
16434 int val5 ;
16435 int ecode5 = 0 ;
16436 int val6 ;
16437 int ecode6 = 0 ;
16438 PyObject * obj0 = 0 ;
16439 PyObject * obj1 = 0 ;
16440 PyObject * obj2 = 0 ;
16441 PyObject * obj3 = 0 ;
16442 PyObject * obj4 = 0 ;
16443 PyObject * obj5 = 0 ;
16444 char * kwnames[] = {
16445 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16446 };
16447
16448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16450 if (!SWIG_IsOK(res1)) {
16451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16452 }
16453 arg1 = reinterpret_cast< wxImage * >(argp1);
16454 {
16455 arg2 = &temp2;
16456 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16457 }
16458 {
16459 arg3 = &temp3;
16460 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16461 }
16462 if (obj3) {
16463 ecode4 = SWIG_AsVal_int(obj3, &val4);
16464 if (!SWIG_IsOK(ecode4)) {
16465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16466 }
16467 arg4 = static_cast< int >(val4);
16468 }
16469 if (obj4) {
16470 ecode5 = SWIG_AsVal_int(obj4, &val5);
16471 if (!SWIG_IsOK(ecode5)) {
16472 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16473 }
16474 arg5 = static_cast< int >(val5);
16475 }
16476 if (obj5) {
16477 ecode6 = SWIG_AsVal_int(obj5, &val6);
16478 if (!SWIG_IsOK(ecode6)) {
16479 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16480 }
16481 arg6 = static_cast< int >(val6);
16482 }
16483 {
16484 PyThreadState* __tstate = wxPyBeginAllowThreads();
16485 {
16486 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16487 result = (wxImage *) &_result_ref;
16488 }
16489 wxPyEndAllowThreads(__tstate);
16490 if (PyErr_Occurred()) SWIG_fail;
16491 }
16492 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16493 return resultobj;
16494 fail:
16495 return NULL;
16496 }
16497
16498
16499 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16500 PyObject *resultobj = 0;
16501 wxImage *arg1 = (wxImage *) 0 ;
16502 int arg2 ;
16503 int arg3 ;
16504 byte arg4 ;
16505 byte arg5 ;
16506 byte arg6 ;
16507 void *argp1 = 0 ;
16508 int res1 = 0 ;
16509 int val2 ;
16510 int ecode2 = 0 ;
16511 int val3 ;
16512 int ecode3 = 0 ;
16513 unsigned char val4 ;
16514 int ecode4 = 0 ;
16515 unsigned char val5 ;
16516 int ecode5 = 0 ;
16517 unsigned char val6 ;
16518 int ecode6 = 0 ;
16519 PyObject * obj0 = 0 ;
16520 PyObject * obj1 = 0 ;
16521 PyObject * obj2 = 0 ;
16522 PyObject * obj3 = 0 ;
16523 PyObject * obj4 = 0 ;
16524 PyObject * obj5 = 0 ;
16525 char * kwnames[] = {
16526 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16527 };
16528
16529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16531 if (!SWIG_IsOK(res1)) {
16532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16533 }
16534 arg1 = reinterpret_cast< wxImage * >(argp1);
16535 ecode2 = SWIG_AsVal_int(obj1, &val2);
16536 if (!SWIG_IsOK(ecode2)) {
16537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16538 }
16539 arg2 = static_cast< int >(val2);
16540 ecode3 = SWIG_AsVal_int(obj2, &val3);
16541 if (!SWIG_IsOK(ecode3)) {
16542 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16543 }
16544 arg3 = static_cast< int >(val3);
16545 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16546 if (!SWIG_IsOK(ecode4)) {
16547 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16548 }
16549 arg4 = static_cast< byte >(val4);
16550 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16551 if (!SWIG_IsOK(ecode5)) {
16552 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16553 }
16554 arg5 = static_cast< byte >(val5);
16555 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16556 if (!SWIG_IsOK(ecode6)) {
16557 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16558 }
16559 arg6 = static_cast< byte >(val6);
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_Py_Void();
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 wxRect *arg2 = 0 ;
16577 byte arg3 ;
16578 byte arg4 ;
16579 byte arg5 ;
16580 void *argp1 = 0 ;
16581 int res1 = 0 ;
16582 wxRect temp2 ;
16583 unsigned char val3 ;
16584 int ecode3 = 0 ;
16585 unsigned char val4 ;
16586 int ecode4 = 0 ;
16587 unsigned char val5 ;
16588 int ecode5 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 PyObject * obj3 = 0 ;
16593 PyObject * obj4 = 0 ;
16594 char * kwnames[] = {
16595 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16596 };
16597
16598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16602 }
16603 arg1 = reinterpret_cast< wxImage * >(argp1);
16604 {
16605 arg2 = &temp2;
16606 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16607 }
16608 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16611 }
16612 arg3 = static_cast< byte >(val3);
16613 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16614 if (!SWIG_IsOK(ecode4)) {
16615 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16616 }
16617 arg4 = static_cast< byte >(val4);
16618 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16619 if (!SWIG_IsOK(ecode5)) {
16620 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16621 }
16622 arg5 = static_cast< byte >(val5);
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 resultobj = SWIG_Py_Void();
16630 return resultobj;
16631 fail:
16632 return NULL;
16633 }
16634
16635
16636 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16637 PyObject *resultobj = 0;
16638 wxImage *arg1 = (wxImage *) 0 ;
16639 int arg2 ;
16640 int arg3 ;
16641 byte result;
16642 void *argp1 = 0 ;
16643 int res1 = 0 ;
16644 int val2 ;
16645 int ecode2 = 0 ;
16646 int val3 ;
16647 int ecode3 = 0 ;
16648 PyObject * obj0 = 0 ;
16649 PyObject * obj1 = 0 ;
16650 PyObject * obj2 = 0 ;
16651 char * kwnames[] = {
16652 (char *) "self",(char *) "x",(char *) "y", NULL
16653 };
16654
16655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16657 if (!SWIG_IsOK(res1)) {
16658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16659 }
16660 arg1 = reinterpret_cast< wxImage * >(argp1);
16661 ecode2 = SWIG_AsVal_int(obj1, &val2);
16662 if (!SWIG_IsOK(ecode2)) {
16663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16664 }
16665 arg2 = static_cast< int >(val2);
16666 ecode3 = SWIG_AsVal_int(obj2, &val3);
16667 if (!SWIG_IsOK(ecode3)) {
16668 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16669 }
16670 arg3 = static_cast< int >(val3);
16671 {
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = (byte)(arg1)->GetRed(arg2,arg3);
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj = 0;
16686 wxImage *arg1 = (wxImage *) 0 ;
16687 int arg2 ;
16688 int arg3 ;
16689 byte result;
16690 void *argp1 = 0 ;
16691 int res1 = 0 ;
16692 int val2 ;
16693 int ecode2 = 0 ;
16694 int val3 ;
16695 int ecode3 = 0 ;
16696 PyObject * obj0 = 0 ;
16697 PyObject * obj1 = 0 ;
16698 PyObject * obj2 = 0 ;
16699 char * kwnames[] = {
16700 (char *) "self",(char *) "x",(char *) "y", NULL
16701 };
16702
16703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16705 if (!SWIG_IsOK(res1)) {
16706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16707 }
16708 arg1 = reinterpret_cast< wxImage * >(argp1);
16709 ecode2 = SWIG_AsVal_int(obj1, &val2);
16710 if (!SWIG_IsOK(ecode2)) {
16711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16712 }
16713 arg2 = static_cast< int >(val2);
16714 ecode3 = SWIG_AsVal_int(obj2, &val3);
16715 if (!SWIG_IsOK(ecode3)) {
16716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16717 }
16718 arg3 = static_cast< int >(val3);
16719 {
16720 PyThreadState* __tstate = wxPyBeginAllowThreads();
16721 result = (byte)(arg1)->GetGreen(arg2,arg3);
16722 wxPyEndAllowThreads(__tstate);
16723 if (PyErr_Occurred()) SWIG_fail;
16724 }
16725 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16726 return resultobj;
16727 fail:
16728 return NULL;
16729 }
16730
16731
16732 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16733 PyObject *resultobj = 0;
16734 wxImage *arg1 = (wxImage *) 0 ;
16735 int arg2 ;
16736 int arg3 ;
16737 byte result;
16738 void *argp1 = 0 ;
16739 int res1 = 0 ;
16740 int val2 ;
16741 int ecode2 = 0 ;
16742 int val3 ;
16743 int ecode3 = 0 ;
16744 PyObject * obj0 = 0 ;
16745 PyObject * obj1 = 0 ;
16746 PyObject * obj2 = 0 ;
16747 char * kwnames[] = {
16748 (char *) "self",(char *) "x",(char *) "y", NULL
16749 };
16750
16751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16753 if (!SWIG_IsOK(res1)) {
16754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16755 }
16756 arg1 = reinterpret_cast< wxImage * >(argp1);
16757 ecode2 = SWIG_AsVal_int(obj1, &val2);
16758 if (!SWIG_IsOK(ecode2)) {
16759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16760 }
16761 arg2 = static_cast< int >(val2);
16762 ecode3 = SWIG_AsVal_int(obj2, &val3);
16763 if (!SWIG_IsOK(ecode3)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16765 }
16766 arg3 = static_cast< int >(val3);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 result = (byte)(arg1)->GetBlue(arg2,arg3);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImage *arg1 = (wxImage *) 0 ;
16783 int arg2 ;
16784 int arg3 ;
16785 byte arg4 ;
16786 void *argp1 = 0 ;
16787 int res1 = 0 ;
16788 int val2 ;
16789 int ecode2 = 0 ;
16790 int val3 ;
16791 int ecode3 = 0 ;
16792 unsigned char val4 ;
16793 int ecode4 = 0 ;
16794 PyObject * obj0 = 0 ;
16795 PyObject * obj1 = 0 ;
16796 PyObject * obj2 = 0 ;
16797 PyObject * obj3 = 0 ;
16798 char * kwnames[] = {
16799 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16800 };
16801
16802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16804 if (!SWIG_IsOK(res1)) {
16805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16806 }
16807 arg1 = reinterpret_cast< wxImage * >(argp1);
16808 ecode2 = SWIG_AsVal_int(obj1, &val2);
16809 if (!SWIG_IsOK(ecode2)) {
16810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16811 }
16812 arg2 = static_cast< int >(val2);
16813 ecode3 = SWIG_AsVal_int(obj2, &val3);
16814 if (!SWIG_IsOK(ecode3)) {
16815 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16816 }
16817 arg3 = static_cast< int >(val3);
16818 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16819 if (!SWIG_IsOK(ecode4)) {
16820 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16821 }
16822 arg4 = static_cast< byte >(val4);
16823 {
16824 PyThreadState* __tstate = wxPyBeginAllowThreads();
16825 (arg1)->SetAlpha(arg2,arg3,arg4);
16826 wxPyEndAllowThreads(__tstate);
16827 if (PyErr_Occurred()) SWIG_fail;
16828 }
16829 resultobj = SWIG_Py_Void();
16830 return resultobj;
16831 fail:
16832 return NULL;
16833 }
16834
16835
16836 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16837 PyObject *resultobj = 0;
16838 wxImage *arg1 = (wxImage *) 0 ;
16839 int arg2 ;
16840 int arg3 ;
16841 byte result;
16842 void *argp1 = 0 ;
16843 int res1 = 0 ;
16844 int val2 ;
16845 int ecode2 = 0 ;
16846 int val3 ;
16847 int ecode3 = 0 ;
16848 PyObject * obj0 = 0 ;
16849 PyObject * obj1 = 0 ;
16850 PyObject * obj2 = 0 ;
16851 char * kwnames[] = {
16852 (char *) "self",(char *) "x",(char *) "y", NULL
16853 };
16854
16855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16857 if (!SWIG_IsOK(res1)) {
16858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16859 }
16860 arg1 = reinterpret_cast< wxImage * >(argp1);
16861 ecode2 = SWIG_AsVal_int(obj1, &val2);
16862 if (!SWIG_IsOK(ecode2)) {
16863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16864 }
16865 arg2 = static_cast< int >(val2);
16866 ecode3 = SWIG_AsVal_int(obj2, &val3);
16867 if (!SWIG_IsOK(ecode3)) {
16868 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16869 }
16870 arg3 = static_cast< int >(val3);
16871 {
16872 PyThreadState* __tstate = wxPyBeginAllowThreads();
16873 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16874 wxPyEndAllowThreads(__tstate);
16875 if (PyErr_Occurred()) SWIG_fail;
16876 }
16877 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16878 return resultobj;
16879 fail:
16880 return NULL;
16881 }
16882
16883
16884 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16885 PyObject *resultobj = 0;
16886 wxImage *arg1 = (wxImage *) 0 ;
16887 bool result;
16888 void *argp1 = 0 ;
16889 int res1 = 0 ;
16890 PyObject *swig_obj[1] ;
16891
16892 if (!args) SWIG_fail;
16893 swig_obj[0] = args;
16894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16895 if (!SWIG_IsOK(res1)) {
16896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16897 }
16898 arg1 = reinterpret_cast< wxImage * >(argp1);
16899 {
16900 PyThreadState* __tstate = wxPyBeginAllowThreads();
16901 result = (bool)(arg1)->HasAlpha();
16902 wxPyEndAllowThreads(__tstate);
16903 if (PyErr_Occurred()) SWIG_fail;
16904 }
16905 {
16906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16907 }
16908 return resultobj;
16909 fail:
16910 return NULL;
16911 }
16912
16913
16914 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16915 PyObject *resultobj = 0;
16916 wxImage *arg1 = (wxImage *) 0 ;
16917 void *argp1 = 0 ;
16918 int res1 = 0 ;
16919 PyObject *swig_obj[1] ;
16920
16921 if (!args) SWIG_fail;
16922 swig_obj[0] = args;
16923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16924 if (!SWIG_IsOK(res1)) {
16925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16926 }
16927 arg1 = reinterpret_cast< wxImage * >(argp1);
16928 {
16929 PyThreadState* __tstate = wxPyBeginAllowThreads();
16930 (arg1)->InitAlpha();
16931 wxPyEndAllowThreads(__tstate);
16932 if (PyErr_Occurred()) SWIG_fail;
16933 }
16934 resultobj = SWIG_Py_Void();
16935 return resultobj;
16936 fail:
16937 return NULL;
16938 }
16939
16940
16941 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16942 PyObject *resultobj = 0;
16943 wxImage *arg1 = (wxImage *) 0 ;
16944 int arg2 ;
16945 int arg3 ;
16946 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16947 bool result;
16948 void *argp1 = 0 ;
16949 int res1 = 0 ;
16950 int val2 ;
16951 int ecode2 = 0 ;
16952 int val3 ;
16953 int ecode3 = 0 ;
16954 unsigned char val4 ;
16955 int ecode4 = 0 ;
16956 PyObject * obj0 = 0 ;
16957 PyObject * obj1 = 0 ;
16958 PyObject * obj2 = 0 ;
16959 PyObject * obj3 = 0 ;
16960 char * kwnames[] = {
16961 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16962 };
16963
16964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16966 if (!SWIG_IsOK(res1)) {
16967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16968 }
16969 arg1 = reinterpret_cast< wxImage * >(argp1);
16970 ecode2 = SWIG_AsVal_int(obj1, &val2);
16971 if (!SWIG_IsOK(ecode2)) {
16972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16973 }
16974 arg2 = static_cast< int >(val2);
16975 ecode3 = SWIG_AsVal_int(obj2, &val3);
16976 if (!SWIG_IsOK(ecode3)) {
16977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16978 }
16979 arg3 = static_cast< int >(val3);
16980 if (obj3) {
16981 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16982 if (!SWIG_IsOK(ecode4)) {
16983 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16984 }
16985 arg4 = static_cast< byte >(val4);
16986 }
16987 {
16988 PyThreadState* __tstate = wxPyBeginAllowThreads();
16989 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
16990 wxPyEndAllowThreads(__tstate);
16991 if (PyErr_Occurred()) SWIG_fail;
16992 }
16993 {
16994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16995 }
16996 return resultobj;
16997 fail:
16998 return NULL;
16999 }
17000
17001
17002 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17003 PyObject *resultobj = 0;
17004 wxImage *arg1 = (wxImage *) 0 ;
17005 byte *arg2 = (byte *) 0 ;
17006 byte *arg3 = (byte *) 0 ;
17007 byte *arg4 = (byte *) 0 ;
17008 byte arg5 = (byte) 0 ;
17009 byte arg6 = (byte) 0 ;
17010 byte arg7 = (byte) 0 ;
17011 bool result;
17012 void *argp1 = 0 ;
17013 int res1 = 0 ;
17014 byte temp2 ;
17015 int res2 = SWIG_TMPOBJ ;
17016 byte temp3 ;
17017 int res3 = SWIG_TMPOBJ ;
17018 byte temp4 ;
17019 int res4 = SWIG_TMPOBJ ;
17020 unsigned char val5 ;
17021 int ecode5 = 0 ;
17022 unsigned char val6 ;
17023 int ecode6 = 0 ;
17024 unsigned char val7 ;
17025 int ecode7 = 0 ;
17026 PyObject * obj0 = 0 ;
17027 PyObject * obj1 = 0 ;
17028 PyObject * obj2 = 0 ;
17029 PyObject * obj3 = 0 ;
17030 char * kwnames[] = {
17031 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17032 };
17033
17034 arg2 = &temp2;
17035 arg3 = &temp3;
17036 arg4 = &temp4;
17037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17039 if (!SWIG_IsOK(res1)) {
17040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17041 }
17042 arg1 = reinterpret_cast< wxImage * >(argp1);
17043 if (obj1) {
17044 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17045 if (!SWIG_IsOK(ecode5)) {
17046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17047 }
17048 arg5 = static_cast< byte >(val5);
17049 }
17050 if (obj2) {
17051 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17052 if (!SWIG_IsOK(ecode6)) {
17053 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17054 }
17055 arg6 = static_cast< byte >(val6);
17056 }
17057 if (obj3) {
17058 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17059 if (!SWIG_IsOK(ecode7)) {
17060 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17061 }
17062 arg7 = static_cast< byte >(val7);
17063 }
17064 {
17065 PyThreadState* __tstate = wxPyBeginAllowThreads();
17066 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17067 wxPyEndAllowThreads(__tstate);
17068 if (PyErr_Occurred()) SWIG_fail;
17069 }
17070 {
17071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17072 }
17073 if (SWIG_IsTmpObj(res2)) {
17074 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17075 } else {
17076 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17077 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17078 }
17079 if (SWIG_IsTmpObj(res3)) {
17080 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17081 } else {
17082 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17083 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17084 }
17085 if (SWIG_IsTmpObj(res4)) {
17086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17087 } else {
17088 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17090 }
17091 return resultobj;
17092 fail:
17093 return NULL;
17094 }
17095
17096
17097 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17098 PyObject *resultobj = 0;
17099 wxImage *arg1 = (wxImage *) 0 ;
17100 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17101 bool result;
17102 void *argp1 = 0 ;
17103 int res1 = 0 ;
17104 unsigned char val2 ;
17105 int ecode2 = 0 ;
17106 PyObject * obj0 = 0 ;
17107 PyObject * obj1 = 0 ;
17108 char * kwnames[] = {
17109 (char *) "self",(char *) "threshold", NULL
17110 };
17111
17112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17114 if (!SWIG_IsOK(res1)) {
17115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17116 }
17117 arg1 = reinterpret_cast< wxImage * >(argp1);
17118 if (obj1) {
17119 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17120 if (!SWIG_IsOK(ecode2)) {
17121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17122 }
17123 arg2 = static_cast< byte >(val2);
17124 }
17125 {
17126 PyThreadState* __tstate = wxPyBeginAllowThreads();
17127 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17128 wxPyEndAllowThreads(__tstate);
17129 if (PyErr_Occurred()) SWIG_fail;
17130 }
17131 {
17132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17133 }
17134 return resultobj;
17135 fail:
17136 return NULL;
17137 }
17138
17139
17140 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17141 PyObject *resultobj = 0;
17142 wxImage *arg1 = (wxImage *) 0 ;
17143 byte arg2 ;
17144 byte arg3 ;
17145 byte arg4 ;
17146 bool result;
17147 void *argp1 = 0 ;
17148 int res1 = 0 ;
17149 unsigned char val2 ;
17150 int ecode2 = 0 ;
17151 unsigned char val3 ;
17152 int ecode3 = 0 ;
17153 unsigned char val4 ;
17154 int ecode4 = 0 ;
17155 PyObject * obj0 = 0 ;
17156 PyObject * obj1 = 0 ;
17157 PyObject * obj2 = 0 ;
17158 PyObject * obj3 = 0 ;
17159 char * kwnames[] = {
17160 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17161 };
17162
17163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17165 if (!SWIG_IsOK(res1)) {
17166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17167 }
17168 arg1 = reinterpret_cast< wxImage * >(argp1);
17169 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17170 if (!SWIG_IsOK(ecode2)) {
17171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17172 }
17173 arg2 = static_cast< byte >(val2);
17174 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17175 if (!SWIG_IsOK(ecode3)) {
17176 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17177 }
17178 arg3 = static_cast< byte >(val3);
17179 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17180 if (!SWIG_IsOK(ecode4)) {
17181 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17182 }
17183 arg4 = static_cast< byte >(val4);
17184 {
17185 PyThreadState* __tstate = wxPyBeginAllowThreads();
17186 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17187 wxPyEndAllowThreads(__tstate);
17188 if (PyErr_Occurred()) SWIG_fail;
17189 }
17190 {
17191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17192 }
17193 return resultobj;
17194 fail:
17195 return NULL;
17196 }
17197
17198
17199 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17200 PyObject *resultobj = 0;
17201 wxImage *arg1 = (wxImage *) 0 ;
17202 wxImage *arg2 = 0 ;
17203 byte arg3 ;
17204 byte arg4 ;
17205 byte arg5 ;
17206 bool result;
17207 void *argp1 = 0 ;
17208 int res1 = 0 ;
17209 void *argp2 = 0 ;
17210 int res2 = 0 ;
17211 unsigned char val3 ;
17212 int ecode3 = 0 ;
17213 unsigned char val4 ;
17214 int ecode4 = 0 ;
17215 unsigned char val5 ;
17216 int ecode5 = 0 ;
17217 PyObject * obj0 = 0 ;
17218 PyObject * obj1 = 0 ;
17219 PyObject * obj2 = 0 ;
17220 PyObject * obj3 = 0 ;
17221 PyObject * obj4 = 0 ;
17222 char * kwnames[] = {
17223 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17224 };
17225
17226 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17227 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17228 if (!SWIG_IsOK(res1)) {
17229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17230 }
17231 arg1 = reinterpret_cast< wxImage * >(argp1);
17232 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17233 if (!SWIG_IsOK(res2)) {
17234 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17235 }
17236 if (!argp2) {
17237 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17238 }
17239 arg2 = reinterpret_cast< wxImage * >(argp2);
17240 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17241 if (!SWIG_IsOK(ecode3)) {
17242 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17243 }
17244 arg3 = static_cast< byte >(val3);
17245 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17246 if (!SWIG_IsOK(ecode4)) {
17247 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17248 }
17249 arg4 = static_cast< byte >(val4);
17250 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17251 if (!SWIG_IsOK(ecode5)) {
17252 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17253 }
17254 arg5 = static_cast< byte >(val5);
17255 {
17256 PyThreadState* __tstate = wxPyBeginAllowThreads();
17257 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17258 wxPyEndAllowThreads(__tstate);
17259 if (PyErr_Occurred()) SWIG_fail;
17260 }
17261 {
17262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17263 }
17264 return resultobj;
17265 fail:
17266 return NULL;
17267 }
17268
17269
17270 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17271 PyObject *resultobj = 0;
17272 wxString *arg1 = 0 ;
17273 bool result;
17274 bool temp1 = false ;
17275 PyObject * obj0 = 0 ;
17276 char * kwnames[] = {
17277 (char *) "filename", NULL
17278 };
17279
17280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17281 {
17282 arg1 = wxString_in_helper(obj0);
17283 if (arg1 == NULL) SWIG_fail;
17284 temp1 = true;
17285 }
17286 {
17287 PyThreadState* __tstate = wxPyBeginAllowThreads();
17288 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17289 wxPyEndAllowThreads(__tstate);
17290 if (PyErr_Occurred()) SWIG_fail;
17291 }
17292 {
17293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17294 }
17295 {
17296 if (temp1)
17297 delete arg1;
17298 }
17299 return resultobj;
17300 fail:
17301 {
17302 if (temp1)
17303 delete arg1;
17304 }
17305 return NULL;
17306 }
17307
17308
17309 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17310 PyObject *resultobj = 0;
17311 wxString *arg1 = 0 ;
17312 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17313 int result;
17314 bool temp1 = false ;
17315 long val2 ;
17316 int ecode2 = 0 ;
17317 PyObject * obj0 = 0 ;
17318 PyObject * obj1 = 0 ;
17319 char * kwnames[] = {
17320 (char *) "filename",(char *) "type", NULL
17321 };
17322
17323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17324 {
17325 arg1 = wxString_in_helper(obj0);
17326 if (arg1 == NULL) SWIG_fail;
17327 temp1 = true;
17328 }
17329 if (obj1) {
17330 ecode2 = SWIG_AsVal_long(obj1, &val2);
17331 if (!SWIG_IsOK(ecode2)) {
17332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17333 }
17334 arg2 = static_cast< long >(val2);
17335 }
17336 {
17337 PyThreadState* __tstate = wxPyBeginAllowThreads();
17338 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17339 wxPyEndAllowThreads(__tstate);
17340 if (PyErr_Occurred()) SWIG_fail;
17341 }
17342 resultobj = SWIG_From_int(static_cast< int >(result));
17343 {
17344 if (temp1)
17345 delete arg1;
17346 }
17347 return resultobj;
17348 fail:
17349 {
17350 if (temp1)
17351 delete arg1;
17352 }
17353 return NULL;
17354 }
17355
17356
17357 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj = 0;
17359 wxImage *arg1 = (wxImage *) 0 ;
17360 wxString *arg2 = 0 ;
17361 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17362 int arg4 = (int) -1 ;
17363 bool result;
17364 void *argp1 = 0 ;
17365 int res1 = 0 ;
17366 bool temp2 = false ;
17367 long val3 ;
17368 int ecode3 = 0 ;
17369 int val4 ;
17370 int ecode4 = 0 ;
17371 PyObject * obj0 = 0 ;
17372 PyObject * obj1 = 0 ;
17373 PyObject * obj2 = 0 ;
17374 PyObject * obj3 = 0 ;
17375 char * kwnames[] = {
17376 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17377 };
17378
17379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17381 if (!SWIG_IsOK(res1)) {
17382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17383 }
17384 arg1 = reinterpret_cast< wxImage * >(argp1);
17385 {
17386 arg2 = wxString_in_helper(obj1);
17387 if (arg2 == NULL) SWIG_fail;
17388 temp2 = true;
17389 }
17390 if (obj2) {
17391 ecode3 = SWIG_AsVal_long(obj2, &val3);
17392 if (!SWIG_IsOK(ecode3)) {
17393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17394 }
17395 arg3 = static_cast< long >(val3);
17396 }
17397 if (obj3) {
17398 ecode4 = SWIG_AsVal_int(obj3, &val4);
17399 if (!SWIG_IsOK(ecode4)) {
17400 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17401 }
17402 arg4 = static_cast< int >(val4);
17403 }
17404 {
17405 PyThreadState* __tstate = wxPyBeginAllowThreads();
17406 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17407 wxPyEndAllowThreads(__tstate);
17408 if (PyErr_Occurred()) SWIG_fail;
17409 }
17410 {
17411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17412 }
17413 {
17414 if (temp2)
17415 delete arg2;
17416 }
17417 return resultobj;
17418 fail:
17419 {
17420 if (temp2)
17421 delete arg2;
17422 }
17423 return NULL;
17424 }
17425
17426
17427 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17428 PyObject *resultobj = 0;
17429 wxImage *arg1 = (wxImage *) 0 ;
17430 wxString *arg2 = 0 ;
17431 wxString *arg3 = 0 ;
17432 int arg4 = (int) -1 ;
17433 bool result;
17434 void *argp1 = 0 ;
17435 int res1 = 0 ;
17436 bool temp2 = false ;
17437 bool temp3 = false ;
17438 int val4 ;
17439 int ecode4 = 0 ;
17440 PyObject * obj0 = 0 ;
17441 PyObject * obj1 = 0 ;
17442 PyObject * obj2 = 0 ;
17443 PyObject * obj3 = 0 ;
17444 char * kwnames[] = {
17445 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17446 };
17447
17448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17450 if (!SWIG_IsOK(res1)) {
17451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17452 }
17453 arg1 = reinterpret_cast< wxImage * >(argp1);
17454 {
17455 arg2 = wxString_in_helper(obj1);
17456 if (arg2 == NULL) SWIG_fail;
17457 temp2 = true;
17458 }
17459 {
17460 arg3 = wxString_in_helper(obj2);
17461 if (arg3 == NULL) SWIG_fail;
17462 temp3 = true;
17463 }
17464 if (obj3) {
17465 ecode4 = SWIG_AsVal_int(obj3, &val4);
17466 if (!SWIG_IsOK(ecode4)) {
17467 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17468 }
17469 arg4 = static_cast< int >(val4);
17470 }
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 {
17478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17479 }
17480 {
17481 if (temp2)
17482 delete arg2;
17483 }
17484 {
17485 if (temp3)
17486 delete arg3;
17487 }
17488 return resultobj;
17489 fail:
17490 {
17491 if (temp2)
17492 delete arg2;
17493 }
17494 {
17495 if (temp3)
17496 delete arg3;
17497 }
17498 return NULL;
17499 }
17500
17501
17502 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17503 PyObject *resultobj = 0;
17504 wxImage *arg1 = (wxImage *) 0 ;
17505 wxString *arg2 = 0 ;
17506 int arg3 ;
17507 bool result;
17508 void *argp1 = 0 ;
17509 int res1 = 0 ;
17510 bool temp2 = false ;
17511 int val3 ;
17512 int ecode3 = 0 ;
17513 PyObject * obj0 = 0 ;
17514 PyObject * obj1 = 0 ;
17515 PyObject * obj2 = 0 ;
17516 char * kwnames[] = {
17517 (char *) "self",(char *) "name",(char *) "type", NULL
17518 };
17519
17520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17522 if (!SWIG_IsOK(res1)) {
17523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17524 }
17525 arg1 = reinterpret_cast< wxImage * >(argp1);
17526 {
17527 arg2 = wxString_in_helper(obj1);
17528 if (arg2 == NULL) SWIG_fail;
17529 temp2 = true;
17530 }
17531 ecode3 = SWIG_AsVal_int(obj2, &val3);
17532 if (!SWIG_IsOK(ecode3)) {
17533 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17534 }
17535 arg3 = static_cast< int >(val3);
17536 {
17537 PyThreadState* __tstate = wxPyBeginAllowThreads();
17538 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17539 wxPyEndAllowThreads(__tstate);
17540 if (PyErr_Occurred()) SWIG_fail;
17541 }
17542 {
17543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17544 }
17545 {
17546 if (temp2)
17547 delete arg2;
17548 }
17549 return resultobj;
17550 fail:
17551 {
17552 if (temp2)
17553 delete arg2;
17554 }
17555 return NULL;
17556 }
17557
17558
17559 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17560 PyObject *resultobj = 0;
17561 wxImage *arg1 = (wxImage *) 0 ;
17562 wxString *arg2 = 0 ;
17563 wxString *arg3 = 0 ;
17564 bool result;
17565 void *argp1 = 0 ;
17566 int res1 = 0 ;
17567 bool temp2 = false ;
17568 bool temp3 = false ;
17569 PyObject * obj0 = 0 ;
17570 PyObject * obj1 = 0 ;
17571 PyObject * obj2 = 0 ;
17572 char * kwnames[] = {
17573 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17574 };
17575
17576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17578 if (!SWIG_IsOK(res1)) {
17579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17580 }
17581 arg1 = reinterpret_cast< wxImage * >(argp1);
17582 {
17583 arg2 = wxString_in_helper(obj1);
17584 if (arg2 == NULL) SWIG_fail;
17585 temp2 = true;
17586 }
17587 {
17588 arg3 = wxString_in_helper(obj2);
17589 if (arg3 == NULL) SWIG_fail;
17590 temp3 = true;
17591 }
17592 {
17593 PyThreadState* __tstate = wxPyBeginAllowThreads();
17594 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17595 wxPyEndAllowThreads(__tstate);
17596 if (PyErr_Occurred()) SWIG_fail;
17597 }
17598 {
17599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17600 }
17601 {
17602 if (temp2)
17603 delete arg2;
17604 }
17605 {
17606 if (temp3)
17607 delete arg3;
17608 }
17609 return resultobj;
17610 fail:
17611 {
17612 if (temp2)
17613 delete arg2;
17614 }
17615 {
17616 if (temp3)
17617 delete arg3;
17618 }
17619 return NULL;
17620 }
17621
17622
17623 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17624 PyObject *resultobj = 0;
17625 wxInputStream *arg1 = 0 ;
17626 bool result;
17627 wxPyInputStream *temp1 ;
17628 bool created1 ;
17629 PyObject * obj0 = 0 ;
17630 char * kwnames[] = {
17631 (char *) "stream", NULL
17632 };
17633
17634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17635 {
17636 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17637 arg1 = temp1->m_wxis;
17638 created1 = false;
17639 } else {
17640 PyErr_Clear(); // clear the failure of the wxPyConvert above
17641 arg1 = wxPyCBInputStream_create(obj0, false);
17642 if (arg1 == NULL) {
17643 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17644 SWIG_fail;
17645 }
17646 created1 = true;
17647 }
17648 }
17649 {
17650 PyThreadState* __tstate = wxPyBeginAllowThreads();
17651 result = (bool)wxImage::CanRead(*arg1);
17652 wxPyEndAllowThreads(__tstate);
17653 if (PyErr_Occurred()) SWIG_fail;
17654 }
17655 {
17656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17657 }
17658 {
17659 if (created1) delete arg1;
17660 }
17661 return resultobj;
17662 fail:
17663 {
17664 if (created1) delete arg1;
17665 }
17666 return NULL;
17667 }
17668
17669
17670 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17671 PyObject *resultobj = 0;
17672 wxImage *arg1 = (wxImage *) 0 ;
17673 wxInputStream *arg2 = 0 ;
17674 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17675 int arg4 = (int) -1 ;
17676 bool result;
17677 void *argp1 = 0 ;
17678 int res1 = 0 ;
17679 wxPyInputStream *temp2 ;
17680 bool created2 ;
17681 long val3 ;
17682 int ecode3 = 0 ;
17683 int val4 ;
17684 int ecode4 = 0 ;
17685 PyObject * obj0 = 0 ;
17686 PyObject * obj1 = 0 ;
17687 PyObject * obj2 = 0 ;
17688 PyObject * obj3 = 0 ;
17689 char * kwnames[] = {
17690 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17691 };
17692
17693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17695 if (!SWIG_IsOK(res1)) {
17696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17697 }
17698 arg1 = reinterpret_cast< wxImage * >(argp1);
17699 {
17700 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17701 arg2 = temp2->m_wxis;
17702 created2 = false;
17703 } else {
17704 PyErr_Clear(); // clear the failure of the wxPyConvert above
17705 arg2 = wxPyCBInputStream_create(obj1, false);
17706 if (arg2 == NULL) {
17707 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17708 SWIG_fail;
17709 }
17710 created2 = true;
17711 }
17712 }
17713 if (obj2) {
17714 ecode3 = SWIG_AsVal_long(obj2, &val3);
17715 if (!SWIG_IsOK(ecode3)) {
17716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17717 }
17718 arg3 = static_cast< long >(val3);
17719 }
17720 if (obj3) {
17721 ecode4 = SWIG_AsVal_int(obj3, &val4);
17722 if (!SWIG_IsOK(ecode4)) {
17723 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17724 }
17725 arg4 = static_cast< int >(val4);
17726 }
17727 {
17728 PyThreadState* __tstate = wxPyBeginAllowThreads();
17729 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17730 wxPyEndAllowThreads(__tstate);
17731 if (PyErr_Occurred()) SWIG_fail;
17732 }
17733 {
17734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17735 }
17736 {
17737 if (created2) delete arg2;
17738 }
17739 return resultobj;
17740 fail:
17741 {
17742 if (created2) delete arg2;
17743 }
17744 return NULL;
17745 }
17746
17747
17748 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17749 PyObject *resultobj = 0;
17750 wxImage *arg1 = (wxImage *) 0 ;
17751 wxInputStream *arg2 = 0 ;
17752 wxString *arg3 = 0 ;
17753 int arg4 = (int) -1 ;
17754 bool result;
17755 void *argp1 = 0 ;
17756 int res1 = 0 ;
17757 wxPyInputStream *temp2 ;
17758 bool created2 ;
17759 bool temp3 = false ;
17760 int val4 ;
17761 int ecode4 = 0 ;
17762 PyObject * obj0 = 0 ;
17763 PyObject * obj1 = 0 ;
17764 PyObject * obj2 = 0 ;
17765 PyObject * obj3 = 0 ;
17766 char * kwnames[] = {
17767 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17768 };
17769
17770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17772 if (!SWIG_IsOK(res1)) {
17773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17774 }
17775 arg1 = reinterpret_cast< wxImage * >(argp1);
17776 {
17777 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17778 arg2 = temp2->m_wxis;
17779 created2 = false;
17780 } else {
17781 PyErr_Clear(); // clear the failure of the wxPyConvert above
17782 arg2 = wxPyCBInputStream_create(obj1, false);
17783 if (arg2 == NULL) {
17784 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17785 SWIG_fail;
17786 }
17787 created2 = true;
17788 }
17789 }
17790 {
17791 arg3 = wxString_in_helper(obj2);
17792 if (arg3 == NULL) SWIG_fail;
17793 temp3 = true;
17794 }
17795 if (obj3) {
17796 ecode4 = SWIG_AsVal_int(obj3, &val4);
17797 if (!SWIG_IsOK(ecode4)) {
17798 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17799 }
17800 arg4 = static_cast< int >(val4);
17801 }
17802 {
17803 PyThreadState* __tstate = wxPyBeginAllowThreads();
17804 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17805 wxPyEndAllowThreads(__tstate);
17806 if (PyErr_Occurred()) SWIG_fail;
17807 }
17808 {
17809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17810 }
17811 {
17812 if (created2) delete arg2;
17813 }
17814 {
17815 if (temp3)
17816 delete arg3;
17817 }
17818 return resultobj;
17819 fail:
17820 {
17821 if (created2) delete arg2;
17822 }
17823 {
17824 if (temp3)
17825 delete arg3;
17826 }
17827 return NULL;
17828 }
17829
17830
17831 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17832 PyObject *resultobj = 0;
17833 wxImage *arg1 = (wxImage *) 0 ;
17834 bool result;
17835 void *argp1 = 0 ;
17836 int res1 = 0 ;
17837 PyObject *swig_obj[1] ;
17838
17839 if (!args) SWIG_fail;
17840 swig_obj[0] = args;
17841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17842 if (!SWIG_IsOK(res1)) {
17843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17844 }
17845 arg1 = reinterpret_cast< wxImage * >(argp1);
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 result = (bool)(arg1)->IsOk();
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 {
17853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17854 }
17855 return resultobj;
17856 fail:
17857 return NULL;
17858 }
17859
17860
17861 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17862 PyObject *resultobj = 0;
17863 wxImage *arg1 = (wxImage *) 0 ;
17864 int result;
17865 void *argp1 = 0 ;
17866 int res1 = 0 ;
17867 PyObject *swig_obj[1] ;
17868
17869 if (!args) SWIG_fail;
17870 swig_obj[0] = args;
17871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17872 if (!SWIG_IsOK(res1)) {
17873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17874 }
17875 arg1 = reinterpret_cast< wxImage * >(argp1);
17876 {
17877 PyThreadState* __tstate = wxPyBeginAllowThreads();
17878 result = (int)(arg1)->GetWidth();
17879 wxPyEndAllowThreads(__tstate);
17880 if (PyErr_Occurred()) SWIG_fail;
17881 }
17882 resultobj = SWIG_From_int(static_cast< int >(result));
17883 return resultobj;
17884 fail:
17885 return NULL;
17886 }
17887
17888
17889 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17890 PyObject *resultobj = 0;
17891 wxImage *arg1 = (wxImage *) 0 ;
17892 int result;
17893 void *argp1 = 0 ;
17894 int res1 = 0 ;
17895 PyObject *swig_obj[1] ;
17896
17897 if (!args) SWIG_fail;
17898 swig_obj[0] = args;
17899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17900 if (!SWIG_IsOK(res1)) {
17901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17902 }
17903 arg1 = reinterpret_cast< wxImage * >(argp1);
17904 {
17905 PyThreadState* __tstate = wxPyBeginAllowThreads();
17906 result = (int)(arg1)->GetHeight();
17907 wxPyEndAllowThreads(__tstate);
17908 if (PyErr_Occurred()) SWIG_fail;
17909 }
17910 resultobj = SWIG_From_int(static_cast< int >(result));
17911 return resultobj;
17912 fail:
17913 return NULL;
17914 }
17915
17916
17917 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17918 PyObject *resultobj = 0;
17919 wxImage *arg1 = (wxImage *) 0 ;
17920 wxSize result;
17921 void *argp1 = 0 ;
17922 int res1 = 0 ;
17923 PyObject *swig_obj[1] ;
17924
17925 if (!args) SWIG_fail;
17926 swig_obj[0] = args;
17927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17928 if (!SWIG_IsOK(res1)) {
17929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17930 }
17931 arg1 = reinterpret_cast< wxImage * >(argp1);
17932 {
17933 PyThreadState* __tstate = wxPyBeginAllowThreads();
17934 result = wxImage_GetSize(arg1);
17935 wxPyEndAllowThreads(__tstate);
17936 if (PyErr_Occurred()) SWIG_fail;
17937 }
17938 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17939 return resultobj;
17940 fail:
17941 return NULL;
17942 }
17943
17944
17945 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17946 PyObject *resultobj = 0;
17947 wxImage *arg1 = (wxImage *) 0 ;
17948 wxRect *arg2 = 0 ;
17949 SwigValueWrapper<wxImage > result;
17950 void *argp1 = 0 ;
17951 int res1 = 0 ;
17952 wxRect temp2 ;
17953 PyObject * obj0 = 0 ;
17954 PyObject * obj1 = 0 ;
17955 char * kwnames[] = {
17956 (char *) "self",(char *) "rect", NULL
17957 };
17958
17959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17961 if (!SWIG_IsOK(res1)) {
17962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17963 }
17964 arg1 = reinterpret_cast< wxImage * >(argp1);
17965 {
17966 arg2 = &temp2;
17967 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17968 }
17969 {
17970 PyThreadState* __tstate = wxPyBeginAllowThreads();
17971 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17976 return resultobj;
17977 fail:
17978 return NULL;
17979 }
17980
17981
17982 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17983 PyObject *resultobj = 0;
17984 wxImage *arg1 = (wxImage *) 0 ;
17985 wxSize *arg2 = 0 ;
17986 wxPoint *arg3 = 0 ;
17987 int arg4 = (int) -1 ;
17988 int arg5 = (int) -1 ;
17989 int arg6 = (int) -1 ;
17990 SwigValueWrapper<wxImage > result;
17991 void *argp1 = 0 ;
17992 int res1 = 0 ;
17993 wxSize temp2 ;
17994 wxPoint temp3 ;
17995 int val4 ;
17996 int ecode4 = 0 ;
17997 int val5 ;
17998 int ecode5 = 0 ;
17999 int val6 ;
18000 int ecode6 = 0 ;
18001 PyObject * obj0 = 0 ;
18002 PyObject * obj1 = 0 ;
18003 PyObject * obj2 = 0 ;
18004 PyObject * obj3 = 0 ;
18005 PyObject * obj4 = 0 ;
18006 PyObject * obj5 = 0 ;
18007 char * kwnames[] = {
18008 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18009 };
18010
18011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18013 if (!SWIG_IsOK(res1)) {
18014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18015 }
18016 arg1 = reinterpret_cast< wxImage * >(argp1);
18017 {
18018 arg2 = &temp2;
18019 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18020 }
18021 {
18022 arg3 = &temp3;
18023 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18024 }
18025 if (obj3) {
18026 ecode4 = SWIG_AsVal_int(obj3, &val4);
18027 if (!SWIG_IsOK(ecode4)) {
18028 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18029 }
18030 arg4 = static_cast< int >(val4);
18031 }
18032 if (obj4) {
18033 ecode5 = SWIG_AsVal_int(obj4, &val5);
18034 if (!SWIG_IsOK(ecode5)) {
18035 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18036 }
18037 arg5 = static_cast< int >(val5);
18038 }
18039 if (obj5) {
18040 ecode6 = SWIG_AsVal_int(obj5, &val6);
18041 if (!SWIG_IsOK(ecode6)) {
18042 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18043 }
18044 arg6 = static_cast< int >(val6);
18045 }
18046 {
18047 PyThreadState* __tstate = wxPyBeginAllowThreads();
18048 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18053 return resultobj;
18054 fail:
18055 return NULL;
18056 }
18057
18058
18059 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18060 PyObject *resultobj = 0;
18061 wxImage *arg1 = (wxImage *) 0 ;
18062 SwigValueWrapper<wxImage > result;
18063 void *argp1 = 0 ;
18064 int res1 = 0 ;
18065 PyObject *swig_obj[1] ;
18066
18067 if (!args) SWIG_fail;
18068 swig_obj[0] = args;
18069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18070 if (!SWIG_IsOK(res1)) {
18071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18072 }
18073 arg1 = reinterpret_cast< wxImage * >(argp1);
18074 {
18075 PyThreadState* __tstate = wxPyBeginAllowThreads();
18076 result = (arg1)->Copy();
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18081 return resultobj;
18082 fail:
18083 return NULL;
18084 }
18085
18086
18087 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18088 PyObject *resultobj = 0;
18089 wxImage *arg1 = (wxImage *) 0 ;
18090 wxImage *arg2 = 0 ;
18091 int arg3 ;
18092 int arg4 ;
18093 void *argp1 = 0 ;
18094 int res1 = 0 ;
18095 void *argp2 = 0 ;
18096 int res2 = 0 ;
18097 int val3 ;
18098 int ecode3 = 0 ;
18099 int val4 ;
18100 int ecode4 = 0 ;
18101 PyObject * obj0 = 0 ;
18102 PyObject * obj1 = 0 ;
18103 PyObject * obj2 = 0 ;
18104 PyObject * obj3 = 0 ;
18105 char * kwnames[] = {
18106 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18107 };
18108
18109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18111 if (!SWIG_IsOK(res1)) {
18112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18113 }
18114 arg1 = reinterpret_cast< wxImage * >(argp1);
18115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18116 if (!SWIG_IsOK(res2)) {
18117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18118 }
18119 if (!argp2) {
18120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18121 }
18122 arg2 = reinterpret_cast< wxImage * >(argp2);
18123 ecode3 = SWIG_AsVal_int(obj2, &val3);
18124 if (!SWIG_IsOK(ecode3)) {
18125 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18126 }
18127 arg3 = static_cast< int >(val3);
18128 ecode4 = SWIG_AsVal_int(obj3, &val4);
18129 if (!SWIG_IsOK(ecode4)) {
18130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18131 }
18132 arg4 = static_cast< int >(val4);
18133 {
18134 PyThreadState* __tstate = wxPyBeginAllowThreads();
18135 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18136 wxPyEndAllowThreads(__tstate);
18137 if (PyErr_Occurred()) SWIG_fail;
18138 }
18139 resultobj = SWIG_Py_Void();
18140 return resultobj;
18141 fail:
18142 return NULL;
18143 }
18144
18145
18146 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18147 PyObject *resultobj = 0;
18148 wxImage *arg1 = (wxImage *) 0 ;
18149 PyObject *result = 0 ;
18150 void *argp1 = 0 ;
18151 int res1 = 0 ;
18152 PyObject *swig_obj[1] ;
18153
18154 if (!args) SWIG_fail;
18155 swig_obj[0] = args;
18156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18157 if (!SWIG_IsOK(res1)) {
18158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18159 }
18160 arg1 = reinterpret_cast< wxImage * >(argp1);
18161 {
18162 PyThreadState* __tstate = wxPyBeginAllowThreads();
18163 result = (PyObject *)wxImage_GetData(arg1);
18164 wxPyEndAllowThreads(__tstate);
18165 if (PyErr_Occurred()) SWIG_fail;
18166 }
18167 resultobj = result;
18168 return resultobj;
18169 fail:
18170 return NULL;
18171 }
18172
18173
18174 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18175 PyObject *resultobj = 0;
18176 wxImage *arg1 = (wxImage *) 0 ;
18177 buffer arg2 ;
18178 int arg3 ;
18179 void *argp1 = 0 ;
18180 int res1 = 0 ;
18181 Py_ssize_t temp2 ;
18182 PyObject * obj0 = 0 ;
18183 PyObject * obj1 = 0 ;
18184 char * kwnames[] = {
18185 (char *) "self",(char *) "data", NULL
18186 };
18187
18188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18190 if (!SWIG_IsOK(res1)) {
18191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18192 }
18193 arg1 = reinterpret_cast< wxImage * >(argp1);
18194 {
18195 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18196 arg3 = (int)temp2;
18197 }
18198 {
18199 PyThreadState* __tstate = wxPyBeginAllowThreads();
18200 wxImage_SetData(arg1,arg2,arg3);
18201 wxPyEndAllowThreads(__tstate);
18202 if (PyErr_Occurred()) SWIG_fail;
18203 }
18204 resultobj = SWIG_Py_Void();
18205 return resultobj;
18206 fail:
18207 return NULL;
18208 }
18209
18210
18211 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18212 PyObject *resultobj = 0;
18213 wxImage *arg1 = (wxImage *) 0 ;
18214 PyObject *result = 0 ;
18215 void *argp1 = 0 ;
18216 int res1 = 0 ;
18217 PyObject *swig_obj[1] ;
18218
18219 if (!args) SWIG_fail;
18220 swig_obj[0] = args;
18221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18222 if (!SWIG_IsOK(res1)) {
18223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18224 }
18225 arg1 = reinterpret_cast< wxImage * >(argp1);
18226 {
18227 PyThreadState* __tstate = wxPyBeginAllowThreads();
18228 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18229 wxPyEndAllowThreads(__tstate);
18230 if (PyErr_Occurred()) SWIG_fail;
18231 }
18232 resultobj = result;
18233 return resultobj;
18234 fail:
18235 return NULL;
18236 }
18237
18238
18239 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18240 PyObject *resultobj = 0;
18241 wxImage *arg1 = (wxImage *) 0 ;
18242 buffer arg2 ;
18243 int arg3 ;
18244 void *argp1 = 0 ;
18245 int res1 = 0 ;
18246 Py_ssize_t temp2 ;
18247 PyObject * obj0 = 0 ;
18248 PyObject * obj1 = 0 ;
18249 char * kwnames[] = {
18250 (char *) "self",(char *) "data", NULL
18251 };
18252
18253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18255 if (!SWIG_IsOK(res1)) {
18256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18257 }
18258 arg1 = reinterpret_cast< wxImage * >(argp1);
18259 {
18260 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18261 arg3 = (int)temp2;
18262 }
18263 {
18264 PyThreadState* __tstate = wxPyBeginAllowThreads();
18265 wxImage_SetDataBuffer(arg1,arg2,arg3);
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 resultobj = SWIG_Py_Void();
18270 return resultobj;
18271 fail:
18272 return NULL;
18273 }
18274
18275
18276 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18277 PyObject *resultobj = 0;
18278 wxImage *arg1 = (wxImage *) 0 ;
18279 PyObject *result = 0 ;
18280 void *argp1 = 0 ;
18281 int res1 = 0 ;
18282 PyObject *swig_obj[1] ;
18283
18284 if (!args) SWIG_fail;
18285 swig_obj[0] = args;
18286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18287 if (!SWIG_IsOK(res1)) {
18288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18289 }
18290 arg1 = reinterpret_cast< wxImage * >(argp1);
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (PyObject *)wxImage_GetAlphaData(arg1);
18294 wxPyEndAllowThreads(__tstate);
18295 if (PyErr_Occurred()) SWIG_fail;
18296 }
18297 resultobj = result;
18298 return resultobj;
18299 fail:
18300 return NULL;
18301 }
18302
18303
18304 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18305 PyObject *resultobj = 0;
18306 wxImage *arg1 = (wxImage *) 0 ;
18307 buffer arg2 ;
18308 int arg3 ;
18309 void *argp1 = 0 ;
18310 int res1 = 0 ;
18311 Py_ssize_t temp2 ;
18312 PyObject * obj0 = 0 ;
18313 PyObject * obj1 = 0 ;
18314 char * kwnames[] = {
18315 (char *) "self",(char *) "alpha", NULL
18316 };
18317
18318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18320 if (!SWIG_IsOK(res1)) {
18321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18322 }
18323 arg1 = reinterpret_cast< wxImage * >(argp1);
18324 {
18325 if (obj1 != Py_None) {
18326 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18327 arg3 = (int)temp2;
18328 }
18329 }
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 wxImage_SetAlphaData(arg1,arg2,arg3);
18333 wxPyEndAllowThreads(__tstate);
18334 if (PyErr_Occurred()) SWIG_fail;
18335 }
18336 resultobj = SWIG_Py_Void();
18337 return resultobj;
18338 fail:
18339 return NULL;
18340 }
18341
18342
18343 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18344 PyObject *resultobj = 0;
18345 wxImage *arg1 = (wxImage *) 0 ;
18346 PyObject *result = 0 ;
18347 void *argp1 = 0 ;
18348 int res1 = 0 ;
18349 PyObject *swig_obj[1] ;
18350
18351 if (!args) SWIG_fail;
18352 swig_obj[0] = args;
18353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18354 if (!SWIG_IsOK(res1)) {
18355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18356 }
18357 arg1 = reinterpret_cast< wxImage * >(argp1);
18358 {
18359 PyThreadState* __tstate = wxPyBeginAllowThreads();
18360 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18361 wxPyEndAllowThreads(__tstate);
18362 if (PyErr_Occurred()) SWIG_fail;
18363 }
18364 resultobj = result;
18365 return resultobj;
18366 fail:
18367 return NULL;
18368 }
18369
18370
18371 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18372 PyObject *resultobj = 0;
18373 wxImage *arg1 = (wxImage *) 0 ;
18374 buffer arg2 ;
18375 int arg3 ;
18376 void *argp1 = 0 ;
18377 int res1 = 0 ;
18378 Py_ssize_t temp2 ;
18379 PyObject * obj0 = 0 ;
18380 PyObject * obj1 = 0 ;
18381 char * kwnames[] = {
18382 (char *) "self",(char *) "alpha", NULL
18383 };
18384
18385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18387 if (!SWIG_IsOK(res1)) {
18388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18389 }
18390 arg1 = reinterpret_cast< wxImage * >(argp1);
18391 {
18392 if (obj1 != Py_None) {
18393 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18394 arg3 = (int)temp2;
18395 }
18396 }
18397 {
18398 PyThreadState* __tstate = wxPyBeginAllowThreads();
18399 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 resultobj = SWIG_Py_Void();
18404 return resultobj;
18405 fail:
18406 return NULL;
18407 }
18408
18409
18410 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18411 PyObject *resultobj = 0;
18412 wxImage *arg1 = (wxImage *) 0 ;
18413 byte arg2 ;
18414 byte arg3 ;
18415 byte arg4 ;
18416 void *argp1 = 0 ;
18417 int res1 = 0 ;
18418 unsigned char val2 ;
18419 int ecode2 = 0 ;
18420 unsigned char val3 ;
18421 int ecode3 = 0 ;
18422 unsigned char val4 ;
18423 int ecode4 = 0 ;
18424 PyObject * obj0 = 0 ;
18425 PyObject * obj1 = 0 ;
18426 PyObject * obj2 = 0 ;
18427 PyObject * obj3 = 0 ;
18428 char * kwnames[] = {
18429 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18430 };
18431
18432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18434 if (!SWIG_IsOK(res1)) {
18435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18436 }
18437 arg1 = reinterpret_cast< wxImage * >(argp1);
18438 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18439 if (!SWIG_IsOK(ecode2)) {
18440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18441 }
18442 arg2 = static_cast< byte >(val2);
18443 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18444 if (!SWIG_IsOK(ecode3)) {
18445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18446 }
18447 arg3 = static_cast< byte >(val3);
18448 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18449 if (!SWIG_IsOK(ecode4)) {
18450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18451 }
18452 arg4 = static_cast< byte >(val4);
18453 {
18454 PyThreadState* __tstate = wxPyBeginAllowThreads();
18455 (arg1)->SetMaskColour(arg2,arg3,arg4);
18456 wxPyEndAllowThreads(__tstate);
18457 if (PyErr_Occurred()) SWIG_fail;
18458 }
18459 resultobj = SWIG_Py_Void();
18460 return resultobj;
18461 fail:
18462 return NULL;
18463 }
18464
18465
18466 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18467 PyObject *resultobj = 0;
18468 wxImage *arg1 = (wxImage *) 0 ;
18469 byte *arg2 = (byte *) 0 ;
18470 byte *arg3 = (byte *) 0 ;
18471 byte *arg4 = (byte *) 0 ;
18472 void *argp1 = 0 ;
18473 int res1 = 0 ;
18474 byte temp2 ;
18475 int res2 = SWIG_TMPOBJ ;
18476 byte temp3 ;
18477 int res3 = SWIG_TMPOBJ ;
18478 byte temp4 ;
18479 int res4 = SWIG_TMPOBJ ;
18480 PyObject *swig_obj[1] ;
18481
18482 arg2 = &temp2;
18483 arg3 = &temp3;
18484 arg4 = &temp4;
18485 if (!args) SWIG_fail;
18486 swig_obj[0] = args;
18487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18488 if (!SWIG_IsOK(res1)) {
18489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18490 }
18491 arg1 = reinterpret_cast< wxImage * >(argp1);
18492 {
18493 PyThreadState* __tstate = wxPyBeginAllowThreads();
18494 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18495 wxPyEndAllowThreads(__tstate);
18496 if (PyErr_Occurred()) SWIG_fail;
18497 }
18498 resultobj = SWIG_Py_Void();
18499 if (SWIG_IsTmpObj(res2)) {
18500 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18501 } else {
18502 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18503 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18504 }
18505 if (SWIG_IsTmpObj(res3)) {
18506 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18507 } else {
18508 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18509 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18510 }
18511 if (SWIG_IsTmpObj(res4)) {
18512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18513 } else {
18514 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18516 }
18517 return resultobj;
18518 fail:
18519 return NULL;
18520 }
18521
18522
18523 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18524 PyObject *resultobj = 0;
18525 wxImage *arg1 = (wxImage *) 0 ;
18526 byte result;
18527 void *argp1 = 0 ;
18528 int res1 = 0 ;
18529 PyObject *swig_obj[1] ;
18530
18531 if (!args) SWIG_fail;
18532 swig_obj[0] = args;
18533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18534 if (!SWIG_IsOK(res1)) {
18535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18536 }
18537 arg1 = reinterpret_cast< wxImage * >(argp1);
18538 {
18539 PyThreadState* __tstate = wxPyBeginAllowThreads();
18540 result = (byte)(arg1)->GetMaskRed();
18541 wxPyEndAllowThreads(__tstate);
18542 if (PyErr_Occurred()) SWIG_fail;
18543 }
18544 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18545 return resultobj;
18546 fail:
18547 return NULL;
18548 }
18549
18550
18551 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18552 PyObject *resultobj = 0;
18553 wxImage *arg1 = (wxImage *) 0 ;
18554 byte result;
18555 void *argp1 = 0 ;
18556 int res1 = 0 ;
18557 PyObject *swig_obj[1] ;
18558
18559 if (!args) SWIG_fail;
18560 swig_obj[0] = args;
18561 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18562 if (!SWIG_IsOK(res1)) {
18563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18564 }
18565 arg1 = reinterpret_cast< wxImage * >(argp1);
18566 {
18567 PyThreadState* __tstate = wxPyBeginAllowThreads();
18568 result = (byte)(arg1)->GetMaskGreen();
18569 wxPyEndAllowThreads(__tstate);
18570 if (PyErr_Occurred()) SWIG_fail;
18571 }
18572 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18580 PyObject *resultobj = 0;
18581 wxImage *arg1 = (wxImage *) 0 ;
18582 byte result;
18583 void *argp1 = 0 ;
18584 int res1 = 0 ;
18585 PyObject *swig_obj[1] ;
18586
18587 if (!args) SWIG_fail;
18588 swig_obj[0] = args;
18589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18590 if (!SWIG_IsOK(res1)) {
18591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18592 }
18593 arg1 = reinterpret_cast< wxImage * >(argp1);
18594 {
18595 PyThreadState* __tstate = wxPyBeginAllowThreads();
18596 result = (byte)(arg1)->GetMaskBlue();
18597 wxPyEndAllowThreads(__tstate);
18598 if (PyErr_Occurred()) SWIG_fail;
18599 }
18600 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18601 return resultobj;
18602 fail:
18603 return NULL;
18604 }
18605
18606
18607 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18608 PyObject *resultobj = 0;
18609 wxImage *arg1 = (wxImage *) 0 ;
18610 bool arg2 = (bool) true ;
18611 void *argp1 = 0 ;
18612 int res1 = 0 ;
18613 bool val2 ;
18614 int ecode2 = 0 ;
18615 PyObject * obj0 = 0 ;
18616 PyObject * obj1 = 0 ;
18617 char * kwnames[] = {
18618 (char *) "self",(char *) "mask", NULL
18619 };
18620
18621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18625 }
18626 arg1 = reinterpret_cast< wxImage * >(argp1);
18627 if (obj1) {
18628 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18629 if (!SWIG_IsOK(ecode2)) {
18630 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18631 }
18632 arg2 = static_cast< bool >(val2);
18633 }
18634 {
18635 PyThreadState* __tstate = wxPyBeginAllowThreads();
18636 (arg1)->SetMask(arg2);
18637 wxPyEndAllowThreads(__tstate);
18638 if (PyErr_Occurred()) SWIG_fail;
18639 }
18640 resultobj = SWIG_Py_Void();
18641 return resultobj;
18642 fail:
18643 return NULL;
18644 }
18645
18646
18647 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18648 PyObject *resultobj = 0;
18649 wxImage *arg1 = (wxImage *) 0 ;
18650 bool result;
18651 void *argp1 = 0 ;
18652 int res1 = 0 ;
18653 PyObject *swig_obj[1] ;
18654
18655 if (!args) SWIG_fail;
18656 swig_obj[0] = args;
18657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18658 if (!SWIG_IsOK(res1)) {
18659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18660 }
18661 arg1 = reinterpret_cast< wxImage * >(argp1);
18662 {
18663 PyThreadState* __tstate = wxPyBeginAllowThreads();
18664 result = (bool)(arg1)->HasMask();
18665 wxPyEndAllowThreads(__tstate);
18666 if (PyErr_Occurred()) SWIG_fail;
18667 }
18668 {
18669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18670 }
18671 return resultobj;
18672 fail:
18673 return NULL;
18674 }
18675
18676
18677 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18678 PyObject *resultobj = 0;
18679 wxImage *arg1 = (wxImage *) 0 ;
18680 double arg2 ;
18681 wxPoint *arg3 = 0 ;
18682 bool arg4 = (bool) true ;
18683 wxPoint *arg5 = (wxPoint *) NULL ;
18684 SwigValueWrapper<wxImage > result;
18685 void *argp1 = 0 ;
18686 int res1 = 0 ;
18687 double val2 ;
18688 int ecode2 = 0 ;
18689 wxPoint temp3 ;
18690 bool val4 ;
18691 int ecode4 = 0 ;
18692 void *argp5 = 0 ;
18693 int res5 = 0 ;
18694 PyObject * obj0 = 0 ;
18695 PyObject * obj1 = 0 ;
18696 PyObject * obj2 = 0 ;
18697 PyObject * obj3 = 0 ;
18698 PyObject * obj4 = 0 ;
18699 char * kwnames[] = {
18700 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18701 };
18702
18703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18705 if (!SWIG_IsOK(res1)) {
18706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18707 }
18708 arg1 = reinterpret_cast< wxImage * >(argp1);
18709 ecode2 = SWIG_AsVal_double(obj1, &val2);
18710 if (!SWIG_IsOK(ecode2)) {
18711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18712 }
18713 arg2 = static_cast< double >(val2);
18714 {
18715 arg3 = &temp3;
18716 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18717 }
18718 if (obj3) {
18719 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18720 if (!SWIG_IsOK(ecode4)) {
18721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18722 }
18723 arg4 = static_cast< bool >(val4);
18724 }
18725 if (obj4) {
18726 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18727 if (!SWIG_IsOK(res5)) {
18728 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18729 }
18730 arg5 = reinterpret_cast< wxPoint * >(argp5);
18731 }
18732 {
18733 PyThreadState* __tstate = wxPyBeginAllowThreads();
18734 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18735 wxPyEndAllowThreads(__tstate);
18736 if (PyErr_Occurred()) SWIG_fail;
18737 }
18738 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18739 return resultobj;
18740 fail:
18741 return NULL;
18742 }
18743
18744
18745 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18746 PyObject *resultobj = 0;
18747 wxImage *arg1 = (wxImage *) 0 ;
18748 bool arg2 = (bool) true ;
18749 SwigValueWrapper<wxImage > result;
18750 void *argp1 = 0 ;
18751 int res1 = 0 ;
18752 bool val2 ;
18753 int ecode2 = 0 ;
18754 PyObject * obj0 = 0 ;
18755 PyObject * obj1 = 0 ;
18756 char * kwnames[] = {
18757 (char *) "self",(char *) "clockwise", NULL
18758 };
18759
18760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18762 if (!SWIG_IsOK(res1)) {
18763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18764 }
18765 arg1 = reinterpret_cast< wxImage * >(argp1);
18766 if (obj1) {
18767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18768 if (!SWIG_IsOK(ecode2)) {
18769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18770 }
18771 arg2 = static_cast< bool >(val2);
18772 }
18773 {
18774 PyThreadState* __tstate = wxPyBeginAllowThreads();
18775 result = (arg1)->Rotate90(arg2);
18776 wxPyEndAllowThreads(__tstate);
18777 if (PyErr_Occurred()) SWIG_fail;
18778 }
18779 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18780 return resultobj;
18781 fail:
18782 return NULL;
18783 }
18784
18785
18786 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18787 PyObject *resultobj = 0;
18788 wxImage *arg1 = (wxImage *) 0 ;
18789 bool arg2 = (bool) true ;
18790 SwigValueWrapper<wxImage > result;
18791 void *argp1 = 0 ;
18792 int res1 = 0 ;
18793 bool val2 ;
18794 int ecode2 = 0 ;
18795 PyObject * obj0 = 0 ;
18796 PyObject * obj1 = 0 ;
18797 char * kwnames[] = {
18798 (char *) "self",(char *) "horizontally", NULL
18799 };
18800
18801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18803 if (!SWIG_IsOK(res1)) {
18804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18805 }
18806 arg1 = reinterpret_cast< wxImage * >(argp1);
18807 if (obj1) {
18808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18809 if (!SWIG_IsOK(ecode2)) {
18810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18811 }
18812 arg2 = static_cast< bool >(val2);
18813 }
18814 {
18815 PyThreadState* __tstate = wxPyBeginAllowThreads();
18816 result = (arg1)->Mirror(arg2);
18817 wxPyEndAllowThreads(__tstate);
18818 if (PyErr_Occurred()) SWIG_fail;
18819 }
18820 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18821 return resultobj;
18822 fail:
18823 return NULL;
18824 }
18825
18826
18827 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18828 PyObject *resultobj = 0;
18829 wxImage *arg1 = (wxImage *) 0 ;
18830 byte arg2 ;
18831 byte arg3 ;
18832 byte arg4 ;
18833 byte arg5 ;
18834 byte arg6 ;
18835 byte arg7 ;
18836 void *argp1 = 0 ;
18837 int res1 = 0 ;
18838 unsigned char val2 ;
18839 int ecode2 = 0 ;
18840 unsigned char val3 ;
18841 int ecode3 = 0 ;
18842 unsigned char val4 ;
18843 int ecode4 = 0 ;
18844 unsigned char val5 ;
18845 int ecode5 = 0 ;
18846 unsigned char val6 ;
18847 int ecode6 = 0 ;
18848 unsigned char val7 ;
18849 int ecode7 = 0 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 PyObject * obj2 = 0 ;
18853 PyObject * obj3 = 0 ;
18854 PyObject * obj4 = 0 ;
18855 PyObject * obj5 = 0 ;
18856 PyObject * obj6 = 0 ;
18857 char * kwnames[] = {
18858 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18859 };
18860
18861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18863 if (!SWIG_IsOK(res1)) {
18864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18865 }
18866 arg1 = reinterpret_cast< wxImage * >(argp1);
18867 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18868 if (!SWIG_IsOK(ecode2)) {
18869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18870 }
18871 arg2 = static_cast< byte >(val2);
18872 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18873 if (!SWIG_IsOK(ecode3)) {
18874 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18875 }
18876 arg3 = static_cast< byte >(val3);
18877 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18878 if (!SWIG_IsOK(ecode4)) {
18879 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18880 }
18881 arg4 = static_cast< byte >(val4);
18882 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18883 if (!SWIG_IsOK(ecode5)) {
18884 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18885 }
18886 arg5 = static_cast< byte >(val5);
18887 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18888 if (!SWIG_IsOK(ecode6)) {
18889 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18890 }
18891 arg6 = static_cast< byte >(val6);
18892 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18893 if (!SWIG_IsOK(ecode7)) {
18894 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18895 }
18896 arg7 = static_cast< byte >(val7);
18897 {
18898 PyThreadState* __tstate = wxPyBeginAllowThreads();
18899 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18900 wxPyEndAllowThreads(__tstate);
18901 if (PyErr_Occurred()) SWIG_fail;
18902 }
18903 resultobj = SWIG_Py_Void();
18904 return resultobj;
18905 fail:
18906 return NULL;
18907 }
18908
18909
18910 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18911 PyObject *resultobj = 0;
18912 wxImage *arg1 = (wxImage *) 0 ;
18913 double arg2 = (double) 0.299 ;
18914 double arg3 = (double) 0.587 ;
18915 double arg4 = (double) 0.114 ;
18916 SwigValueWrapper<wxImage > result;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 double val2 ;
18920 int ecode2 = 0 ;
18921 double val3 ;
18922 int ecode3 = 0 ;
18923 double val4 ;
18924 int ecode4 = 0 ;
18925 PyObject * obj0 = 0 ;
18926 PyObject * obj1 = 0 ;
18927 PyObject * obj2 = 0 ;
18928 PyObject * obj3 = 0 ;
18929 char * kwnames[] = {
18930 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18931 };
18932
18933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18935 if (!SWIG_IsOK(res1)) {
18936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18937 }
18938 arg1 = reinterpret_cast< wxImage * >(argp1);
18939 if (obj1) {
18940 ecode2 = SWIG_AsVal_double(obj1, &val2);
18941 if (!SWIG_IsOK(ecode2)) {
18942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18943 }
18944 arg2 = static_cast< double >(val2);
18945 }
18946 if (obj2) {
18947 ecode3 = SWIG_AsVal_double(obj2, &val3);
18948 if (!SWIG_IsOK(ecode3)) {
18949 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18950 }
18951 arg3 = static_cast< double >(val3);
18952 }
18953 if (obj3) {
18954 ecode4 = SWIG_AsVal_double(obj3, &val4);
18955 if (!SWIG_IsOK(ecode4)) {
18956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18957 }
18958 arg4 = static_cast< double >(val4);
18959 }
18960 {
18961 PyThreadState* __tstate = wxPyBeginAllowThreads();
18962 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18963 wxPyEndAllowThreads(__tstate);
18964 if (PyErr_Occurred()) SWIG_fail;
18965 }
18966 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18974 PyObject *resultobj = 0;
18975 wxImage *arg1 = (wxImage *) 0 ;
18976 byte arg2 ;
18977 byte arg3 ;
18978 byte arg4 ;
18979 SwigValueWrapper<wxImage > result;
18980 void *argp1 = 0 ;
18981 int res1 = 0 ;
18982 unsigned char val2 ;
18983 int ecode2 = 0 ;
18984 unsigned char val3 ;
18985 int ecode3 = 0 ;
18986 unsigned char val4 ;
18987 int ecode4 = 0 ;
18988 PyObject * obj0 = 0 ;
18989 PyObject * obj1 = 0 ;
18990 PyObject * obj2 = 0 ;
18991 PyObject * obj3 = 0 ;
18992 char * kwnames[] = {
18993 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18994 };
18995
18996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18998 if (!SWIG_IsOK(res1)) {
18999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19000 }
19001 arg1 = reinterpret_cast< wxImage * >(argp1);
19002 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19003 if (!SWIG_IsOK(ecode2)) {
19004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19005 }
19006 arg2 = static_cast< byte >(val2);
19007 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19008 if (!SWIG_IsOK(ecode3)) {
19009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19010 }
19011 arg3 = static_cast< byte >(val3);
19012 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19013 if (!SWIG_IsOK(ecode4)) {
19014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19015 }
19016 arg4 = static_cast< byte >(val4);
19017 {
19018 PyThreadState* __tstate = wxPyBeginAllowThreads();
19019 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19020 wxPyEndAllowThreads(__tstate);
19021 if (PyErr_Occurred()) SWIG_fail;
19022 }
19023 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19024 return resultobj;
19025 fail:
19026 return NULL;
19027 }
19028
19029
19030 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19031 PyObject *resultobj = 0;
19032 wxImage *arg1 = (wxImage *) 0 ;
19033 wxString *arg2 = 0 ;
19034 wxString *arg3 = 0 ;
19035 void *argp1 = 0 ;
19036 int res1 = 0 ;
19037 bool temp2 = false ;
19038 bool temp3 = false ;
19039 PyObject * obj0 = 0 ;
19040 PyObject * obj1 = 0 ;
19041 PyObject * obj2 = 0 ;
19042 char * kwnames[] = {
19043 (char *) "self",(char *) "name",(char *) "value", NULL
19044 };
19045
19046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19050 }
19051 arg1 = reinterpret_cast< wxImage * >(argp1);
19052 {
19053 arg2 = wxString_in_helper(obj1);
19054 if (arg2 == NULL) SWIG_fail;
19055 temp2 = true;
19056 }
19057 {
19058 arg3 = wxString_in_helper(obj2);
19059 if (arg3 == NULL) SWIG_fail;
19060 temp3 = true;
19061 }
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19065 wxPyEndAllowThreads(__tstate);
19066 if (PyErr_Occurred()) SWIG_fail;
19067 }
19068 resultobj = SWIG_Py_Void();
19069 {
19070 if (temp2)
19071 delete arg2;
19072 }
19073 {
19074 if (temp3)
19075 delete arg3;
19076 }
19077 return resultobj;
19078 fail:
19079 {
19080 if (temp2)
19081 delete arg2;
19082 }
19083 {
19084 if (temp3)
19085 delete arg3;
19086 }
19087 return NULL;
19088 }
19089
19090
19091 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19092 PyObject *resultobj = 0;
19093 wxImage *arg1 = (wxImage *) 0 ;
19094 wxString *arg2 = 0 ;
19095 int arg3 ;
19096 void *argp1 = 0 ;
19097 int res1 = 0 ;
19098 bool temp2 = false ;
19099 int val3 ;
19100 int ecode3 = 0 ;
19101 PyObject * obj0 = 0 ;
19102 PyObject * obj1 = 0 ;
19103 PyObject * obj2 = 0 ;
19104 char * kwnames[] = {
19105 (char *) "self",(char *) "name",(char *) "value", NULL
19106 };
19107
19108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19110 if (!SWIG_IsOK(res1)) {
19111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19112 }
19113 arg1 = reinterpret_cast< wxImage * >(argp1);
19114 {
19115 arg2 = wxString_in_helper(obj1);
19116 if (arg2 == NULL) SWIG_fail;
19117 temp2 = true;
19118 }
19119 ecode3 = SWIG_AsVal_int(obj2, &val3);
19120 if (!SWIG_IsOK(ecode3)) {
19121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19122 }
19123 arg3 = static_cast< int >(val3);
19124 {
19125 PyThreadState* __tstate = wxPyBeginAllowThreads();
19126 (arg1)->SetOption((wxString const &)*arg2,arg3);
19127 wxPyEndAllowThreads(__tstate);
19128 if (PyErr_Occurred()) SWIG_fail;
19129 }
19130 resultobj = SWIG_Py_Void();
19131 {
19132 if (temp2)
19133 delete arg2;
19134 }
19135 return resultobj;
19136 fail:
19137 {
19138 if (temp2)
19139 delete arg2;
19140 }
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj = 0;
19147 wxImage *arg1 = (wxImage *) 0 ;
19148 wxString *arg2 = 0 ;
19149 wxString result;
19150 void *argp1 = 0 ;
19151 int res1 = 0 ;
19152 bool temp2 = false ;
19153 PyObject * obj0 = 0 ;
19154 PyObject * obj1 = 0 ;
19155 char * kwnames[] = {
19156 (char *) "self",(char *) "name", NULL
19157 };
19158
19159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19161 if (!SWIG_IsOK(res1)) {
19162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19163 }
19164 arg1 = reinterpret_cast< wxImage * >(argp1);
19165 {
19166 arg2 = wxString_in_helper(obj1);
19167 if (arg2 == NULL) SWIG_fail;
19168 temp2 = true;
19169 }
19170 {
19171 PyThreadState* __tstate = wxPyBeginAllowThreads();
19172 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19173 wxPyEndAllowThreads(__tstate);
19174 if (PyErr_Occurred()) SWIG_fail;
19175 }
19176 {
19177 #if wxUSE_UNICODE
19178 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19179 #else
19180 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19181 #endif
19182 }
19183 {
19184 if (temp2)
19185 delete arg2;
19186 }
19187 return resultobj;
19188 fail:
19189 {
19190 if (temp2)
19191 delete arg2;
19192 }
19193 return NULL;
19194 }
19195
19196
19197 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19198 PyObject *resultobj = 0;
19199 wxImage *arg1 = (wxImage *) 0 ;
19200 wxString *arg2 = 0 ;
19201 int result;
19202 void *argp1 = 0 ;
19203 int res1 = 0 ;
19204 bool temp2 = false ;
19205 PyObject * obj0 = 0 ;
19206 PyObject * obj1 = 0 ;
19207 char * kwnames[] = {
19208 (char *) "self",(char *) "name", NULL
19209 };
19210
19211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19213 if (!SWIG_IsOK(res1)) {
19214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19215 }
19216 arg1 = reinterpret_cast< wxImage * >(argp1);
19217 {
19218 arg2 = wxString_in_helper(obj1);
19219 if (arg2 == NULL) SWIG_fail;
19220 temp2 = true;
19221 }
19222 {
19223 PyThreadState* __tstate = wxPyBeginAllowThreads();
19224 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19225 wxPyEndAllowThreads(__tstate);
19226 if (PyErr_Occurred()) SWIG_fail;
19227 }
19228 resultobj = SWIG_From_int(static_cast< int >(result));
19229 {
19230 if (temp2)
19231 delete arg2;
19232 }
19233 return resultobj;
19234 fail:
19235 {
19236 if (temp2)
19237 delete arg2;
19238 }
19239 return NULL;
19240 }
19241
19242
19243 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19244 PyObject *resultobj = 0;
19245 wxImage *arg1 = (wxImage *) 0 ;
19246 wxString *arg2 = 0 ;
19247 bool result;
19248 void *argp1 = 0 ;
19249 int res1 = 0 ;
19250 bool temp2 = false ;
19251 PyObject * obj0 = 0 ;
19252 PyObject * obj1 = 0 ;
19253 char * kwnames[] = {
19254 (char *) "self",(char *) "name", NULL
19255 };
19256
19257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19259 if (!SWIG_IsOK(res1)) {
19260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19261 }
19262 arg1 = reinterpret_cast< wxImage * >(argp1);
19263 {
19264 arg2 = wxString_in_helper(obj1);
19265 if (arg2 == NULL) SWIG_fail;
19266 temp2 = true;
19267 }
19268 {
19269 PyThreadState* __tstate = wxPyBeginAllowThreads();
19270 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19271 wxPyEndAllowThreads(__tstate);
19272 if (PyErr_Occurred()) SWIG_fail;
19273 }
19274 {
19275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19276 }
19277 {
19278 if (temp2)
19279 delete arg2;
19280 }
19281 return resultobj;
19282 fail:
19283 {
19284 if (temp2)
19285 delete arg2;
19286 }
19287 return NULL;
19288 }
19289
19290
19291 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19292 PyObject *resultobj = 0;
19293 wxImage *arg1 = (wxImage *) 0 ;
19294 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19295 unsigned long result;
19296 void *argp1 = 0 ;
19297 int res1 = 0 ;
19298 unsigned long val2 ;
19299 int ecode2 = 0 ;
19300 PyObject * obj0 = 0 ;
19301 PyObject * obj1 = 0 ;
19302 char * kwnames[] = {
19303 (char *) "self",(char *) "stopafter", NULL
19304 };
19305
19306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19308 if (!SWIG_IsOK(res1)) {
19309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19310 }
19311 arg1 = reinterpret_cast< wxImage * >(argp1);
19312 if (obj1) {
19313 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19314 if (!SWIG_IsOK(ecode2)) {
19315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19316 }
19317 arg2 = static_cast< unsigned long >(val2);
19318 }
19319 {
19320 PyThreadState* __tstate = wxPyBeginAllowThreads();
19321 result = (unsigned long)(arg1)->CountColours(arg2);
19322 wxPyEndAllowThreads(__tstate);
19323 if (PyErr_Occurred()) SWIG_fail;
19324 }
19325 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19326 return resultobj;
19327 fail:
19328 return NULL;
19329 }
19330
19331
19332 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19333 PyObject *resultobj = 0;
19334 wxImage *arg1 = (wxImage *) 0 ;
19335 wxImageHistogram *arg2 = 0 ;
19336 unsigned long result;
19337 void *argp1 = 0 ;
19338 int res1 = 0 ;
19339 void *argp2 = 0 ;
19340 int res2 = 0 ;
19341 PyObject * obj0 = 0 ;
19342 PyObject * obj1 = 0 ;
19343 char * kwnames[] = {
19344 (char *) "self",(char *) "h", NULL
19345 };
19346
19347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19349 if (!SWIG_IsOK(res1)) {
19350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19351 }
19352 arg1 = reinterpret_cast< wxImage * >(argp1);
19353 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19354 if (!SWIG_IsOK(res2)) {
19355 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19356 }
19357 if (!argp2) {
19358 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19359 }
19360 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19361 {
19362 PyThreadState* __tstate = wxPyBeginAllowThreads();
19363 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19364 wxPyEndAllowThreads(__tstate);
19365 if (PyErr_Occurred()) SWIG_fail;
19366 }
19367 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19368 return resultobj;
19369 fail:
19370 return NULL;
19371 }
19372
19373
19374 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19375 PyObject *resultobj = 0;
19376 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19377 void *argp1 = 0 ;
19378 int res1 = 0 ;
19379 PyObject * obj0 = 0 ;
19380 char * kwnames[] = {
19381 (char *) "handler", NULL
19382 };
19383
19384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19386 if (!SWIG_IsOK(res1)) {
19387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19388 }
19389 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 wxImage::AddHandler(arg1);
19393 wxPyEndAllowThreads(__tstate);
19394 if (PyErr_Occurred()) SWIG_fail;
19395 }
19396 resultobj = SWIG_Py_Void();
19397 return resultobj;
19398 fail:
19399 return NULL;
19400 }
19401
19402
19403 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19406 void *argp1 = 0 ;
19407 int res1 = 0 ;
19408 PyObject * obj0 = 0 ;
19409 char * kwnames[] = {
19410 (char *) "handler", NULL
19411 };
19412
19413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19415 if (!SWIG_IsOK(res1)) {
19416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19417 }
19418 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19419 {
19420 PyThreadState* __tstate = wxPyBeginAllowThreads();
19421 wxImage::InsertHandler(arg1);
19422 wxPyEndAllowThreads(__tstate);
19423 if (PyErr_Occurred()) SWIG_fail;
19424 }
19425 resultobj = SWIG_Py_Void();
19426 return resultobj;
19427 fail:
19428 return NULL;
19429 }
19430
19431
19432 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19433 PyObject *resultobj = 0;
19434 wxString *arg1 = 0 ;
19435 bool result;
19436 bool temp1 = false ;
19437 PyObject * obj0 = 0 ;
19438 char * kwnames[] = {
19439 (char *) "name", NULL
19440 };
19441
19442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19443 {
19444 arg1 = wxString_in_helper(obj0);
19445 if (arg1 == NULL) SWIG_fail;
19446 temp1 = true;
19447 }
19448 {
19449 PyThreadState* __tstate = wxPyBeginAllowThreads();
19450 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19451 wxPyEndAllowThreads(__tstate);
19452 if (PyErr_Occurred()) SWIG_fail;
19453 }
19454 {
19455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19456 }
19457 {
19458 if (temp1)
19459 delete arg1;
19460 }
19461 return resultobj;
19462 fail:
19463 {
19464 if (temp1)
19465 delete arg1;
19466 }
19467 return NULL;
19468 }
19469
19470
19471 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19472 PyObject *resultobj = 0;
19473 PyObject *result = 0 ;
19474
19475 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19476 {
19477 PyThreadState* __tstate = wxPyBeginAllowThreads();
19478 result = (PyObject *)wxImage_GetHandlers();
19479 wxPyEndAllowThreads(__tstate);
19480 if (PyErr_Occurred()) SWIG_fail;
19481 }
19482 resultobj = result;
19483 return resultobj;
19484 fail:
19485 return NULL;
19486 }
19487
19488
19489 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19490 PyObject *resultobj = 0;
19491 wxString result;
19492
19493 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19494 {
19495 PyThreadState* __tstate = wxPyBeginAllowThreads();
19496 result = wxImage::GetImageExtWildcard();
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 {
19501 #if wxUSE_UNICODE
19502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19503 #else
19504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19505 #endif
19506 }
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19514 PyObject *resultobj = 0;
19515 wxImage *arg1 = (wxImage *) 0 ;
19516 int arg2 = (int) -1 ;
19517 wxBitmap result;
19518 void *argp1 = 0 ;
19519 int res1 = 0 ;
19520 int val2 ;
19521 int ecode2 = 0 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 char * kwnames[] = {
19525 (char *) "self",(char *) "depth", NULL
19526 };
19527
19528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19530 if (!SWIG_IsOK(res1)) {
19531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19532 }
19533 arg1 = reinterpret_cast< wxImage * >(argp1);
19534 if (obj1) {
19535 ecode2 = SWIG_AsVal_int(obj1, &val2);
19536 if (!SWIG_IsOK(ecode2)) {
19537 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19538 }
19539 arg2 = static_cast< int >(val2);
19540 }
19541 {
19542 if (!wxPyCheckForApp()) SWIG_fail;
19543 PyThreadState* __tstate = wxPyBeginAllowThreads();
19544 result = wxImage_ConvertToBitmap(arg1,arg2);
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj = 0;
19557 wxImage *arg1 = (wxImage *) 0 ;
19558 byte arg2 ;
19559 byte arg3 ;
19560 byte arg4 ;
19561 wxBitmap result;
19562 void *argp1 = 0 ;
19563 int res1 = 0 ;
19564 unsigned char val2 ;
19565 int ecode2 = 0 ;
19566 unsigned char val3 ;
19567 int ecode3 = 0 ;
19568 unsigned char val4 ;
19569 int ecode4 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 PyObject * obj2 = 0 ;
19573 PyObject * obj3 = 0 ;
19574 char * kwnames[] = {
19575 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19576 };
19577
19578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19580 if (!SWIG_IsOK(res1)) {
19581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19582 }
19583 arg1 = reinterpret_cast< wxImage * >(argp1);
19584 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19585 if (!SWIG_IsOK(ecode2)) {
19586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19587 }
19588 arg2 = static_cast< byte >(val2);
19589 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19590 if (!SWIG_IsOK(ecode3)) {
19591 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19592 }
19593 arg3 = static_cast< byte >(val3);
19594 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19595 if (!SWIG_IsOK(ecode4)) {
19596 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19597 }
19598 arg4 = static_cast< byte >(val4);
19599 {
19600 if (!wxPyCheckForApp()) SWIG_fail;
19601 PyThreadState* __tstate = wxPyBeginAllowThreads();
19602 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19603 wxPyEndAllowThreads(__tstate);
19604 if (PyErr_Occurred()) SWIG_fail;
19605 }
19606 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19607 return resultobj;
19608 fail:
19609 return NULL;
19610 }
19611
19612
19613 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19614 PyObject *resultobj = 0;
19615 wxImage *arg1 = (wxImage *) 0 ;
19616 double arg2 ;
19617 void *argp1 = 0 ;
19618 int res1 = 0 ;
19619 double val2 ;
19620 int ecode2 = 0 ;
19621 PyObject * obj0 = 0 ;
19622 PyObject * obj1 = 0 ;
19623 char * kwnames[] = {
19624 (char *) "self",(char *) "angle", NULL
19625 };
19626
19627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19629 if (!SWIG_IsOK(res1)) {
19630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19631 }
19632 arg1 = reinterpret_cast< wxImage * >(argp1);
19633 ecode2 = SWIG_AsVal_double(obj1, &val2);
19634 if (!SWIG_IsOK(ecode2)) {
19635 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19636 }
19637 arg2 = static_cast< double >(val2);
19638 {
19639 PyThreadState* __tstate = wxPyBeginAllowThreads();
19640 (arg1)->RotateHue(arg2);
19641 wxPyEndAllowThreads(__tstate);
19642 if (PyErr_Occurred()) SWIG_fail;
19643 }
19644 resultobj = SWIG_Py_Void();
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj = 0;
19653 wxImage_RGBValue arg1 ;
19654 wxImage_HSVValue result;
19655 void *argp1 ;
19656 int res1 = 0 ;
19657 PyObject * obj0 = 0 ;
19658 char * kwnames[] = {
19659 (char *) "rgb", NULL
19660 };
19661
19662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19663 {
19664 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19665 if (!SWIG_IsOK(res1)) {
19666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19667 }
19668 if (!argp1) {
19669 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19670 } else {
19671 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19672 arg1 = *temp;
19673 if (SWIG_IsNewObj(res1)) delete temp;
19674 }
19675 }
19676 {
19677 PyThreadState* __tstate = wxPyBeginAllowThreads();
19678 result = wxImage::RGBtoHSV(arg1);
19679 wxPyEndAllowThreads(__tstate);
19680 if (PyErr_Occurred()) SWIG_fail;
19681 }
19682 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19683 return resultobj;
19684 fail:
19685 return NULL;
19686 }
19687
19688
19689 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19690 PyObject *resultobj = 0;
19691 wxImage_HSVValue arg1 ;
19692 wxImage_RGBValue result;
19693 void *argp1 ;
19694 int res1 = 0 ;
19695 PyObject * obj0 = 0 ;
19696 char * kwnames[] = {
19697 (char *) "hsv", NULL
19698 };
19699
19700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19701 {
19702 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19703 if (!SWIG_IsOK(res1)) {
19704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19705 }
19706 if (!argp1) {
19707 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19708 } else {
19709 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19710 arg1 = *temp;
19711 if (SWIG_IsNewObj(res1)) delete temp;
19712 }
19713 }
19714 {
19715 PyThreadState* __tstate = wxPyBeginAllowThreads();
19716 result = wxImage::HSVtoRGB(arg1);
19717 wxPyEndAllowThreads(__tstate);
19718 if (PyErr_Occurred()) SWIG_fail;
19719 }
19720 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19721 return resultobj;
19722 fail:
19723 return NULL;
19724 }
19725
19726
19727 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19728 PyObject *obj;
19729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19730 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19731 return SWIG_Py_Void();
19732 }
19733
19734 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19735 return SWIG_Python_InitShadowInstance(args);
19736 }
19737
19738 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19739 PyObject *resultobj = 0;
19740 int arg1 ;
19741 int arg2 ;
19742 buffer arg3 ;
19743 int arg4 ;
19744 buffer arg5 = (buffer) NULL ;
19745 int arg6 = (int) 0 ;
19746 wxImage *result = 0 ;
19747 int val1 ;
19748 int ecode1 = 0 ;
19749 int val2 ;
19750 int ecode2 = 0 ;
19751 Py_ssize_t temp3 ;
19752 Py_ssize_t temp5 ;
19753 PyObject * obj0 = 0 ;
19754 PyObject * obj1 = 0 ;
19755 PyObject * obj2 = 0 ;
19756 PyObject * obj3 = 0 ;
19757 char * kwnames[] = {
19758 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19759 };
19760
19761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19762 ecode1 = SWIG_AsVal_int(obj0, &val1);
19763 if (!SWIG_IsOK(ecode1)) {
19764 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19765 }
19766 arg1 = static_cast< int >(val1);
19767 ecode2 = SWIG_AsVal_int(obj1, &val2);
19768 if (!SWIG_IsOK(ecode2)) {
19769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19770 }
19771 arg2 = static_cast< int >(val2);
19772 {
19773 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19774 arg4 = (int)temp3;
19775 }
19776 if (obj3) {
19777 {
19778 if (obj3 != Py_None) {
19779 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19780 arg6 = (int)temp5;
19781 }
19782 }
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 {
19791 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19792 }
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 SWIGINTERN int NullImage_set(PyObject *) {
19800 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19801 return 1;
19802 }
19803
19804
19805 SWIGINTERN PyObject *NullImage_get(void) {
19806 PyObject *pyobj = 0;
19807
19808 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19809 return pyobj;
19810 }
19811
19812
19813 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19814 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19815 return 1;
19816 }
19817
19818
19819 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19820 PyObject *pyobj = 0;
19821
19822 {
19823 #if wxUSE_UNICODE
19824 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19825 #else
19826 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19827 #endif
19828 }
19829 return pyobj;
19830 }
19831
19832
19833 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19834 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19835 return 1;
19836 }
19837
19838
19839 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19840 PyObject *pyobj = 0;
19841
19842 {
19843 #if wxUSE_UNICODE
19844 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19845 #else
19846 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19847 #endif
19848 }
19849 return pyobj;
19850 }
19851
19852
19853 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19854 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19855 return 1;
19856 }
19857
19858
19859 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19860 PyObject *pyobj = 0;
19861
19862 {
19863 #if wxUSE_UNICODE
19864 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19865 #else
19866 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19867 #endif
19868 }
19869 return pyobj;
19870 }
19871
19872
19873 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19874 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19875 return 1;
19876 }
19877
19878
19879 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19880 PyObject *pyobj = 0;
19881
19882 {
19883 #if wxUSE_UNICODE
19884 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19885 #else
19886 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19887 #endif
19888 }
19889 return pyobj;
19890 }
19891
19892
19893 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19894 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19895 return 1;
19896 }
19897
19898
19899 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19900 PyObject *pyobj = 0;
19901
19902 {
19903 #if wxUSE_UNICODE
19904 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19905 #else
19906 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19907 #endif
19908 }
19909 return pyobj;
19910 }
19911
19912
19913 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19914 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19915 return 1;
19916 }
19917
19918
19919 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19920 PyObject *pyobj = 0;
19921
19922 {
19923 #if wxUSE_UNICODE
19924 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19925 #else
19926 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19927 #endif
19928 }
19929 return pyobj;
19930 }
19931
19932
19933 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19934 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19935 return 1;
19936 }
19937
19938
19939 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19940 PyObject *pyobj = 0;
19941
19942 {
19943 #if wxUSE_UNICODE
19944 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19945 #else
19946 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19947 #endif
19948 }
19949 return pyobj;
19950 }
19951
19952
19953 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19954 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19955 return 1;
19956 }
19957
19958
19959 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19960 PyObject *pyobj = 0;
19961
19962 {
19963 #if wxUSE_UNICODE
19964 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19965 #else
19966 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19967 #endif
19968 }
19969 return pyobj;
19970 }
19971
19972
19973 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19974 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19975 return 1;
19976 }
19977
19978
19979 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19980 PyObject *pyobj = 0;
19981
19982 {
19983 #if wxUSE_UNICODE
19984 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19985 #else
19986 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19987 #endif
19988 }
19989 return pyobj;
19990 }
19991
19992
19993 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
19994 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
19995 return 1;
19996 }
19997
19998
19999 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20000 PyObject *pyobj = 0;
20001
20002 {
20003 #if wxUSE_UNICODE
20004 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20005 #else
20006 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20007 #endif
20008 }
20009 return pyobj;
20010 }
20011
20012
20013 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20014 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20015 return 1;
20016 }
20017
20018
20019 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20020 PyObject *pyobj = 0;
20021
20022 {
20023 #if wxUSE_UNICODE
20024 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20025 #else
20026 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20027 #endif
20028 }
20029 return pyobj;
20030 }
20031
20032
20033 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20034 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20035 return 1;
20036 }
20037
20038
20039 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20040 PyObject *pyobj = 0;
20041
20042 {
20043 #if wxUSE_UNICODE
20044 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20045 #else
20046 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20047 #endif
20048 }
20049 return pyobj;
20050 }
20051
20052
20053 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20054 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20055 return 1;
20056 }
20057
20058
20059 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20060 PyObject *pyobj = 0;
20061
20062 {
20063 #if wxUSE_UNICODE
20064 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20065 #else
20066 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20067 #endif
20068 }
20069 return pyobj;
20070 }
20071
20072
20073 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20074 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20075 return 1;
20076 }
20077
20078
20079 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20080 PyObject *pyobj = 0;
20081
20082 {
20083 #if wxUSE_UNICODE
20084 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20085 #else
20086 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20087 #endif
20088 }
20089 return pyobj;
20090 }
20091
20092
20093 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20094 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20095 return 1;
20096 }
20097
20098
20099 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20100 PyObject *pyobj = 0;
20101
20102 {
20103 #if wxUSE_UNICODE
20104 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20105 #else
20106 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20107 #endif
20108 }
20109 return pyobj;
20110 }
20111
20112
20113 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20114 PyObject *resultobj = 0;
20115 wxBMPHandler *result = 0 ;
20116
20117 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20118 {
20119 PyThreadState* __tstate = wxPyBeginAllowThreads();
20120 result = (wxBMPHandler *)new wxBMPHandler();
20121 wxPyEndAllowThreads(__tstate);
20122 if (PyErr_Occurred()) SWIG_fail;
20123 }
20124 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20125 return resultobj;
20126 fail:
20127 return NULL;
20128 }
20129
20130
20131 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20132 PyObject *obj;
20133 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20134 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20135 return SWIG_Py_Void();
20136 }
20137
20138 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20139 return SWIG_Python_InitShadowInstance(args);
20140 }
20141
20142 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20143 PyObject *resultobj = 0;
20144 wxICOHandler *result = 0 ;
20145
20146 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 result = (wxICOHandler *)new wxICOHandler();
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20154 return resultobj;
20155 fail:
20156 return NULL;
20157 }
20158
20159
20160 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20161 PyObject *obj;
20162 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20163 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20164 return SWIG_Py_Void();
20165 }
20166
20167 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20168 return SWIG_Python_InitShadowInstance(args);
20169 }
20170
20171 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20172 PyObject *resultobj = 0;
20173 wxCURHandler *result = 0 ;
20174
20175 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20176 {
20177 PyThreadState* __tstate = wxPyBeginAllowThreads();
20178 result = (wxCURHandler *)new wxCURHandler();
20179 wxPyEndAllowThreads(__tstate);
20180 if (PyErr_Occurred()) SWIG_fail;
20181 }
20182 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20183 return resultobj;
20184 fail:
20185 return NULL;
20186 }
20187
20188
20189 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20190 PyObject *obj;
20191 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20192 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20193 return SWIG_Py_Void();
20194 }
20195
20196 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20197 return SWIG_Python_InitShadowInstance(args);
20198 }
20199
20200 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20201 PyObject *resultobj = 0;
20202 wxANIHandler *result = 0 ;
20203
20204 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20205 {
20206 PyThreadState* __tstate = wxPyBeginAllowThreads();
20207 result = (wxANIHandler *)new wxANIHandler();
20208 wxPyEndAllowThreads(__tstate);
20209 if (PyErr_Occurred()) SWIG_fail;
20210 }
20211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20212 return resultobj;
20213 fail:
20214 return NULL;
20215 }
20216
20217
20218 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20219 PyObject *obj;
20220 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20221 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20222 return SWIG_Py_Void();
20223 }
20224
20225 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20226 return SWIG_Python_InitShadowInstance(args);
20227 }
20228
20229 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20230 PyObject *resultobj = 0;
20231 wxPNGHandler *result = 0 ;
20232
20233 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20234 {
20235 PyThreadState* __tstate = wxPyBeginAllowThreads();
20236 result = (wxPNGHandler *)new wxPNGHandler();
20237 wxPyEndAllowThreads(__tstate);
20238 if (PyErr_Occurred()) SWIG_fail;
20239 }
20240 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20241 return resultobj;
20242 fail:
20243 return NULL;
20244 }
20245
20246
20247 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20248 PyObject *obj;
20249 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20250 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20251 return SWIG_Py_Void();
20252 }
20253
20254 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 return SWIG_Python_InitShadowInstance(args);
20256 }
20257
20258 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20259 PyObject *resultobj = 0;
20260 wxGIFHandler *result = 0 ;
20261
20262 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20263 {
20264 PyThreadState* __tstate = wxPyBeginAllowThreads();
20265 result = (wxGIFHandler *)new wxGIFHandler();
20266 wxPyEndAllowThreads(__tstate);
20267 if (PyErr_Occurred()) SWIG_fail;
20268 }
20269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20270 return resultobj;
20271 fail:
20272 return NULL;
20273 }
20274
20275
20276 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20277 PyObject *obj;
20278 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20279 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20280 return SWIG_Py_Void();
20281 }
20282
20283 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20284 return SWIG_Python_InitShadowInstance(args);
20285 }
20286
20287 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20288 PyObject *resultobj = 0;
20289 wxPCXHandler *result = 0 ;
20290
20291 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20292 {
20293 PyThreadState* __tstate = wxPyBeginAllowThreads();
20294 result = (wxPCXHandler *)new wxPCXHandler();
20295 wxPyEndAllowThreads(__tstate);
20296 if (PyErr_Occurred()) SWIG_fail;
20297 }
20298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20299 return resultobj;
20300 fail:
20301 return NULL;
20302 }
20303
20304
20305 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20306 PyObject *obj;
20307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20308 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20309 return SWIG_Py_Void();
20310 }
20311
20312 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 return SWIG_Python_InitShadowInstance(args);
20314 }
20315
20316 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20317 PyObject *resultobj = 0;
20318 wxJPEGHandler *result = 0 ;
20319
20320 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20321 {
20322 PyThreadState* __tstate = wxPyBeginAllowThreads();
20323 result = (wxJPEGHandler *)new wxJPEGHandler();
20324 wxPyEndAllowThreads(__tstate);
20325 if (PyErr_Occurred()) SWIG_fail;
20326 }
20327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20328 return resultobj;
20329 fail:
20330 return NULL;
20331 }
20332
20333
20334 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20335 PyObject *obj;
20336 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20337 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20338 return SWIG_Py_Void();
20339 }
20340
20341 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20342 return SWIG_Python_InitShadowInstance(args);
20343 }
20344
20345 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20346 PyObject *resultobj = 0;
20347 wxPNMHandler *result = 0 ;
20348
20349 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20350 {
20351 PyThreadState* __tstate = wxPyBeginAllowThreads();
20352 result = (wxPNMHandler *)new wxPNMHandler();
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20364 PyObject *obj;
20365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20366 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20367 return SWIG_Py_Void();
20368 }
20369
20370 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20371 return SWIG_Python_InitShadowInstance(args);
20372 }
20373
20374 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20375 PyObject *resultobj = 0;
20376 wxXPMHandler *result = 0 ;
20377
20378 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20379 {
20380 PyThreadState* __tstate = wxPyBeginAllowThreads();
20381 result = (wxXPMHandler *)new wxXPMHandler();
20382 wxPyEndAllowThreads(__tstate);
20383 if (PyErr_Occurred()) SWIG_fail;
20384 }
20385 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *obj;
20394 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20395 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20396 return SWIG_Py_Void();
20397 }
20398
20399 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20400 return SWIG_Python_InitShadowInstance(args);
20401 }
20402
20403 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20404 PyObject *resultobj = 0;
20405 wxTIFFHandler *result = 0 ;
20406
20407 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20408 {
20409 PyThreadState* __tstate = wxPyBeginAllowThreads();
20410 result = (wxTIFFHandler *)new wxTIFFHandler();
20411 wxPyEndAllowThreads(__tstate);
20412 if (PyErr_Occurred()) SWIG_fail;
20413 }
20414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20415 return resultobj;
20416 fail:
20417 return NULL;
20418 }
20419
20420
20421 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20422 PyObject *obj;
20423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20424 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20425 return SWIG_Py_Void();
20426 }
20427
20428 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20429 return SWIG_Python_InitShadowInstance(args);
20430 }
20431
20432 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxTGAHandler *result = 0 ;
20435
20436 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (wxTGAHandler *)new wxTGAHandler();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20451 PyObject *obj;
20452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20453 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20454 return SWIG_Py_Void();
20455 }
20456
20457 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20458 return SWIG_Python_InitShadowInstance(args);
20459 }
20460
20461 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20462 PyObject *resultobj = 0;
20463 wxImage *arg1 = 0 ;
20464 wxImage *arg2 = 0 ;
20465 int arg3 = (int) 236 ;
20466 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20467 bool result;
20468 void *argp1 = 0 ;
20469 int res1 = 0 ;
20470 void *argp2 = 0 ;
20471 int res2 = 0 ;
20472 int val3 ;
20473 int ecode3 = 0 ;
20474 int val4 ;
20475 int ecode4 = 0 ;
20476 PyObject * obj0 = 0 ;
20477 PyObject * obj1 = 0 ;
20478 PyObject * obj2 = 0 ;
20479 PyObject * obj3 = 0 ;
20480 char * kwnames[] = {
20481 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20482 };
20483
20484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20485 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20486 if (!SWIG_IsOK(res1)) {
20487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20488 }
20489 if (!argp1) {
20490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20491 }
20492 arg1 = reinterpret_cast< wxImage * >(argp1);
20493 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20494 if (!SWIG_IsOK(res2)) {
20495 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20496 }
20497 if (!argp2) {
20498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20499 }
20500 arg2 = reinterpret_cast< wxImage * >(argp2);
20501 if (obj2) {
20502 ecode3 = SWIG_AsVal_int(obj2, &val3);
20503 if (!SWIG_IsOK(ecode3)) {
20504 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20505 }
20506 arg3 = static_cast< int >(val3);
20507 }
20508 if (obj3) {
20509 ecode4 = SWIG_AsVal_int(obj3, &val4);
20510 if (!SWIG_IsOK(ecode4)) {
20511 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20512 }
20513 arg4 = static_cast< int >(val4);
20514 }
20515 {
20516 PyThreadState* __tstate = wxPyBeginAllowThreads();
20517 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20518 wxPyEndAllowThreads(__tstate);
20519 if (PyErr_Occurred()) SWIG_fail;
20520 }
20521 {
20522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20523 }
20524 return resultobj;
20525 fail:
20526 return NULL;
20527 }
20528
20529
20530 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20531 PyObject *obj;
20532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20533 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20534 return SWIG_Py_Void();
20535 }
20536
20537 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20538 PyObject *resultobj = 0;
20539 wxEvtHandler *result = 0 ;
20540
20541 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20542 {
20543 PyThreadState* __tstate = wxPyBeginAllowThreads();
20544 result = (wxEvtHandler *)new wxEvtHandler();
20545 wxPyEndAllowThreads(__tstate);
20546 if (PyErr_Occurred()) SWIG_fail;
20547 }
20548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20549 return resultobj;
20550 fail:
20551 return NULL;
20552 }
20553
20554
20555 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20556 PyObject *resultobj = 0;
20557 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20558 wxEvtHandler *result = 0 ;
20559 void *argp1 = 0 ;
20560 int res1 = 0 ;
20561 PyObject *swig_obj[1] ;
20562
20563 if (!args) SWIG_fail;
20564 swig_obj[0] = args;
20565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20566 if (!SWIG_IsOK(res1)) {
20567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20568 }
20569 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20570 {
20571 PyThreadState* __tstate = wxPyBeginAllowThreads();
20572 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20573 wxPyEndAllowThreads(__tstate);
20574 if (PyErr_Occurred()) SWIG_fail;
20575 }
20576 {
20577 resultobj = wxPyMake_wxObject(result, 0);
20578 }
20579 return resultobj;
20580 fail:
20581 return NULL;
20582 }
20583
20584
20585 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20586 PyObject *resultobj = 0;
20587 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20588 wxEvtHandler *result = 0 ;
20589 void *argp1 = 0 ;
20590 int res1 = 0 ;
20591 PyObject *swig_obj[1] ;
20592
20593 if (!args) SWIG_fail;
20594 swig_obj[0] = args;
20595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20596 if (!SWIG_IsOK(res1)) {
20597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20598 }
20599 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20600 {
20601 PyThreadState* __tstate = wxPyBeginAllowThreads();
20602 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20603 wxPyEndAllowThreads(__tstate);
20604 if (PyErr_Occurred()) SWIG_fail;
20605 }
20606 {
20607 resultobj = wxPyMake_wxObject(result, 0);
20608 }
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj = 0;
20617 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20618 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20619 void *argp1 = 0 ;
20620 int res1 = 0 ;
20621 void *argp2 = 0 ;
20622 int res2 = 0 ;
20623 PyObject * obj0 = 0 ;
20624 PyObject * obj1 = 0 ;
20625 char * kwnames[] = {
20626 (char *) "self",(char *) "handler", NULL
20627 };
20628
20629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20631 if (!SWIG_IsOK(res1)) {
20632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20633 }
20634 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20635 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20636 if (!SWIG_IsOK(res2)) {
20637 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20638 }
20639 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20640 {
20641 PyThreadState* __tstate = wxPyBeginAllowThreads();
20642 (arg1)->SetNextHandler(arg2);
20643 wxPyEndAllowThreads(__tstate);
20644 if (PyErr_Occurred()) SWIG_fail;
20645 }
20646 resultobj = SWIG_Py_Void();
20647 return resultobj;
20648 fail:
20649 return NULL;
20650 }
20651
20652
20653 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20654 PyObject *resultobj = 0;
20655 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20656 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20657 void *argp1 = 0 ;
20658 int res1 = 0 ;
20659 void *argp2 = 0 ;
20660 int res2 = 0 ;
20661 PyObject * obj0 = 0 ;
20662 PyObject * obj1 = 0 ;
20663 char * kwnames[] = {
20664 (char *) "self",(char *) "handler", NULL
20665 };
20666
20667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20669 if (!SWIG_IsOK(res1)) {
20670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20671 }
20672 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20673 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20674 if (!SWIG_IsOK(res2)) {
20675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20676 }
20677 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20678 {
20679 PyThreadState* __tstate = wxPyBeginAllowThreads();
20680 (arg1)->SetPreviousHandler(arg2);
20681 wxPyEndAllowThreads(__tstate);
20682 if (PyErr_Occurred()) SWIG_fail;
20683 }
20684 resultobj = SWIG_Py_Void();
20685 return resultobj;
20686 fail:
20687 return NULL;
20688 }
20689
20690
20691 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20692 PyObject *resultobj = 0;
20693 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20694 bool result;
20695 void *argp1 = 0 ;
20696 int res1 = 0 ;
20697 PyObject *swig_obj[1] ;
20698
20699 if (!args) SWIG_fail;
20700 swig_obj[0] = args;
20701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20702 if (!SWIG_IsOK(res1)) {
20703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20704 }
20705 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20706 {
20707 PyThreadState* __tstate = wxPyBeginAllowThreads();
20708 result = (bool)(arg1)->GetEvtHandlerEnabled();
20709 wxPyEndAllowThreads(__tstate);
20710 if (PyErr_Occurred()) SWIG_fail;
20711 }
20712 {
20713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20714 }
20715 return resultobj;
20716 fail:
20717 return NULL;
20718 }
20719
20720
20721 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20722 PyObject *resultobj = 0;
20723 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20724 bool arg2 ;
20725 void *argp1 = 0 ;
20726 int res1 = 0 ;
20727 bool val2 ;
20728 int ecode2 = 0 ;
20729 PyObject * obj0 = 0 ;
20730 PyObject * obj1 = 0 ;
20731 char * kwnames[] = {
20732 (char *) "self",(char *) "enabled", NULL
20733 };
20734
20735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20737 if (!SWIG_IsOK(res1)) {
20738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20739 }
20740 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20741 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20742 if (!SWIG_IsOK(ecode2)) {
20743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20744 }
20745 arg2 = static_cast< bool >(val2);
20746 {
20747 PyThreadState* __tstate = wxPyBeginAllowThreads();
20748 (arg1)->SetEvtHandlerEnabled(arg2);
20749 wxPyEndAllowThreads(__tstate);
20750 if (PyErr_Occurred()) SWIG_fail;
20751 }
20752 resultobj = SWIG_Py_Void();
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20760 PyObject *resultobj = 0;
20761 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20762 wxEvent *arg2 = 0 ;
20763 bool result;
20764 void *argp1 = 0 ;
20765 int res1 = 0 ;
20766 void *argp2 = 0 ;
20767 int res2 = 0 ;
20768 PyObject * obj0 = 0 ;
20769 PyObject * obj1 = 0 ;
20770 char * kwnames[] = {
20771 (char *) "self",(char *) "event", NULL
20772 };
20773
20774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20776 if (!SWIG_IsOK(res1)) {
20777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20778 }
20779 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20780 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20781 if (!SWIG_IsOK(res2)) {
20782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20783 }
20784 if (!argp2) {
20785 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20786 }
20787 arg2 = reinterpret_cast< wxEvent * >(argp2);
20788 {
20789 PyThreadState* __tstate = wxPyBeginAllowThreads();
20790 result = (bool)(arg1)->ProcessEvent(*arg2);
20791 wxPyEndAllowThreads(__tstate);
20792 if (PyErr_Occurred()) SWIG_fail;
20793 }
20794 {
20795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20796 }
20797 return resultobj;
20798 fail:
20799 return NULL;
20800 }
20801
20802
20803 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20804 PyObject *resultobj = 0;
20805 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20806 wxEvent *arg2 = 0 ;
20807 void *argp1 = 0 ;
20808 int res1 = 0 ;
20809 void *argp2 = 0 ;
20810 int res2 = 0 ;
20811 PyObject * obj0 = 0 ;
20812 PyObject * obj1 = 0 ;
20813 char * kwnames[] = {
20814 (char *) "self",(char *) "event", NULL
20815 };
20816
20817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20819 if (!SWIG_IsOK(res1)) {
20820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20821 }
20822 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20823 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20824 if (!SWIG_IsOK(res2)) {
20825 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20826 }
20827 if (!argp2) {
20828 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20829 }
20830 arg2 = reinterpret_cast< wxEvent * >(argp2);
20831 {
20832 PyThreadState* __tstate = wxPyBeginAllowThreads();
20833 (arg1)->AddPendingEvent(*arg2);
20834 wxPyEndAllowThreads(__tstate);
20835 if (PyErr_Occurred()) SWIG_fail;
20836 }
20837 resultobj = SWIG_Py_Void();
20838 return resultobj;
20839 fail:
20840 return NULL;
20841 }
20842
20843
20844 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20845 PyObject *resultobj = 0;
20846 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20847 void *argp1 = 0 ;
20848 int res1 = 0 ;
20849 PyObject *swig_obj[1] ;
20850
20851 if (!args) SWIG_fail;
20852 swig_obj[0] = args;
20853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20854 if (!SWIG_IsOK(res1)) {
20855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20856 }
20857 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20858 {
20859 PyThreadState* __tstate = wxPyBeginAllowThreads();
20860 (arg1)->ProcessPendingEvents();
20861 wxPyEndAllowThreads(__tstate);
20862 if (PyErr_Occurred()) SWIG_fail;
20863 }
20864 resultobj = SWIG_Py_Void();
20865 return resultobj;
20866 fail:
20867 return NULL;
20868 }
20869
20870
20871 SWIGINTERN PyObject *_wrap_EvtHandler_AllowReentrance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj = 0;
20873 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20874 bool arg2 = (bool) true ;
20875 void *argp1 = 0 ;
20876 int res1 = 0 ;
20877 bool val2 ;
20878 int ecode2 = 0 ;
20879 PyObject * obj0 = 0 ;
20880 PyObject * obj1 = 0 ;
20881 char * kwnames[] = {
20882 (char *) "self",(char *) "allow", NULL
20883 };
20884
20885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EvtHandler_AllowReentrance",kwnames,&obj0,&obj1)) SWIG_fail;
20886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20887 if (!SWIG_IsOK(res1)) {
20888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20889 }
20890 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20891 if (obj1) {
20892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20893 if (!SWIG_IsOK(ecode2)) {
20894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_AllowReentrance" "', expected argument " "2"" of type '" "bool""'");
20895 }
20896 arg2 = static_cast< bool >(val2);
20897 }
20898 {
20899 PyThreadState* __tstate = wxPyBeginAllowThreads();
20900 (arg1)->AllowReentrance(arg2);
20901 wxPyEndAllowThreads(__tstate);
20902 if (PyErr_Occurred()) SWIG_fail;
20903 }
20904 resultobj = SWIG_Py_Void();
20905 return resultobj;
20906 fail:
20907 return NULL;
20908 }
20909
20910
20911 SWIGINTERN PyObject *_wrap_EvtHandler_IsReentranceAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20912 PyObject *resultobj = 0;
20913 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20914 bool result;
20915 void *argp1 = 0 ;
20916 int res1 = 0 ;
20917 PyObject *swig_obj[1] ;
20918
20919 if (!args) SWIG_fail;
20920 swig_obj[0] = args;
20921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20922 if (!SWIG_IsOK(res1)) {
20923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsReentranceAllowed" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20924 }
20925 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20926 {
20927 PyThreadState* __tstate = wxPyBeginAllowThreads();
20928 result = (bool)(arg1)->IsReentranceAllowed();
20929 wxPyEndAllowThreads(__tstate);
20930 if (PyErr_Occurred()) SWIG_fail;
20931 }
20932 {
20933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20934 }
20935 return resultobj;
20936 fail:
20937 return NULL;
20938 }
20939
20940
20941 SWIGINTERN PyObject *_wrap_EvtHandler_IsEventHandlingInProgress(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20942 PyObject *resultobj = 0;
20943 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20944 bool result;
20945 void *argp1 = 0 ;
20946 int res1 = 0 ;
20947 PyObject *swig_obj[1] ;
20948
20949 if (!args) SWIG_fail;
20950 swig_obj[0] = args;
20951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20952 if (!SWIG_IsOK(res1)) {
20953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_IsEventHandlingInProgress" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20954 }
20955 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20956 {
20957 PyThreadState* __tstate = wxPyBeginAllowThreads();
20958 result = (bool)(arg1)->IsEventHandlingInProgress();
20959 wxPyEndAllowThreads(__tstate);
20960 if (PyErr_Occurred()) SWIG_fail;
20961 }
20962 {
20963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20964 }
20965 return resultobj;
20966 fail:
20967 return NULL;
20968 }
20969
20970
20971 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20972 PyObject *resultobj = 0;
20973 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20974 int arg2 ;
20975 int arg3 ;
20976 int arg4 ;
20977 PyObject *arg5 = (PyObject *) 0 ;
20978 void *argp1 = 0 ;
20979 int res1 = 0 ;
20980 int val2 ;
20981 int ecode2 = 0 ;
20982 int val3 ;
20983 int ecode3 = 0 ;
20984 int val4 ;
20985 int ecode4 = 0 ;
20986 PyObject * obj0 = 0 ;
20987 PyObject * obj1 = 0 ;
20988 PyObject * obj2 = 0 ;
20989 PyObject * obj3 = 0 ;
20990 PyObject * obj4 = 0 ;
20991 char * kwnames[] = {
20992 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20993 };
20994
20995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20997 if (!SWIG_IsOK(res1)) {
20998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20999 }
21000 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21001 ecode2 = SWIG_AsVal_int(obj1, &val2);
21002 if (!SWIG_IsOK(ecode2)) {
21003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
21004 }
21005 arg2 = static_cast< int >(val2);
21006 ecode3 = SWIG_AsVal_int(obj2, &val3);
21007 if (!SWIG_IsOK(ecode3)) {
21008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
21009 }
21010 arg3 = static_cast< int >(val3);
21011 ecode4 = SWIG_AsVal_int(obj3, &val4);
21012 if (!SWIG_IsOK(ecode4)) {
21013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
21014 }
21015 arg4 = static_cast< int >(val4);
21016 arg5 = obj4;
21017 {
21018 PyThreadState* __tstate = wxPyBeginAllowThreads();
21019 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
21020 wxPyEndAllowThreads(__tstate);
21021 if (PyErr_Occurred()) SWIG_fail;
21022 }
21023 resultobj = SWIG_Py_Void();
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21031 PyObject *resultobj = 0;
21032 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21033 int arg2 ;
21034 int arg3 = (int) -1 ;
21035 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
21036 bool result;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 int val2 ;
21040 int ecode2 = 0 ;
21041 int val3 ;
21042 int ecode3 = 0 ;
21043 int val4 ;
21044 int ecode4 = 0 ;
21045 PyObject * obj0 = 0 ;
21046 PyObject * obj1 = 0 ;
21047 PyObject * obj2 = 0 ;
21048 PyObject * obj3 = 0 ;
21049 char * kwnames[] = {
21050 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
21051 };
21052
21053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
21054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21055 if (!SWIG_IsOK(res1)) {
21056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21057 }
21058 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21059 ecode2 = SWIG_AsVal_int(obj1, &val2);
21060 if (!SWIG_IsOK(ecode2)) {
21061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
21062 }
21063 arg2 = static_cast< int >(val2);
21064 if (obj2) {
21065 ecode3 = SWIG_AsVal_int(obj2, &val3);
21066 if (!SWIG_IsOK(ecode3)) {
21067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
21068 }
21069 arg3 = static_cast< int >(val3);
21070 }
21071 if (obj3) {
21072 ecode4 = SWIG_AsVal_int(obj3, &val4);
21073 if (!SWIG_IsOK(ecode4)) {
21074 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
21075 }
21076 arg4 = static_cast< wxEventType >(val4);
21077 }
21078 {
21079 PyThreadState* __tstate = wxPyBeginAllowThreads();
21080 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
21081 wxPyEndAllowThreads(__tstate);
21082 if (PyErr_Occurred()) SWIG_fail;
21083 }
21084 {
21085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21086 }
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj = 0;
21095 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21096 PyObject *arg2 = (PyObject *) 0 ;
21097 bool arg3 = (bool) true ;
21098 void *argp1 = 0 ;
21099 int res1 = 0 ;
21100 bool val3 ;
21101 int ecode3 = 0 ;
21102 PyObject * obj0 = 0 ;
21103 PyObject * obj1 = 0 ;
21104 PyObject * obj2 = 0 ;
21105 char * kwnames[] = {
21106 (char *) "self",(char *) "_self",(char *) "incref", NULL
21107 };
21108
21109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21111 if (!SWIG_IsOK(res1)) {
21112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21113 }
21114 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21115 arg2 = obj1;
21116 if (obj2) {
21117 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21118 if (!SWIG_IsOK(ecode3)) {
21119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21120 }
21121 arg3 = static_cast< bool >(val3);
21122 }
21123 {
21124 PyThreadState* __tstate = wxPyBeginAllowThreads();
21125 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21126 wxPyEndAllowThreads(__tstate);
21127 if (PyErr_Occurred()) SWIG_fail;
21128 }
21129 resultobj = SWIG_Py_Void();
21130 return resultobj;
21131 fail:
21132 return NULL;
21133 }
21134
21135
21136 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21137 PyObject *obj;
21138 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21139 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21140 return SWIG_Py_Void();
21141 }
21142
21143 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21144 return SWIG_Python_InitShadowInstance(args);
21145 }
21146
21147 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21148 PyObject *resultobj = 0;
21149 wxEventType result;
21150
21151 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21152 {
21153 PyThreadState* __tstate = wxPyBeginAllowThreads();
21154 result = (wxEventType)wxNewEventType();
21155 wxPyEndAllowThreads(__tstate);
21156 if (PyErr_Occurred()) SWIG_fail;
21157 }
21158 resultobj = SWIG_From_int(static_cast< int >(result));
21159 return resultobj;
21160 fail:
21161 return NULL;
21162 }
21163
21164
21165 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21166 PyObject *resultobj = 0;
21167 wxEvent *arg1 = (wxEvent *) 0 ;
21168 void *argp1 = 0 ;
21169 int res1 = 0 ;
21170 PyObject *swig_obj[1] ;
21171
21172 if (!args) SWIG_fail;
21173 swig_obj[0] = args;
21174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21175 if (!SWIG_IsOK(res1)) {
21176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21177 }
21178 arg1 = reinterpret_cast< wxEvent * >(argp1);
21179 {
21180 PyThreadState* __tstate = wxPyBeginAllowThreads();
21181 delete arg1;
21182
21183 wxPyEndAllowThreads(__tstate);
21184 if (PyErr_Occurred()) SWIG_fail;
21185 }
21186 resultobj = SWIG_Py_Void();
21187 return resultobj;
21188 fail:
21189 return NULL;
21190 }
21191
21192
21193 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21194 PyObject *resultobj = 0;
21195 wxEvent *arg1 = (wxEvent *) 0 ;
21196 wxEventType arg2 ;
21197 void *argp1 = 0 ;
21198 int res1 = 0 ;
21199 int val2 ;
21200 int ecode2 = 0 ;
21201 PyObject * obj0 = 0 ;
21202 PyObject * obj1 = 0 ;
21203 char * kwnames[] = {
21204 (char *) "self",(char *) "typ", NULL
21205 };
21206
21207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21211 }
21212 arg1 = reinterpret_cast< wxEvent * >(argp1);
21213 ecode2 = SWIG_AsVal_int(obj1, &val2);
21214 if (!SWIG_IsOK(ecode2)) {
21215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21216 }
21217 arg2 = static_cast< wxEventType >(val2);
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 (arg1)->SetEventType(arg2);
21221 wxPyEndAllowThreads(__tstate);
21222 if (PyErr_Occurred()) SWIG_fail;
21223 }
21224 resultobj = SWIG_Py_Void();
21225 return resultobj;
21226 fail:
21227 return NULL;
21228 }
21229
21230
21231 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21232 PyObject *resultobj = 0;
21233 wxEvent *arg1 = (wxEvent *) 0 ;
21234 wxEventType result;
21235 void *argp1 = 0 ;
21236 int res1 = 0 ;
21237 PyObject *swig_obj[1] ;
21238
21239 if (!args) SWIG_fail;
21240 swig_obj[0] = args;
21241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21242 if (!SWIG_IsOK(res1)) {
21243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21244 }
21245 arg1 = reinterpret_cast< wxEvent * >(argp1);
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21249 wxPyEndAllowThreads(__tstate);
21250 if (PyErr_Occurred()) SWIG_fail;
21251 }
21252 resultobj = SWIG_From_int(static_cast< int >(result));
21253 return resultobj;
21254 fail:
21255 return NULL;
21256 }
21257
21258
21259 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21260 PyObject *resultobj = 0;
21261 wxEvent *arg1 = (wxEvent *) 0 ;
21262 wxObject *result = 0 ;
21263 void *argp1 = 0 ;
21264 int res1 = 0 ;
21265 PyObject *swig_obj[1] ;
21266
21267 if (!args) SWIG_fail;
21268 swig_obj[0] = args;
21269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21270 if (!SWIG_IsOK(res1)) {
21271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21272 }
21273 arg1 = reinterpret_cast< wxEvent * >(argp1);
21274 {
21275 PyThreadState* __tstate = wxPyBeginAllowThreads();
21276 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21277 wxPyEndAllowThreads(__tstate);
21278 if (PyErr_Occurred()) SWIG_fail;
21279 }
21280 {
21281 resultobj = wxPyMake_wxObject(result, (bool)0);
21282 }
21283 return resultobj;
21284 fail:
21285 return NULL;
21286 }
21287
21288
21289 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21290 PyObject *resultobj = 0;
21291 wxEvent *arg1 = (wxEvent *) 0 ;
21292 wxObject *arg2 = (wxObject *) 0 ;
21293 void *argp1 = 0 ;
21294 int res1 = 0 ;
21295 void *argp2 = 0 ;
21296 int res2 = 0 ;
21297 PyObject * obj0 = 0 ;
21298 PyObject * obj1 = 0 ;
21299 char * kwnames[] = {
21300 (char *) "self",(char *) "obj", NULL
21301 };
21302
21303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21305 if (!SWIG_IsOK(res1)) {
21306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21307 }
21308 arg1 = reinterpret_cast< wxEvent * >(argp1);
21309 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21310 if (!SWIG_IsOK(res2)) {
21311 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21312 }
21313 arg2 = reinterpret_cast< wxObject * >(argp2);
21314 {
21315 PyThreadState* __tstate = wxPyBeginAllowThreads();
21316 (arg1)->SetEventObject(arg2);
21317 wxPyEndAllowThreads(__tstate);
21318 if (PyErr_Occurred()) SWIG_fail;
21319 }
21320 resultobj = SWIG_Py_Void();
21321 return resultobj;
21322 fail:
21323 return NULL;
21324 }
21325
21326
21327 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21328 PyObject *resultobj = 0;
21329 wxEvent *arg1 = (wxEvent *) 0 ;
21330 long result;
21331 void *argp1 = 0 ;
21332 int res1 = 0 ;
21333 PyObject *swig_obj[1] ;
21334
21335 if (!args) SWIG_fail;
21336 swig_obj[0] = args;
21337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21338 if (!SWIG_IsOK(res1)) {
21339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21340 }
21341 arg1 = reinterpret_cast< wxEvent * >(argp1);
21342 {
21343 PyThreadState* __tstate = wxPyBeginAllowThreads();
21344 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21345 wxPyEndAllowThreads(__tstate);
21346 if (PyErr_Occurred()) SWIG_fail;
21347 }
21348 resultobj = SWIG_From_long(static_cast< long >(result));
21349 return resultobj;
21350 fail:
21351 return NULL;
21352 }
21353
21354
21355 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21356 PyObject *resultobj = 0;
21357 wxEvent *arg1 = (wxEvent *) 0 ;
21358 long arg2 = (long) 0 ;
21359 void *argp1 = 0 ;
21360 int res1 = 0 ;
21361 long val2 ;
21362 int ecode2 = 0 ;
21363 PyObject * obj0 = 0 ;
21364 PyObject * obj1 = 0 ;
21365 char * kwnames[] = {
21366 (char *) "self",(char *) "ts", NULL
21367 };
21368
21369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21371 if (!SWIG_IsOK(res1)) {
21372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21373 }
21374 arg1 = reinterpret_cast< wxEvent * >(argp1);
21375 if (obj1) {
21376 ecode2 = SWIG_AsVal_long(obj1, &val2);
21377 if (!SWIG_IsOK(ecode2)) {
21378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21379 }
21380 arg2 = static_cast< long >(val2);
21381 }
21382 {
21383 PyThreadState* __tstate = wxPyBeginAllowThreads();
21384 (arg1)->SetTimestamp(arg2);
21385 wxPyEndAllowThreads(__tstate);
21386 if (PyErr_Occurred()) SWIG_fail;
21387 }
21388 resultobj = SWIG_Py_Void();
21389 return resultobj;
21390 fail:
21391 return NULL;
21392 }
21393
21394
21395 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21396 PyObject *resultobj = 0;
21397 wxEvent *arg1 = (wxEvent *) 0 ;
21398 int result;
21399 void *argp1 = 0 ;
21400 int res1 = 0 ;
21401 PyObject *swig_obj[1] ;
21402
21403 if (!args) SWIG_fail;
21404 swig_obj[0] = args;
21405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21406 if (!SWIG_IsOK(res1)) {
21407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21408 }
21409 arg1 = reinterpret_cast< wxEvent * >(argp1);
21410 {
21411 PyThreadState* __tstate = wxPyBeginAllowThreads();
21412 result = (int)((wxEvent const *)arg1)->GetId();
21413 wxPyEndAllowThreads(__tstate);
21414 if (PyErr_Occurred()) SWIG_fail;
21415 }
21416 resultobj = SWIG_From_int(static_cast< int >(result));
21417 return resultobj;
21418 fail:
21419 return NULL;
21420 }
21421
21422
21423 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21424 PyObject *resultobj = 0;
21425 wxEvent *arg1 = (wxEvent *) 0 ;
21426 int arg2 ;
21427 void *argp1 = 0 ;
21428 int res1 = 0 ;
21429 int val2 ;
21430 int ecode2 = 0 ;
21431 PyObject * obj0 = 0 ;
21432 PyObject * obj1 = 0 ;
21433 char * kwnames[] = {
21434 (char *) "self",(char *) "Id", NULL
21435 };
21436
21437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21439 if (!SWIG_IsOK(res1)) {
21440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21441 }
21442 arg1 = reinterpret_cast< wxEvent * >(argp1);
21443 ecode2 = SWIG_AsVal_int(obj1, &val2);
21444 if (!SWIG_IsOK(ecode2)) {
21445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21446 }
21447 arg2 = static_cast< int >(val2);
21448 {
21449 PyThreadState* __tstate = wxPyBeginAllowThreads();
21450 (arg1)->SetId(arg2);
21451 wxPyEndAllowThreads(__tstate);
21452 if (PyErr_Occurred()) SWIG_fail;
21453 }
21454 resultobj = SWIG_Py_Void();
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21462 PyObject *resultobj = 0;
21463 wxEvent *arg1 = (wxEvent *) 0 ;
21464 bool result;
21465 void *argp1 = 0 ;
21466 int res1 = 0 ;
21467 PyObject *swig_obj[1] ;
21468
21469 if (!args) SWIG_fail;
21470 swig_obj[0] = args;
21471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21472 if (!SWIG_IsOK(res1)) {
21473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21474 }
21475 arg1 = reinterpret_cast< wxEvent * >(argp1);
21476 {
21477 PyThreadState* __tstate = wxPyBeginAllowThreads();
21478 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21479 wxPyEndAllowThreads(__tstate);
21480 if (PyErr_Occurred()) SWIG_fail;
21481 }
21482 {
21483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21484 }
21485 return resultobj;
21486 fail:
21487 return NULL;
21488 }
21489
21490
21491 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21492 PyObject *resultobj = 0;
21493 wxEvent *arg1 = (wxEvent *) 0 ;
21494 bool arg2 = (bool) true ;
21495 void *argp1 = 0 ;
21496 int res1 = 0 ;
21497 bool val2 ;
21498 int ecode2 = 0 ;
21499 PyObject * obj0 = 0 ;
21500 PyObject * obj1 = 0 ;
21501 char * kwnames[] = {
21502 (char *) "self",(char *) "skip", NULL
21503 };
21504
21505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21507 if (!SWIG_IsOK(res1)) {
21508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21509 }
21510 arg1 = reinterpret_cast< wxEvent * >(argp1);
21511 if (obj1) {
21512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21513 if (!SWIG_IsOK(ecode2)) {
21514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21515 }
21516 arg2 = static_cast< bool >(val2);
21517 }
21518 {
21519 PyThreadState* __tstate = wxPyBeginAllowThreads();
21520 (arg1)->Skip(arg2);
21521 wxPyEndAllowThreads(__tstate);
21522 if (PyErr_Occurred()) SWIG_fail;
21523 }
21524 resultobj = SWIG_Py_Void();
21525 return resultobj;
21526 fail:
21527 return NULL;
21528 }
21529
21530
21531 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21532 PyObject *resultobj = 0;
21533 wxEvent *arg1 = (wxEvent *) 0 ;
21534 bool result;
21535 void *argp1 = 0 ;
21536 int res1 = 0 ;
21537 PyObject *swig_obj[1] ;
21538
21539 if (!args) SWIG_fail;
21540 swig_obj[0] = args;
21541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21542 if (!SWIG_IsOK(res1)) {
21543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21544 }
21545 arg1 = reinterpret_cast< wxEvent * >(argp1);
21546 {
21547 PyThreadState* __tstate = wxPyBeginAllowThreads();
21548 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21549 wxPyEndAllowThreads(__tstate);
21550 if (PyErr_Occurred()) SWIG_fail;
21551 }
21552 {
21553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21554 }
21555 return resultobj;
21556 fail:
21557 return NULL;
21558 }
21559
21560
21561 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21562 PyObject *resultobj = 0;
21563 wxEvent *arg1 = (wxEvent *) 0 ;
21564 bool result;
21565 void *argp1 = 0 ;
21566 int res1 = 0 ;
21567 PyObject *swig_obj[1] ;
21568
21569 if (!args) SWIG_fail;
21570 swig_obj[0] = args;
21571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21572 if (!SWIG_IsOK(res1)) {
21573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21574 }
21575 arg1 = reinterpret_cast< wxEvent * >(argp1);
21576 {
21577 PyThreadState* __tstate = wxPyBeginAllowThreads();
21578 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21579 wxPyEndAllowThreads(__tstate);
21580 if (PyErr_Occurred()) SWIG_fail;
21581 }
21582 {
21583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21584 }
21585 return resultobj;
21586 fail:
21587 return NULL;
21588 }
21589
21590
21591 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21592 PyObject *resultobj = 0;
21593 wxEvent *arg1 = (wxEvent *) 0 ;
21594 int result;
21595 void *argp1 = 0 ;
21596 int res1 = 0 ;
21597 PyObject *swig_obj[1] ;
21598
21599 if (!args) SWIG_fail;
21600 swig_obj[0] = args;
21601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21602 if (!SWIG_IsOK(res1)) {
21603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21604 }
21605 arg1 = reinterpret_cast< wxEvent * >(argp1);
21606 {
21607 PyThreadState* __tstate = wxPyBeginAllowThreads();
21608 result = (int)(arg1)->StopPropagation();
21609 wxPyEndAllowThreads(__tstate);
21610 if (PyErr_Occurred()) SWIG_fail;
21611 }
21612 resultobj = SWIG_From_int(static_cast< int >(result));
21613 return resultobj;
21614 fail:
21615 return NULL;
21616 }
21617
21618
21619 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21620 PyObject *resultobj = 0;
21621 wxEvent *arg1 = (wxEvent *) 0 ;
21622 int arg2 ;
21623 void *argp1 = 0 ;
21624 int res1 = 0 ;
21625 int val2 ;
21626 int ecode2 = 0 ;
21627 PyObject * obj0 = 0 ;
21628 PyObject * obj1 = 0 ;
21629 char * kwnames[] = {
21630 (char *) "self",(char *) "propagationLevel", NULL
21631 };
21632
21633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21637 }
21638 arg1 = reinterpret_cast< wxEvent * >(argp1);
21639 ecode2 = SWIG_AsVal_int(obj1, &val2);
21640 if (!SWIG_IsOK(ecode2)) {
21641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21642 }
21643 arg2 = static_cast< int >(val2);
21644 {
21645 PyThreadState* __tstate = wxPyBeginAllowThreads();
21646 (arg1)->ResumePropagation(arg2);
21647 wxPyEndAllowThreads(__tstate);
21648 if (PyErr_Occurred()) SWIG_fail;
21649 }
21650 resultobj = SWIG_Py_Void();
21651 return resultobj;
21652 fail:
21653 return NULL;
21654 }
21655
21656
21657 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21658 PyObject *resultobj = 0;
21659 wxEvent *arg1 = (wxEvent *) 0 ;
21660 wxEvent *result = 0 ;
21661 void *argp1 = 0 ;
21662 int res1 = 0 ;
21663 PyObject *swig_obj[1] ;
21664
21665 if (!args) SWIG_fail;
21666 swig_obj[0] = args;
21667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21668 if (!SWIG_IsOK(res1)) {
21669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21670 }
21671 arg1 = reinterpret_cast< wxEvent * >(argp1);
21672 {
21673 PyThreadState* __tstate = wxPyBeginAllowThreads();
21674 result = (wxEvent *)(arg1)->Clone();
21675 wxPyEndAllowThreads(__tstate);
21676 if (PyErr_Occurred()) SWIG_fail;
21677 }
21678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21679 return resultobj;
21680 fail:
21681 return NULL;
21682 }
21683
21684
21685 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21686 PyObject *obj;
21687 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21688 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21689 return SWIG_Py_Void();
21690 }
21691
21692 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21693 PyObject *resultobj = 0;
21694 wxEvent *arg1 = 0 ;
21695 wxPropagationDisabler *result = 0 ;
21696 void *argp1 = 0 ;
21697 int res1 = 0 ;
21698 PyObject * obj0 = 0 ;
21699 char * kwnames[] = {
21700 (char *) "event", NULL
21701 };
21702
21703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21704 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21705 if (!SWIG_IsOK(res1)) {
21706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21707 }
21708 if (!argp1) {
21709 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21710 }
21711 arg1 = reinterpret_cast< wxEvent * >(argp1);
21712 {
21713 PyThreadState* __tstate = wxPyBeginAllowThreads();
21714 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21719 return resultobj;
21720 fail:
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *resultobj = 0;
21727 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21728 void *argp1 = 0 ;
21729 int res1 = 0 ;
21730 PyObject *swig_obj[1] ;
21731
21732 if (!args) SWIG_fail;
21733 swig_obj[0] = args;
21734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21735 if (!SWIG_IsOK(res1)) {
21736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21737 }
21738 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21739 {
21740 PyThreadState* __tstate = wxPyBeginAllowThreads();
21741 delete arg1;
21742
21743 wxPyEndAllowThreads(__tstate);
21744 if (PyErr_Occurred()) SWIG_fail;
21745 }
21746 resultobj = SWIG_Py_Void();
21747 return resultobj;
21748 fail:
21749 return NULL;
21750 }
21751
21752
21753 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21754 PyObject *obj;
21755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21756 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21757 return SWIG_Py_Void();
21758 }
21759
21760 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21761 return SWIG_Python_InitShadowInstance(args);
21762 }
21763
21764 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21765 PyObject *resultobj = 0;
21766 wxEvent *arg1 = 0 ;
21767 wxPropagateOnce *result = 0 ;
21768 void *argp1 = 0 ;
21769 int res1 = 0 ;
21770 PyObject * obj0 = 0 ;
21771 char * kwnames[] = {
21772 (char *) "event", NULL
21773 };
21774
21775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21776 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21777 if (!SWIG_IsOK(res1)) {
21778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21779 }
21780 if (!argp1) {
21781 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21782 }
21783 arg1 = reinterpret_cast< wxEvent * >(argp1);
21784 {
21785 PyThreadState* __tstate = wxPyBeginAllowThreads();
21786 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21787 wxPyEndAllowThreads(__tstate);
21788 if (PyErr_Occurred()) SWIG_fail;
21789 }
21790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21791 return resultobj;
21792 fail:
21793 return NULL;
21794 }
21795
21796
21797 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21798 PyObject *resultobj = 0;
21799 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21800 void *argp1 = 0 ;
21801 int res1 = 0 ;
21802 PyObject *swig_obj[1] ;
21803
21804 if (!args) SWIG_fail;
21805 swig_obj[0] = args;
21806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21807 if (!SWIG_IsOK(res1)) {
21808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21809 }
21810 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21811 {
21812 PyThreadState* __tstate = wxPyBeginAllowThreads();
21813 delete arg1;
21814
21815 wxPyEndAllowThreads(__tstate);
21816 if (PyErr_Occurred()) SWIG_fail;
21817 }
21818 resultobj = SWIG_Py_Void();
21819 return resultobj;
21820 fail:
21821 return NULL;
21822 }
21823
21824
21825 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21826 PyObject *obj;
21827 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21828 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21829 return SWIG_Py_Void();
21830 }
21831
21832 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21833 return SWIG_Python_InitShadowInstance(args);
21834 }
21835
21836 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21837 PyObject *resultobj = 0;
21838 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21839 int arg2 = (int) 0 ;
21840 wxCommandEvent *result = 0 ;
21841 int val1 ;
21842 int ecode1 = 0 ;
21843 int val2 ;
21844 int ecode2 = 0 ;
21845 PyObject * obj0 = 0 ;
21846 PyObject * obj1 = 0 ;
21847 char * kwnames[] = {
21848 (char *) "commandType",(char *) "winid", NULL
21849 };
21850
21851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21852 if (obj0) {
21853 ecode1 = SWIG_AsVal_int(obj0, &val1);
21854 if (!SWIG_IsOK(ecode1)) {
21855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21856 }
21857 arg1 = static_cast< wxEventType >(val1);
21858 }
21859 if (obj1) {
21860 ecode2 = SWIG_AsVal_int(obj1, &val2);
21861 if (!SWIG_IsOK(ecode2)) {
21862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21863 }
21864 arg2 = static_cast< int >(val2);
21865 }
21866 {
21867 PyThreadState* __tstate = wxPyBeginAllowThreads();
21868 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21869 wxPyEndAllowThreads(__tstate);
21870 if (PyErr_Occurred()) SWIG_fail;
21871 }
21872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21873 return resultobj;
21874 fail:
21875 return NULL;
21876 }
21877
21878
21879 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21880 PyObject *resultobj = 0;
21881 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21882 int result;
21883 void *argp1 = 0 ;
21884 int res1 = 0 ;
21885 PyObject *swig_obj[1] ;
21886
21887 if (!args) SWIG_fail;
21888 swig_obj[0] = args;
21889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21890 if (!SWIG_IsOK(res1)) {
21891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21892 }
21893 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21894 {
21895 PyThreadState* __tstate = wxPyBeginAllowThreads();
21896 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21897 wxPyEndAllowThreads(__tstate);
21898 if (PyErr_Occurred()) SWIG_fail;
21899 }
21900 resultobj = SWIG_From_int(static_cast< int >(result));
21901 return resultobj;
21902 fail:
21903 return NULL;
21904 }
21905
21906
21907 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21908 PyObject *resultobj = 0;
21909 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21910 wxString *arg2 = 0 ;
21911 void *argp1 = 0 ;
21912 int res1 = 0 ;
21913 bool temp2 = false ;
21914 PyObject * obj0 = 0 ;
21915 PyObject * obj1 = 0 ;
21916 char * kwnames[] = {
21917 (char *) "self",(char *) "s", NULL
21918 };
21919
21920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21922 if (!SWIG_IsOK(res1)) {
21923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21924 }
21925 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21926 {
21927 arg2 = wxString_in_helper(obj1);
21928 if (arg2 == NULL) SWIG_fail;
21929 temp2 = true;
21930 }
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 (arg1)->SetString((wxString const &)*arg2);
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 resultobj = SWIG_Py_Void();
21938 {
21939 if (temp2)
21940 delete arg2;
21941 }
21942 return resultobj;
21943 fail:
21944 {
21945 if (temp2)
21946 delete arg2;
21947 }
21948 return NULL;
21949 }
21950
21951
21952 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21953 PyObject *resultobj = 0;
21954 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21955 wxString result;
21956 void *argp1 = 0 ;
21957 int res1 = 0 ;
21958 PyObject *swig_obj[1] ;
21959
21960 if (!args) SWIG_fail;
21961 swig_obj[0] = args;
21962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21963 if (!SWIG_IsOK(res1)) {
21964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21965 }
21966 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21967 {
21968 PyThreadState* __tstate = wxPyBeginAllowThreads();
21969 result = ((wxCommandEvent const *)arg1)->GetString();
21970 wxPyEndAllowThreads(__tstate);
21971 if (PyErr_Occurred()) SWIG_fail;
21972 }
21973 {
21974 #if wxUSE_UNICODE
21975 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21976 #else
21977 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21978 #endif
21979 }
21980 return resultobj;
21981 fail:
21982 return NULL;
21983 }
21984
21985
21986 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21987 PyObject *resultobj = 0;
21988 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21989 bool result;
21990 void *argp1 = 0 ;
21991 int res1 = 0 ;
21992 PyObject *swig_obj[1] ;
21993
21994 if (!args) SWIG_fail;
21995 swig_obj[0] = args;
21996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21997 if (!SWIG_IsOK(res1)) {
21998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21999 }
22000 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22001 {
22002 PyThreadState* __tstate = wxPyBeginAllowThreads();
22003 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
22004 wxPyEndAllowThreads(__tstate);
22005 if (PyErr_Occurred()) SWIG_fail;
22006 }
22007 {
22008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22009 }
22010 return resultobj;
22011 fail:
22012 return NULL;
22013 }
22014
22015
22016 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22017 PyObject *resultobj = 0;
22018 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22019 bool result;
22020 void *argp1 = 0 ;
22021 int res1 = 0 ;
22022 PyObject *swig_obj[1] ;
22023
22024 if (!args) SWIG_fail;
22025 swig_obj[0] = args;
22026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22027 if (!SWIG_IsOK(res1)) {
22028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22029 }
22030 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22031 {
22032 PyThreadState* __tstate = wxPyBeginAllowThreads();
22033 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
22034 wxPyEndAllowThreads(__tstate);
22035 if (PyErr_Occurred()) SWIG_fail;
22036 }
22037 {
22038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22039 }
22040 return resultobj;
22041 fail:
22042 return NULL;
22043 }
22044
22045
22046 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22047 PyObject *resultobj = 0;
22048 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22049 long arg2 ;
22050 void *argp1 = 0 ;
22051 int res1 = 0 ;
22052 long val2 ;
22053 int ecode2 = 0 ;
22054 PyObject * obj0 = 0 ;
22055 PyObject * obj1 = 0 ;
22056 char * kwnames[] = {
22057 (char *) "self",(char *) "extraLong", NULL
22058 };
22059
22060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
22061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22062 if (!SWIG_IsOK(res1)) {
22063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22064 }
22065 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22066 ecode2 = SWIG_AsVal_long(obj1, &val2);
22067 if (!SWIG_IsOK(ecode2)) {
22068 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
22069 }
22070 arg2 = static_cast< long >(val2);
22071 {
22072 PyThreadState* __tstate = wxPyBeginAllowThreads();
22073 (arg1)->SetExtraLong(arg2);
22074 wxPyEndAllowThreads(__tstate);
22075 if (PyErr_Occurred()) SWIG_fail;
22076 }
22077 resultobj = SWIG_Py_Void();
22078 return resultobj;
22079 fail:
22080 return NULL;
22081 }
22082
22083
22084 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22085 PyObject *resultobj = 0;
22086 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22087 long result;
22088 void *argp1 = 0 ;
22089 int res1 = 0 ;
22090 PyObject *swig_obj[1] ;
22091
22092 if (!args) SWIG_fail;
22093 swig_obj[0] = args;
22094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22095 if (!SWIG_IsOK(res1)) {
22096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22097 }
22098 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22099 {
22100 PyThreadState* __tstate = wxPyBeginAllowThreads();
22101 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22102 wxPyEndAllowThreads(__tstate);
22103 if (PyErr_Occurred()) SWIG_fail;
22104 }
22105 resultobj = SWIG_From_long(static_cast< long >(result));
22106 return resultobj;
22107 fail:
22108 return NULL;
22109 }
22110
22111
22112 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22113 PyObject *resultobj = 0;
22114 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22115 int arg2 ;
22116 void *argp1 = 0 ;
22117 int res1 = 0 ;
22118 int val2 ;
22119 int ecode2 = 0 ;
22120 PyObject * obj0 = 0 ;
22121 PyObject * obj1 = 0 ;
22122 char * kwnames[] = {
22123 (char *) "self",(char *) "i", NULL
22124 };
22125
22126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22130 }
22131 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22132 ecode2 = SWIG_AsVal_int(obj1, &val2);
22133 if (!SWIG_IsOK(ecode2)) {
22134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22135 }
22136 arg2 = static_cast< int >(val2);
22137 {
22138 PyThreadState* __tstate = wxPyBeginAllowThreads();
22139 (arg1)->SetInt(arg2);
22140 wxPyEndAllowThreads(__tstate);
22141 if (PyErr_Occurred()) SWIG_fail;
22142 }
22143 resultobj = SWIG_Py_Void();
22144 return resultobj;
22145 fail:
22146 return NULL;
22147 }
22148
22149
22150 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22151 PyObject *resultobj = 0;
22152 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22153 int result;
22154 void *argp1 = 0 ;
22155 int res1 = 0 ;
22156 PyObject *swig_obj[1] ;
22157
22158 if (!args) SWIG_fail;
22159 swig_obj[0] = args;
22160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22161 if (!SWIG_IsOK(res1)) {
22162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22163 }
22164 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22165 {
22166 PyThreadState* __tstate = wxPyBeginAllowThreads();
22167 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22168 wxPyEndAllowThreads(__tstate);
22169 if (PyErr_Occurred()) SWIG_fail;
22170 }
22171 resultobj = SWIG_From_int(static_cast< int >(result));
22172 return resultobj;
22173 fail:
22174 return NULL;
22175 }
22176
22177
22178 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22179 PyObject *resultobj = 0;
22180 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22181 PyObject *result = 0 ;
22182 void *argp1 = 0 ;
22183 int res1 = 0 ;
22184 PyObject *swig_obj[1] ;
22185
22186 if (!args) SWIG_fail;
22187 swig_obj[0] = args;
22188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22189 if (!SWIG_IsOK(res1)) {
22190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22191 }
22192 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22193 {
22194 PyThreadState* __tstate = wxPyBeginAllowThreads();
22195 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22196 wxPyEndAllowThreads(__tstate);
22197 if (PyErr_Occurred()) SWIG_fail;
22198 }
22199 resultobj = result;
22200 return resultobj;
22201 fail:
22202 return NULL;
22203 }
22204
22205
22206 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22207 PyObject *resultobj = 0;
22208 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22209 PyObject *arg2 = (PyObject *) 0 ;
22210 void *argp1 = 0 ;
22211 int res1 = 0 ;
22212 PyObject * obj0 = 0 ;
22213 PyObject * obj1 = 0 ;
22214 char * kwnames[] = {
22215 (char *) "self",(char *) "clientData", NULL
22216 };
22217
22218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22220 if (!SWIG_IsOK(res1)) {
22221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22222 }
22223 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22224 arg2 = obj1;
22225 {
22226 PyThreadState* __tstate = wxPyBeginAllowThreads();
22227 wxCommandEvent_SetClientData(arg1,arg2);
22228 wxPyEndAllowThreads(__tstate);
22229 if (PyErr_Occurred()) SWIG_fail;
22230 }
22231 resultobj = SWIG_Py_Void();
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22239 PyObject *resultobj = 0;
22240 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22241 wxEvent *result = 0 ;
22242 void *argp1 = 0 ;
22243 int res1 = 0 ;
22244 PyObject *swig_obj[1] ;
22245
22246 if (!args) SWIG_fail;
22247 swig_obj[0] = args;
22248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22249 if (!SWIG_IsOK(res1)) {
22250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22251 }
22252 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22253 {
22254 PyThreadState* __tstate = wxPyBeginAllowThreads();
22255 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22256 wxPyEndAllowThreads(__tstate);
22257 if (PyErr_Occurred()) SWIG_fail;
22258 }
22259 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22260 return resultobj;
22261 fail:
22262 return NULL;
22263 }
22264
22265
22266 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22267 PyObject *obj;
22268 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22269 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22270 return SWIG_Py_Void();
22271 }
22272
22273 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22274 return SWIG_Python_InitShadowInstance(args);
22275 }
22276
22277 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22278 PyObject *resultobj = 0;
22279 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22280 int arg2 = (int) 0 ;
22281 wxNotifyEvent *result = 0 ;
22282 int val1 ;
22283 int ecode1 = 0 ;
22284 int val2 ;
22285 int ecode2 = 0 ;
22286 PyObject * obj0 = 0 ;
22287 PyObject * obj1 = 0 ;
22288 char * kwnames[] = {
22289 (char *) "commandType",(char *) "winid", NULL
22290 };
22291
22292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22293 if (obj0) {
22294 ecode1 = SWIG_AsVal_int(obj0, &val1);
22295 if (!SWIG_IsOK(ecode1)) {
22296 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22297 }
22298 arg1 = static_cast< wxEventType >(val1);
22299 }
22300 if (obj1) {
22301 ecode2 = SWIG_AsVal_int(obj1, &val2);
22302 if (!SWIG_IsOK(ecode2)) {
22303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22304 }
22305 arg2 = static_cast< int >(val2);
22306 }
22307 {
22308 PyThreadState* __tstate = wxPyBeginAllowThreads();
22309 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22314 return resultobj;
22315 fail:
22316 return NULL;
22317 }
22318
22319
22320 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22321 PyObject *resultobj = 0;
22322 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22323 void *argp1 = 0 ;
22324 int res1 = 0 ;
22325 PyObject *swig_obj[1] ;
22326
22327 if (!args) SWIG_fail;
22328 swig_obj[0] = args;
22329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22330 if (!SWIG_IsOK(res1)) {
22331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22332 }
22333 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22334 {
22335 PyThreadState* __tstate = wxPyBeginAllowThreads();
22336 (arg1)->Veto();
22337 wxPyEndAllowThreads(__tstate);
22338 if (PyErr_Occurred()) SWIG_fail;
22339 }
22340 resultobj = SWIG_Py_Void();
22341 return resultobj;
22342 fail:
22343 return NULL;
22344 }
22345
22346
22347 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22348 PyObject *resultobj = 0;
22349 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22350 void *argp1 = 0 ;
22351 int res1 = 0 ;
22352 PyObject *swig_obj[1] ;
22353
22354 if (!args) SWIG_fail;
22355 swig_obj[0] = args;
22356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22357 if (!SWIG_IsOK(res1)) {
22358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22359 }
22360 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22361 {
22362 PyThreadState* __tstate = wxPyBeginAllowThreads();
22363 (arg1)->Allow();
22364 wxPyEndAllowThreads(__tstate);
22365 if (PyErr_Occurred()) SWIG_fail;
22366 }
22367 resultobj = SWIG_Py_Void();
22368 return resultobj;
22369 fail:
22370 return NULL;
22371 }
22372
22373
22374 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22375 PyObject *resultobj = 0;
22376 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22377 bool result;
22378 void *argp1 = 0 ;
22379 int res1 = 0 ;
22380 PyObject *swig_obj[1] ;
22381
22382 if (!args) SWIG_fail;
22383 swig_obj[0] = args;
22384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22385 if (!SWIG_IsOK(res1)) {
22386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22387 }
22388 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22389 {
22390 PyThreadState* __tstate = wxPyBeginAllowThreads();
22391 result = (bool)(arg1)->IsAllowed();
22392 wxPyEndAllowThreads(__tstate);
22393 if (PyErr_Occurred()) SWIG_fail;
22394 }
22395 {
22396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22397 }
22398 return resultobj;
22399 fail:
22400 return NULL;
22401 }
22402
22403
22404 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22405 PyObject *obj;
22406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22407 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22408 return SWIG_Py_Void();
22409 }
22410
22411 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22412 return SWIG_Python_InitShadowInstance(args);
22413 }
22414
22415 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22416 PyObject *resultobj = 0;
22417 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22418 int arg2 = (int) 0 ;
22419 int arg3 = (int) 0 ;
22420 int arg4 = (int) 0 ;
22421 wxScrollEvent *result = 0 ;
22422 int val1 ;
22423 int ecode1 = 0 ;
22424 int val2 ;
22425 int ecode2 = 0 ;
22426 int val3 ;
22427 int ecode3 = 0 ;
22428 int val4 ;
22429 int ecode4 = 0 ;
22430 PyObject * obj0 = 0 ;
22431 PyObject * obj1 = 0 ;
22432 PyObject * obj2 = 0 ;
22433 PyObject * obj3 = 0 ;
22434 char * kwnames[] = {
22435 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22436 };
22437
22438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22439 if (obj0) {
22440 ecode1 = SWIG_AsVal_int(obj0, &val1);
22441 if (!SWIG_IsOK(ecode1)) {
22442 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22443 }
22444 arg1 = static_cast< wxEventType >(val1);
22445 }
22446 if (obj1) {
22447 ecode2 = SWIG_AsVal_int(obj1, &val2);
22448 if (!SWIG_IsOK(ecode2)) {
22449 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22450 }
22451 arg2 = static_cast< int >(val2);
22452 }
22453 if (obj2) {
22454 ecode3 = SWIG_AsVal_int(obj2, &val3);
22455 if (!SWIG_IsOK(ecode3)) {
22456 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22457 }
22458 arg3 = static_cast< int >(val3);
22459 }
22460 if (obj3) {
22461 ecode4 = SWIG_AsVal_int(obj3, &val4);
22462 if (!SWIG_IsOK(ecode4)) {
22463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22464 }
22465 arg4 = static_cast< int >(val4);
22466 }
22467 {
22468 PyThreadState* __tstate = wxPyBeginAllowThreads();
22469 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22470 wxPyEndAllowThreads(__tstate);
22471 if (PyErr_Occurred()) SWIG_fail;
22472 }
22473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22474 return resultobj;
22475 fail:
22476 return NULL;
22477 }
22478
22479
22480 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22481 PyObject *resultobj = 0;
22482 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22483 int result;
22484 void *argp1 = 0 ;
22485 int res1 = 0 ;
22486 PyObject *swig_obj[1] ;
22487
22488 if (!args) SWIG_fail;
22489 swig_obj[0] = args;
22490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22491 if (!SWIG_IsOK(res1)) {
22492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22493 }
22494 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22495 {
22496 PyThreadState* __tstate = wxPyBeginAllowThreads();
22497 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22498 wxPyEndAllowThreads(__tstate);
22499 if (PyErr_Occurred()) SWIG_fail;
22500 }
22501 resultobj = SWIG_From_int(static_cast< int >(result));
22502 return resultobj;
22503 fail:
22504 return NULL;
22505 }
22506
22507
22508 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22509 PyObject *resultobj = 0;
22510 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22511 int result;
22512 void *argp1 = 0 ;
22513 int res1 = 0 ;
22514 PyObject *swig_obj[1] ;
22515
22516 if (!args) SWIG_fail;
22517 swig_obj[0] = args;
22518 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22519 if (!SWIG_IsOK(res1)) {
22520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22521 }
22522 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22523 {
22524 PyThreadState* __tstate = wxPyBeginAllowThreads();
22525 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22526 wxPyEndAllowThreads(__tstate);
22527 if (PyErr_Occurred()) SWIG_fail;
22528 }
22529 resultobj = SWIG_From_int(static_cast< int >(result));
22530 return resultobj;
22531 fail:
22532 return NULL;
22533 }
22534
22535
22536 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22537 PyObject *resultobj = 0;
22538 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22539 int arg2 ;
22540 void *argp1 = 0 ;
22541 int res1 = 0 ;
22542 int val2 ;
22543 int ecode2 = 0 ;
22544 PyObject * obj0 = 0 ;
22545 PyObject * obj1 = 0 ;
22546 char * kwnames[] = {
22547 (char *) "self",(char *) "orient", NULL
22548 };
22549
22550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22552 if (!SWIG_IsOK(res1)) {
22553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22554 }
22555 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22556 ecode2 = SWIG_AsVal_int(obj1, &val2);
22557 if (!SWIG_IsOK(ecode2)) {
22558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22559 }
22560 arg2 = static_cast< int >(val2);
22561 {
22562 PyThreadState* __tstate = wxPyBeginAllowThreads();
22563 (arg1)->SetOrientation(arg2);
22564 wxPyEndAllowThreads(__tstate);
22565 if (PyErr_Occurred()) SWIG_fail;
22566 }
22567 resultobj = SWIG_Py_Void();
22568 return resultobj;
22569 fail:
22570 return NULL;
22571 }
22572
22573
22574 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22575 PyObject *resultobj = 0;
22576 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22577 int arg2 ;
22578 void *argp1 = 0 ;
22579 int res1 = 0 ;
22580 int val2 ;
22581 int ecode2 = 0 ;
22582 PyObject * obj0 = 0 ;
22583 PyObject * obj1 = 0 ;
22584 char * kwnames[] = {
22585 (char *) "self",(char *) "pos", NULL
22586 };
22587
22588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22590 if (!SWIG_IsOK(res1)) {
22591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22592 }
22593 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22594 ecode2 = SWIG_AsVal_int(obj1, &val2);
22595 if (!SWIG_IsOK(ecode2)) {
22596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22597 }
22598 arg2 = static_cast< int >(val2);
22599 {
22600 PyThreadState* __tstate = wxPyBeginAllowThreads();
22601 (arg1)->SetPosition(arg2);
22602 wxPyEndAllowThreads(__tstate);
22603 if (PyErr_Occurred()) SWIG_fail;
22604 }
22605 resultobj = SWIG_Py_Void();
22606 return resultobj;
22607 fail:
22608 return NULL;
22609 }
22610
22611
22612 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22613 PyObject *obj;
22614 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22615 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22616 return SWIG_Py_Void();
22617 }
22618
22619 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22620 return SWIG_Python_InitShadowInstance(args);
22621 }
22622
22623 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22624 PyObject *resultobj = 0;
22625 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22626 int arg2 = (int) 0 ;
22627 int arg3 = (int) 0 ;
22628 wxScrollWinEvent *result = 0 ;
22629 int val1 ;
22630 int ecode1 = 0 ;
22631 int val2 ;
22632 int ecode2 = 0 ;
22633 int val3 ;
22634 int ecode3 = 0 ;
22635 PyObject * obj0 = 0 ;
22636 PyObject * obj1 = 0 ;
22637 PyObject * obj2 = 0 ;
22638 char * kwnames[] = {
22639 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22640 };
22641
22642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22643 if (obj0) {
22644 ecode1 = SWIG_AsVal_int(obj0, &val1);
22645 if (!SWIG_IsOK(ecode1)) {
22646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22647 }
22648 arg1 = static_cast< wxEventType >(val1);
22649 }
22650 if (obj1) {
22651 ecode2 = SWIG_AsVal_int(obj1, &val2);
22652 if (!SWIG_IsOK(ecode2)) {
22653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22654 }
22655 arg2 = static_cast< int >(val2);
22656 }
22657 if (obj2) {
22658 ecode3 = SWIG_AsVal_int(obj2, &val3);
22659 if (!SWIG_IsOK(ecode3)) {
22660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22661 }
22662 arg3 = static_cast< int >(val3);
22663 }
22664 {
22665 PyThreadState* __tstate = wxPyBeginAllowThreads();
22666 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22667 wxPyEndAllowThreads(__tstate);
22668 if (PyErr_Occurred()) SWIG_fail;
22669 }
22670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22680 int result;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 PyObject *swig_obj[1] ;
22684
22685 if (!args) SWIG_fail;
22686 swig_obj[0] = args;
22687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22688 if (!SWIG_IsOK(res1)) {
22689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22690 }
22691 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22692 {
22693 PyThreadState* __tstate = wxPyBeginAllowThreads();
22694 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22695 wxPyEndAllowThreads(__tstate);
22696 if (PyErr_Occurred()) SWIG_fail;
22697 }
22698 resultobj = SWIG_From_int(static_cast< int >(result));
22699 return resultobj;
22700 fail:
22701 return NULL;
22702 }
22703
22704
22705 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22706 PyObject *resultobj = 0;
22707 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22708 int result;
22709 void *argp1 = 0 ;
22710 int res1 = 0 ;
22711 PyObject *swig_obj[1] ;
22712
22713 if (!args) SWIG_fail;
22714 swig_obj[0] = args;
22715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22716 if (!SWIG_IsOK(res1)) {
22717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22718 }
22719 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22720 {
22721 PyThreadState* __tstate = wxPyBeginAllowThreads();
22722 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22723 wxPyEndAllowThreads(__tstate);
22724 if (PyErr_Occurred()) SWIG_fail;
22725 }
22726 resultobj = SWIG_From_int(static_cast< int >(result));
22727 return resultobj;
22728 fail:
22729 return NULL;
22730 }
22731
22732
22733 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22734 PyObject *resultobj = 0;
22735 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22736 int arg2 ;
22737 void *argp1 = 0 ;
22738 int res1 = 0 ;
22739 int val2 ;
22740 int ecode2 = 0 ;
22741 PyObject * obj0 = 0 ;
22742 PyObject * obj1 = 0 ;
22743 char * kwnames[] = {
22744 (char *) "self",(char *) "orient", NULL
22745 };
22746
22747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22749 if (!SWIG_IsOK(res1)) {
22750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22751 }
22752 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22753 ecode2 = SWIG_AsVal_int(obj1, &val2);
22754 if (!SWIG_IsOK(ecode2)) {
22755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22756 }
22757 arg2 = static_cast< int >(val2);
22758 {
22759 PyThreadState* __tstate = wxPyBeginAllowThreads();
22760 (arg1)->SetOrientation(arg2);
22761 wxPyEndAllowThreads(__tstate);
22762 if (PyErr_Occurred()) SWIG_fail;
22763 }
22764 resultobj = SWIG_Py_Void();
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22772 PyObject *resultobj = 0;
22773 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22774 int arg2 ;
22775 void *argp1 = 0 ;
22776 int res1 = 0 ;
22777 int val2 ;
22778 int ecode2 = 0 ;
22779 PyObject * obj0 = 0 ;
22780 PyObject * obj1 = 0 ;
22781 char * kwnames[] = {
22782 (char *) "self",(char *) "pos", NULL
22783 };
22784
22785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22787 if (!SWIG_IsOK(res1)) {
22788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22789 }
22790 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22791 ecode2 = SWIG_AsVal_int(obj1, &val2);
22792 if (!SWIG_IsOK(ecode2)) {
22793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22794 }
22795 arg2 = static_cast< int >(val2);
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 (arg1)->SetPosition(arg2);
22799 wxPyEndAllowThreads(__tstate);
22800 if (PyErr_Occurred()) SWIG_fail;
22801 }
22802 resultobj = SWIG_Py_Void();
22803 return resultobj;
22804 fail:
22805 return NULL;
22806 }
22807
22808
22809 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22810 PyObject *obj;
22811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22812 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22813 return SWIG_Py_Void();
22814 }
22815
22816 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22817 return SWIG_Python_InitShadowInstance(args);
22818 }
22819
22820 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22821 PyObject *resultobj = 0;
22822 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22823 wxMouseEvent *result = 0 ;
22824 int val1 ;
22825 int ecode1 = 0 ;
22826 PyObject * obj0 = 0 ;
22827 char * kwnames[] = {
22828 (char *) "mouseType", NULL
22829 };
22830
22831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22832 if (obj0) {
22833 ecode1 = SWIG_AsVal_int(obj0, &val1);
22834 if (!SWIG_IsOK(ecode1)) {
22835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22836 }
22837 arg1 = static_cast< wxEventType >(val1);
22838 }
22839 {
22840 PyThreadState* __tstate = wxPyBeginAllowThreads();
22841 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22842 wxPyEndAllowThreads(__tstate);
22843 if (PyErr_Occurred()) SWIG_fail;
22844 }
22845 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22846 return resultobj;
22847 fail:
22848 return NULL;
22849 }
22850
22851
22852 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22853 PyObject *resultobj = 0;
22854 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22855 bool result;
22856 void *argp1 = 0 ;
22857 int res1 = 0 ;
22858 PyObject *swig_obj[1] ;
22859
22860 if (!args) SWIG_fail;
22861 swig_obj[0] = args;
22862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22863 if (!SWIG_IsOK(res1)) {
22864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22865 }
22866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22867 {
22868 PyThreadState* __tstate = wxPyBeginAllowThreads();
22869 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22870 wxPyEndAllowThreads(__tstate);
22871 if (PyErr_Occurred()) SWIG_fail;
22872 }
22873 {
22874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22875 }
22876 return resultobj;
22877 fail:
22878 return NULL;
22879 }
22880
22881
22882 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22883 PyObject *resultobj = 0;
22884 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22885 int arg2 = (int) wxMOUSE_BTN_ANY ;
22886 bool result;
22887 void *argp1 = 0 ;
22888 int res1 = 0 ;
22889 int val2 ;
22890 int ecode2 = 0 ;
22891 PyObject * obj0 = 0 ;
22892 PyObject * obj1 = 0 ;
22893 char * kwnames[] = {
22894 (char *) "self",(char *) "but", NULL
22895 };
22896
22897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22899 if (!SWIG_IsOK(res1)) {
22900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22901 }
22902 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22903 if (obj1) {
22904 ecode2 = SWIG_AsVal_int(obj1, &val2);
22905 if (!SWIG_IsOK(ecode2)) {
22906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22907 }
22908 arg2 = static_cast< int >(val2);
22909 }
22910 {
22911 PyThreadState* __tstate = wxPyBeginAllowThreads();
22912 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 {
22917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22918 }
22919 return resultobj;
22920 fail:
22921 return NULL;
22922 }
22923
22924
22925 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22926 PyObject *resultobj = 0;
22927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22928 int arg2 = (int) wxMOUSE_BTN_ANY ;
22929 bool result;
22930 void *argp1 = 0 ;
22931 int res1 = 0 ;
22932 int val2 ;
22933 int ecode2 = 0 ;
22934 PyObject * obj0 = 0 ;
22935 PyObject * obj1 = 0 ;
22936 char * kwnames[] = {
22937 (char *) "self",(char *) "but", NULL
22938 };
22939
22940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22944 }
22945 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22946 if (obj1) {
22947 ecode2 = SWIG_AsVal_int(obj1, &val2);
22948 if (!SWIG_IsOK(ecode2)) {
22949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22950 }
22951 arg2 = static_cast< int >(val2);
22952 }
22953 {
22954 PyThreadState* __tstate = wxPyBeginAllowThreads();
22955 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22956 wxPyEndAllowThreads(__tstate);
22957 if (PyErr_Occurred()) SWIG_fail;
22958 }
22959 {
22960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22961 }
22962 return resultobj;
22963 fail:
22964 return NULL;
22965 }
22966
22967
22968 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22969 PyObject *resultobj = 0;
22970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22971 int arg2 = (int) wxMOUSE_BTN_ANY ;
22972 bool result;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 int val2 ;
22976 int ecode2 = 0 ;
22977 PyObject * obj0 = 0 ;
22978 PyObject * obj1 = 0 ;
22979 char * kwnames[] = {
22980 (char *) "self",(char *) "but", NULL
22981 };
22982
22983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22985 if (!SWIG_IsOK(res1)) {
22986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22987 }
22988 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22989 if (obj1) {
22990 ecode2 = SWIG_AsVal_int(obj1, &val2);
22991 if (!SWIG_IsOK(ecode2)) {
22992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22993 }
22994 arg2 = static_cast< int >(val2);
22995 }
22996 {
22997 PyThreadState* __tstate = wxPyBeginAllowThreads();
22998 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22999 wxPyEndAllowThreads(__tstate);
23000 if (PyErr_Occurred()) SWIG_fail;
23001 }
23002 {
23003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23004 }
23005 return resultobj;
23006 fail:
23007 return NULL;
23008 }
23009
23010
23011 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23012 PyObject *resultobj = 0;
23013 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23014 int arg2 ;
23015 bool result;
23016 void *argp1 = 0 ;
23017 int res1 = 0 ;
23018 int val2 ;
23019 int ecode2 = 0 ;
23020 PyObject * obj0 = 0 ;
23021 PyObject * obj1 = 0 ;
23022 char * kwnames[] = {
23023 (char *) "self",(char *) "button", NULL
23024 };
23025
23026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
23027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23028 if (!SWIG_IsOK(res1)) {
23029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23030 }
23031 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23032 ecode2 = SWIG_AsVal_int(obj1, &val2);
23033 if (!SWIG_IsOK(ecode2)) {
23034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
23035 }
23036 arg2 = static_cast< int >(val2);
23037 {
23038 PyThreadState* __tstate = wxPyBeginAllowThreads();
23039 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
23040 wxPyEndAllowThreads(__tstate);
23041 if (PyErr_Occurred()) SWIG_fail;
23042 }
23043 {
23044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23045 }
23046 return resultobj;
23047 fail:
23048 return NULL;
23049 }
23050
23051
23052 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23053 PyObject *resultobj = 0;
23054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23055 int arg2 ;
23056 bool result;
23057 void *argp1 = 0 ;
23058 int res1 = 0 ;
23059 int val2 ;
23060 int ecode2 = 0 ;
23061 PyObject * obj0 = 0 ;
23062 PyObject * obj1 = 0 ;
23063 char * kwnames[] = {
23064 (char *) "self",(char *) "but", NULL
23065 };
23066
23067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
23068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23069 if (!SWIG_IsOK(res1)) {
23070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23071 }
23072 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23073 ecode2 = SWIG_AsVal_int(obj1, &val2);
23074 if (!SWIG_IsOK(ecode2)) {
23075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
23076 }
23077 arg2 = static_cast< int >(val2);
23078 {
23079 PyThreadState* __tstate = wxPyBeginAllowThreads();
23080 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
23081 wxPyEndAllowThreads(__tstate);
23082 if (PyErr_Occurred()) SWIG_fail;
23083 }
23084 {
23085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23086 }
23087 return resultobj;
23088 fail:
23089 return NULL;
23090 }
23091
23092
23093 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23094 PyObject *resultobj = 0;
23095 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23096 int result;
23097 void *argp1 = 0 ;
23098 int res1 = 0 ;
23099 PyObject *swig_obj[1] ;
23100
23101 if (!args) SWIG_fail;
23102 swig_obj[0] = args;
23103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23104 if (!SWIG_IsOK(res1)) {
23105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23106 }
23107 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23108 {
23109 PyThreadState* __tstate = wxPyBeginAllowThreads();
23110 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23111 wxPyEndAllowThreads(__tstate);
23112 if (PyErr_Occurred()) SWIG_fail;
23113 }
23114 resultobj = SWIG_From_int(static_cast< int >(result));
23115 return resultobj;
23116 fail:
23117 return NULL;
23118 }
23119
23120
23121 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23122 PyObject *resultobj = 0;
23123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23124 bool result;
23125 void *argp1 = 0 ;
23126 int res1 = 0 ;
23127 PyObject *swig_obj[1] ;
23128
23129 if (!args) SWIG_fail;
23130 swig_obj[0] = args;
23131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23132 if (!SWIG_IsOK(res1)) {
23133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23134 }
23135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23136 {
23137 PyThreadState* __tstate = wxPyBeginAllowThreads();
23138 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23139 wxPyEndAllowThreads(__tstate);
23140 if (PyErr_Occurred()) SWIG_fail;
23141 }
23142 {
23143 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23144 }
23145 return resultobj;
23146 fail:
23147 return NULL;
23148 }
23149
23150
23151 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23152 PyObject *resultobj = 0;
23153 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23154 bool result;
23155 void *argp1 = 0 ;
23156 int res1 = 0 ;
23157 PyObject *swig_obj[1] ;
23158
23159 if (!args) SWIG_fail;
23160 swig_obj[0] = args;
23161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23162 if (!SWIG_IsOK(res1)) {
23163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23164 }
23165 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23166 {
23167 PyThreadState* __tstate = wxPyBeginAllowThreads();
23168 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23169 wxPyEndAllowThreads(__tstate);
23170 if (PyErr_Occurred()) SWIG_fail;
23171 }
23172 {
23173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23174 }
23175 return resultobj;
23176 fail:
23177 return NULL;
23178 }
23179
23180
23181 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23182 PyObject *resultobj = 0;
23183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23184 bool result;
23185 void *argp1 = 0 ;
23186 int res1 = 0 ;
23187 PyObject *swig_obj[1] ;
23188
23189 if (!args) SWIG_fail;
23190 swig_obj[0] = args;
23191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23192 if (!SWIG_IsOK(res1)) {
23193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23194 }
23195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23196 {
23197 PyThreadState* __tstate = wxPyBeginAllowThreads();
23198 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23199 wxPyEndAllowThreads(__tstate);
23200 if (PyErr_Occurred()) SWIG_fail;
23201 }
23202 {
23203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23204 }
23205 return resultobj;
23206 fail:
23207 return NULL;
23208 }
23209
23210
23211 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23212 PyObject *resultobj = 0;
23213 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23214 bool result;
23215 void *argp1 = 0 ;
23216 int res1 = 0 ;
23217 PyObject *swig_obj[1] ;
23218
23219 if (!args) SWIG_fail;
23220 swig_obj[0] = args;
23221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23222 if (!SWIG_IsOK(res1)) {
23223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23224 }
23225 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23226 {
23227 PyThreadState* __tstate = wxPyBeginAllowThreads();
23228 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23229 wxPyEndAllowThreads(__tstate);
23230 if (PyErr_Occurred()) SWIG_fail;
23231 }
23232 {
23233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23234 }
23235 return resultobj;
23236 fail:
23237 return NULL;
23238 }
23239
23240
23241 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23242 PyObject *resultobj = 0;
23243 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23244 bool result;
23245 void *argp1 = 0 ;
23246 int res1 = 0 ;
23247 PyObject *swig_obj[1] ;
23248
23249 if (!args) SWIG_fail;
23250 swig_obj[0] = args;
23251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23252 if (!SWIG_IsOK(res1)) {
23253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23254 }
23255 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23256 {
23257 PyThreadState* __tstate = wxPyBeginAllowThreads();
23258 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23259 wxPyEndAllowThreads(__tstate);
23260 if (PyErr_Occurred()) SWIG_fail;
23261 }
23262 {
23263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23264 }
23265 return resultobj;
23266 fail:
23267 return NULL;
23268 }
23269
23270
23271 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23272 PyObject *resultobj = 0;
23273 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23274 bool result;
23275 void *argp1 = 0 ;
23276 int res1 = 0 ;
23277 PyObject *swig_obj[1] ;
23278
23279 if (!args) SWIG_fail;
23280 swig_obj[0] = args;
23281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23282 if (!SWIG_IsOK(res1)) {
23283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23284 }
23285 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 {
23293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23294 }
23295 return resultobj;
23296 fail:
23297 return NULL;
23298 }
23299
23300
23301 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23302 PyObject *resultobj = 0;
23303 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23304 bool result;
23305 void *argp1 = 0 ;
23306 int res1 = 0 ;
23307 PyObject *swig_obj[1] ;
23308
23309 if (!args) SWIG_fail;
23310 swig_obj[0] = args;
23311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23312 if (!SWIG_IsOK(res1)) {
23313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23314 }
23315 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23316 {
23317 PyThreadState* __tstate = wxPyBeginAllowThreads();
23318 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 {
23323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23324 }
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23332 PyObject *resultobj = 0;
23333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23334 bool result;
23335 void *argp1 = 0 ;
23336 int res1 = 0 ;
23337 PyObject *swig_obj[1] ;
23338
23339 if (!args) SWIG_fail;
23340 swig_obj[0] = args;
23341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23342 if (!SWIG_IsOK(res1)) {
23343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23344 }
23345 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23346 {
23347 PyThreadState* __tstate = wxPyBeginAllowThreads();
23348 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23349 wxPyEndAllowThreads(__tstate);
23350 if (PyErr_Occurred()) SWIG_fail;
23351 }
23352 {
23353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23354 }
23355 return resultobj;
23356 fail:
23357 return NULL;
23358 }
23359
23360
23361 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23362 PyObject *resultobj = 0;
23363 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23364 bool result;
23365 void *argp1 = 0 ;
23366 int res1 = 0 ;
23367 PyObject *swig_obj[1] ;
23368
23369 if (!args) SWIG_fail;
23370 swig_obj[0] = args;
23371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23372 if (!SWIG_IsOK(res1)) {
23373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23374 }
23375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23376 {
23377 PyThreadState* __tstate = wxPyBeginAllowThreads();
23378 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23379 wxPyEndAllowThreads(__tstate);
23380 if (PyErr_Occurred()) SWIG_fail;
23381 }
23382 {
23383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23384 }
23385 return resultobj;
23386 fail:
23387 return NULL;
23388 }
23389
23390
23391 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23392 PyObject *resultobj = 0;
23393 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23394 bool result;
23395 void *argp1 = 0 ;
23396 int res1 = 0 ;
23397 PyObject *swig_obj[1] ;
23398
23399 if (!args) SWIG_fail;
23400 swig_obj[0] = args;
23401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23402 if (!SWIG_IsOK(res1)) {
23403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23404 }
23405 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23406 {
23407 PyThreadState* __tstate = wxPyBeginAllowThreads();
23408 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23409 wxPyEndAllowThreads(__tstate);
23410 if (PyErr_Occurred()) SWIG_fail;
23411 }
23412 {
23413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23414 }
23415 return resultobj;
23416 fail:
23417 return NULL;
23418 }
23419
23420
23421 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23422 PyObject *resultobj = 0;
23423 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23424 bool result;
23425 void *argp1 = 0 ;
23426 int res1 = 0 ;
23427 PyObject *swig_obj[1] ;
23428
23429 if (!args) SWIG_fail;
23430 swig_obj[0] = args;
23431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23432 if (!SWIG_IsOK(res1)) {
23433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23434 }
23435 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23436 {
23437 PyThreadState* __tstate = wxPyBeginAllowThreads();
23438 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23439 wxPyEndAllowThreads(__tstate);
23440 if (PyErr_Occurred()) SWIG_fail;
23441 }
23442 {
23443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23444 }
23445 return resultobj;
23446 fail:
23447 return NULL;
23448 }
23449
23450
23451 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23452 PyObject *resultobj = 0;
23453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23454 bool result;
23455 void *argp1 = 0 ;
23456 int res1 = 0 ;
23457 PyObject *swig_obj[1] ;
23458
23459 if (!args) SWIG_fail;
23460 swig_obj[0] = args;
23461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23462 if (!SWIG_IsOK(res1)) {
23463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23464 }
23465 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23469 wxPyEndAllowThreads(__tstate);
23470 if (PyErr_Occurred()) SWIG_fail;
23471 }
23472 {
23473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23474 }
23475 return resultobj;
23476 fail:
23477 return NULL;
23478 }
23479
23480
23481 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23482 PyObject *resultobj = 0;
23483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23484 bool result;
23485 void *argp1 = 0 ;
23486 int res1 = 0 ;
23487 PyObject *swig_obj[1] ;
23488
23489 if (!args) SWIG_fail;
23490 swig_obj[0] = args;
23491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23492 if (!SWIG_IsOK(res1)) {
23493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23494 }
23495 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23496 {
23497 PyThreadState* __tstate = wxPyBeginAllowThreads();
23498 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23499 wxPyEndAllowThreads(__tstate);
23500 if (PyErr_Occurred()) SWIG_fail;
23501 }
23502 {
23503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23504 }
23505 return resultobj;
23506 fail:
23507 return NULL;
23508 }
23509
23510
23511 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23512 PyObject *resultobj = 0;
23513 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23514 bool result;
23515 void *argp1 = 0 ;
23516 int res1 = 0 ;
23517 PyObject *swig_obj[1] ;
23518
23519 if (!args) SWIG_fail;
23520 swig_obj[0] = args;
23521 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23522 if (!SWIG_IsOK(res1)) {
23523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23524 }
23525 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23526 {
23527 PyThreadState* __tstate = wxPyBeginAllowThreads();
23528 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 {
23533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23534 }
23535 return resultobj;
23536 fail:
23537 return NULL;
23538 }
23539
23540
23541 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23542 PyObject *resultobj = 0;
23543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23544 bool result;
23545 void *argp1 = 0 ;
23546 int res1 = 0 ;
23547 PyObject *swig_obj[1] ;
23548
23549 if (!args) SWIG_fail;
23550 swig_obj[0] = args;
23551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23552 if (!SWIG_IsOK(res1)) {
23553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23554 }
23555 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23556 {
23557 PyThreadState* __tstate = wxPyBeginAllowThreads();
23558 result = (bool)(arg1)->LeftIsDown();
23559 wxPyEndAllowThreads(__tstate);
23560 if (PyErr_Occurred()) SWIG_fail;
23561 }
23562 {
23563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23564 }
23565 return resultobj;
23566 fail:
23567 return NULL;
23568 }
23569
23570
23571 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23572 PyObject *resultobj = 0;
23573 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23574 bool result;
23575 void *argp1 = 0 ;
23576 int res1 = 0 ;
23577 PyObject *swig_obj[1] ;
23578
23579 if (!args) SWIG_fail;
23580 swig_obj[0] = args;
23581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23582 if (!SWIG_IsOK(res1)) {
23583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23584 }
23585 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23586 {
23587 PyThreadState* __tstate = wxPyBeginAllowThreads();
23588 result = (bool)(arg1)->MiddleIsDown();
23589 wxPyEndAllowThreads(__tstate);
23590 if (PyErr_Occurred()) SWIG_fail;
23591 }
23592 {
23593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23594 }
23595 return resultobj;
23596 fail:
23597 return NULL;
23598 }
23599
23600
23601 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23602 PyObject *resultobj = 0;
23603 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23604 bool result;
23605 void *argp1 = 0 ;
23606 int res1 = 0 ;
23607 PyObject *swig_obj[1] ;
23608
23609 if (!args) SWIG_fail;
23610 swig_obj[0] = args;
23611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23612 if (!SWIG_IsOK(res1)) {
23613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23614 }
23615 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23616 {
23617 PyThreadState* __tstate = wxPyBeginAllowThreads();
23618 result = (bool)(arg1)->RightIsDown();
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23632 PyObject *resultobj = 0;
23633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23634 bool result;
23635 void *argp1 = 0 ;
23636 int res1 = 0 ;
23637 PyObject *swig_obj[1] ;
23638
23639 if (!args) SWIG_fail;
23640 swig_obj[0] = args;
23641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23642 if (!SWIG_IsOK(res1)) {
23643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23644 }
23645 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23646 {
23647 PyThreadState* __tstate = wxPyBeginAllowThreads();
23648 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23649 wxPyEndAllowThreads(__tstate);
23650 if (PyErr_Occurred()) SWIG_fail;
23651 }
23652 {
23653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23654 }
23655 return resultobj;
23656 fail:
23657 return NULL;
23658 }
23659
23660
23661 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23662 PyObject *resultobj = 0;
23663 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23664 bool result;
23665 void *argp1 = 0 ;
23666 int res1 = 0 ;
23667 PyObject *swig_obj[1] ;
23668
23669 if (!args) SWIG_fail;
23670 swig_obj[0] = args;
23671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23672 if (!SWIG_IsOK(res1)) {
23673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23674 }
23675 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23676 {
23677 PyThreadState* __tstate = wxPyBeginAllowThreads();
23678 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23679 wxPyEndAllowThreads(__tstate);
23680 if (PyErr_Occurred()) SWIG_fail;
23681 }
23682 {
23683 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23684 }
23685 return resultobj;
23686 fail:
23687 return NULL;
23688 }
23689
23690
23691 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23692 PyObject *resultobj = 0;
23693 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23694 bool result;
23695 void *argp1 = 0 ;
23696 int res1 = 0 ;
23697 PyObject *swig_obj[1] ;
23698
23699 if (!args) SWIG_fail;
23700 swig_obj[0] = args;
23701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23702 if (!SWIG_IsOK(res1)) {
23703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23704 }
23705 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23706 {
23707 PyThreadState* __tstate = wxPyBeginAllowThreads();
23708 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23709 wxPyEndAllowThreads(__tstate);
23710 if (PyErr_Occurred()) SWIG_fail;
23711 }
23712 {
23713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23714 }
23715 return resultobj;
23716 fail:
23717 return NULL;
23718 }
23719
23720
23721 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23722 PyObject *resultobj = 0;
23723 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23724 bool result;
23725 void *argp1 = 0 ;
23726 int res1 = 0 ;
23727 PyObject *swig_obj[1] ;
23728
23729 if (!args) SWIG_fail;
23730 swig_obj[0] = args;
23731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23732 if (!SWIG_IsOK(res1)) {
23733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23734 }
23735 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23736 {
23737 PyThreadState* __tstate = wxPyBeginAllowThreads();
23738 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23739 wxPyEndAllowThreads(__tstate);
23740 if (PyErr_Occurred()) SWIG_fail;
23741 }
23742 {
23743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23744 }
23745 return resultobj;
23746 fail:
23747 return NULL;
23748 }
23749
23750
23751 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23752 PyObject *resultobj = 0;
23753 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23754 wxPoint result;
23755 void *argp1 = 0 ;
23756 int res1 = 0 ;
23757 PyObject *swig_obj[1] ;
23758
23759 if (!args) SWIG_fail;
23760 swig_obj[0] = args;
23761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23762 if (!SWIG_IsOK(res1)) {
23763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23764 }
23765 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23766 {
23767 PyThreadState* __tstate = wxPyBeginAllowThreads();
23768 result = (arg1)->GetPosition();
23769 wxPyEndAllowThreads(__tstate);
23770 if (PyErr_Occurred()) SWIG_fail;
23771 }
23772 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23773 return resultobj;
23774 fail:
23775 return NULL;
23776 }
23777
23778
23779 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23780 PyObject *resultobj = 0;
23781 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23782 long *arg2 = (long *) 0 ;
23783 long *arg3 = (long *) 0 ;
23784 void *argp1 = 0 ;
23785 int res1 = 0 ;
23786 long temp2 ;
23787 int res2 = SWIG_TMPOBJ ;
23788 long temp3 ;
23789 int res3 = SWIG_TMPOBJ ;
23790 PyObject *swig_obj[1] ;
23791
23792 arg2 = &temp2;
23793 arg3 = &temp3;
23794 if (!args) SWIG_fail;
23795 swig_obj[0] = args;
23796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23797 if (!SWIG_IsOK(res1)) {
23798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23799 }
23800 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23801 {
23802 PyThreadState* __tstate = wxPyBeginAllowThreads();
23803 (arg1)->GetPosition(arg2,arg3);
23804 wxPyEndAllowThreads(__tstate);
23805 if (PyErr_Occurred()) SWIG_fail;
23806 }
23807 resultobj = SWIG_Py_Void();
23808 if (SWIG_IsTmpObj(res2)) {
23809 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23810 } else {
23811 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23812 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23813 }
23814 if (SWIG_IsTmpObj(res3)) {
23815 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23816 } else {
23817 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23818 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23819 }
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23827 PyObject *resultobj = 0;
23828 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23829 wxDC *arg2 = 0 ;
23830 wxPoint result;
23831 void *argp1 = 0 ;
23832 int res1 = 0 ;
23833 void *argp2 = 0 ;
23834 int res2 = 0 ;
23835 PyObject * obj0 = 0 ;
23836 PyObject * obj1 = 0 ;
23837 char * kwnames[] = {
23838 (char *) "self",(char *) "dc", NULL
23839 };
23840
23841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23843 if (!SWIG_IsOK(res1)) {
23844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23845 }
23846 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23847 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23848 if (!SWIG_IsOK(res2)) {
23849 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23850 }
23851 if (!argp2) {
23852 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23853 }
23854 arg2 = reinterpret_cast< wxDC * >(argp2);
23855 {
23856 PyThreadState* __tstate = wxPyBeginAllowThreads();
23857 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23862 return resultobj;
23863 fail:
23864 return NULL;
23865 }
23866
23867
23868 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23869 PyObject *resultobj = 0;
23870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23871 int result;
23872 void *argp1 = 0 ;
23873 int res1 = 0 ;
23874 PyObject *swig_obj[1] ;
23875
23876 if (!args) SWIG_fail;
23877 swig_obj[0] = args;
23878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23879 if (!SWIG_IsOK(res1)) {
23880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23881 }
23882 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23883 {
23884 PyThreadState* __tstate = wxPyBeginAllowThreads();
23885 result = (int)((wxMouseEvent const *)arg1)->GetX();
23886 wxPyEndAllowThreads(__tstate);
23887 if (PyErr_Occurred()) SWIG_fail;
23888 }
23889 resultobj = SWIG_From_int(static_cast< int >(result));
23890 return resultobj;
23891 fail:
23892 return NULL;
23893 }
23894
23895
23896 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23897 PyObject *resultobj = 0;
23898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23899 int result;
23900 void *argp1 = 0 ;
23901 int res1 = 0 ;
23902 PyObject *swig_obj[1] ;
23903
23904 if (!args) SWIG_fail;
23905 swig_obj[0] = args;
23906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23907 if (!SWIG_IsOK(res1)) {
23908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23909 }
23910 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23911 {
23912 PyThreadState* __tstate = wxPyBeginAllowThreads();
23913 result = (int)((wxMouseEvent const *)arg1)->GetY();
23914 wxPyEndAllowThreads(__tstate);
23915 if (PyErr_Occurred()) SWIG_fail;
23916 }
23917 resultobj = SWIG_From_int(static_cast< int >(result));
23918 return resultobj;
23919 fail:
23920 return NULL;
23921 }
23922
23923
23924 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23925 PyObject *resultobj = 0;
23926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23927 int result;
23928 void *argp1 = 0 ;
23929 int res1 = 0 ;
23930 PyObject *swig_obj[1] ;
23931
23932 if (!args) SWIG_fail;
23933 swig_obj[0] = args;
23934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23935 if (!SWIG_IsOK(res1)) {
23936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23937 }
23938 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23939 {
23940 PyThreadState* __tstate = wxPyBeginAllowThreads();
23941 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23942 wxPyEndAllowThreads(__tstate);
23943 if (PyErr_Occurred()) SWIG_fail;
23944 }
23945 resultobj = SWIG_From_int(static_cast< int >(result));
23946 return resultobj;
23947 fail:
23948 return NULL;
23949 }
23950
23951
23952 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23953 PyObject *resultobj = 0;
23954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23955 int result;
23956 void *argp1 = 0 ;
23957 int res1 = 0 ;
23958 PyObject *swig_obj[1] ;
23959
23960 if (!args) SWIG_fail;
23961 swig_obj[0] = args;
23962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23963 if (!SWIG_IsOK(res1)) {
23964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23965 }
23966 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23967 {
23968 PyThreadState* __tstate = wxPyBeginAllowThreads();
23969 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23970 wxPyEndAllowThreads(__tstate);
23971 if (PyErr_Occurred()) SWIG_fail;
23972 }
23973 resultobj = SWIG_From_int(static_cast< int >(result));
23974 return resultobj;
23975 fail:
23976 return NULL;
23977 }
23978
23979
23980 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23981 PyObject *resultobj = 0;
23982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23983 int result;
23984 void *argp1 = 0 ;
23985 int res1 = 0 ;
23986 PyObject *swig_obj[1] ;
23987
23988 if (!args) SWIG_fail;
23989 swig_obj[0] = args;
23990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23991 if (!SWIG_IsOK(res1)) {
23992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23993 }
23994 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23995 {
23996 PyThreadState* __tstate = wxPyBeginAllowThreads();
23997 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23998 wxPyEndAllowThreads(__tstate);
23999 if (PyErr_Occurred()) SWIG_fail;
24000 }
24001 resultobj = SWIG_From_int(static_cast< int >(result));
24002 return resultobj;
24003 fail:
24004 return NULL;
24005 }
24006
24007
24008 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24009 PyObject *resultobj = 0;
24010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24011 bool result;
24012 void *argp1 = 0 ;
24013 int res1 = 0 ;
24014 PyObject *swig_obj[1] ;
24015
24016 if (!args) SWIG_fail;
24017 swig_obj[0] = args;
24018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24019 if (!SWIG_IsOK(res1)) {
24020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
24021 }
24022 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24023 {
24024 PyThreadState* __tstate = wxPyBeginAllowThreads();
24025 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
24026 wxPyEndAllowThreads(__tstate);
24027 if (PyErr_Occurred()) SWIG_fail;
24028 }
24029 {
24030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24031 }
24032 return resultobj;
24033 fail:
24034 return NULL;
24035 }
24036
24037
24038 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24039 PyObject *resultobj = 0;
24040 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24041 int arg2 ;
24042 void *argp1 = 0 ;
24043 int res1 = 0 ;
24044 int val2 ;
24045 int ecode2 = 0 ;
24046 PyObject *swig_obj[2] ;
24047
24048 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
24049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24050 if (!SWIG_IsOK(res1)) {
24051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24052 }
24053 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24054 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24055 if (!SWIG_IsOK(ecode2)) {
24056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
24057 }
24058 arg2 = static_cast< int >(val2);
24059 if (arg1) (arg1)->m_x = arg2;
24060
24061 resultobj = SWIG_Py_Void();
24062 return resultobj;
24063 fail:
24064 return NULL;
24065 }
24066
24067
24068 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24069 PyObject *resultobj = 0;
24070 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24071 int result;
24072 void *argp1 = 0 ;
24073 int res1 = 0 ;
24074 PyObject *swig_obj[1] ;
24075
24076 if (!args) SWIG_fail;
24077 swig_obj[0] = args;
24078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24079 if (!SWIG_IsOK(res1)) {
24080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24081 }
24082 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24083 result = (int) ((arg1)->m_x);
24084 resultobj = SWIG_From_int(static_cast< int >(result));
24085 return resultobj;
24086 fail:
24087 return NULL;
24088 }
24089
24090
24091 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24092 PyObject *resultobj = 0;
24093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24094 int arg2 ;
24095 void *argp1 = 0 ;
24096 int res1 = 0 ;
24097 int val2 ;
24098 int ecode2 = 0 ;
24099 PyObject *swig_obj[2] ;
24100
24101 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24103 if (!SWIG_IsOK(res1)) {
24104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24105 }
24106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24107 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24108 if (!SWIG_IsOK(ecode2)) {
24109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24110 }
24111 arg2 = static_cast< int >(val2);
24112 if (arg1) (arg1)->m_y = arg2;
24113
24114 resultobj = SWIG_Py_Void();
24115 return resultobj;
24116 fail:
24117 return NULL;
24118 }
24119
24120
24121 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24122 PyObject *resultobj = 0;
24123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24124 int result;
24125 void *argp1 = 0 ;
24126 int res1 = 0 ;
24127 PyObject *swig_obj[1] ;
24128
24129 if (!args) SWIG_fail;
24130 swig_obj[0] = args;
24131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24132 if (!SWIG_IsOK(res1)) {
24133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24134 }
24135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24136 result = (int) ((arg1)->m_y);
24137 resultobj = SWIG_From_int(static_cast< int >(result));
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24145 PyObject *resultobj = 0;
24146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24147 bool arg2 ;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 bool val2 ;
24151 int ecode2 = 0 ;
24152 PyObject *swig_obj[2] ;
24153
24154 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24156 if (!SWIG_IsOK(res1)) {
24157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24158 }
24159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24160 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24161 if (!SWIG_IsOK(ecode2)) {
24162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24163 }
24164 arg2 = static_cast< bool >(val2);
24165 if (arg1) (arg1)->m_leftDown = arg2;
24166
24167 resultobj = SWIG_Py_Void();
24168 return resultobj;
24169 fail:
24170 return NULL;
24171 }
24172
24173
24174 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24175 PyObject *resultobj = 0;
24176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24177 bool result;
24178 void *argp1 = 0 ;
24179 int res1 = 0 ;
24180 PyObject *swig_obj[1] ;
24181
24182 if (!args) SWIG_fail;
24183 swig_obj[0] = args;
24184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24185 if (!SWIG_IsOK(res1)) {
24186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24187 }
24188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24189 result = (bool) ((arg1)->m_leftDown);
24190 {
24191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24192 }
24193 return resultobj;
24194 fail:
24195 return NULL;
24196 }
24197
24198
24199 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24200 PyObject *resultobj = 0;
24201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24202 bool arg2 ;
24203 void *argp1 = 0 ;
24204 int res1 = 0 ;
24205 bool val2 ;
24206 int ecode2 = 0 ;
24207 PyObject *swig_obj[2] ;
24208
24209 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24211 if (!SWIG_IsOK(res1)) {
24212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24213 }
24214 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24215 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24216 if (!SWIG_IsOK(ecode2)) {
24217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24218 }
24219 arg2 = static_cast< bool >(val2);
24220 if (arg1) (arg1)->m_middleDown = arg2;
24221
24222 resultobj = SWIG_Py_Void();
24223 return resultobj;
24224 fail:
24225 return NULL;
24226 }
24227
24228
24229 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24230 PyObject *resultobj = 0;
24231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24232 bool result;
24233 void *argp1 = 0 ;
24234 int res1 = 0 ;
24235 PyObject *swig_obj[1] ;
24236
24237 if (!args) SWIG_fail;
24238 swig_obj[0] = args;
24239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24240 if (!SWIG_IsOK(res1)) {
24241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24242 }
24243 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24244 result = (bool) ((arg1)->m_middleDown);
24245 {
24246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24247 }
24248 return resultobj;
24249 fail:
24250 return NULL;
24251 }
24252
24253
24254 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24255 PyObject *resultobj = 0;
24256 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24257 bool arg2 ;
24258 void *argp1 = 0 ;
24259 int res1 = 0 ;
24260 bool val2 ;
24261 int ecode2 = 0 ;
24262 PyObject *swig_obj[2] ;
24263
24264 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24266 if (!SWIG_IsOK(res1)) {
24267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24268 }
24269 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24270 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24271 if (!SWIG_IsOK(ecode2)) {
24272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24273 }
24274 arg2 = static_cast< bool >(val2);
24275 if (arg1) (arg1)->m_rightDown = arg2;
24276
24277 resultobj = SWIG_Py_Void();
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24285 PyObject *resultobj = 0;
24286 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24287 bool result;
24288 void *argp1 = 0 ;
24289 int res1 = 0 ;
24290 PyObject *swig_obj[1] ;
24291
24292 if (!args) SWIG_fail;
24293 swig_obj[0] = args;
24294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24295 if (!SWIG_IsOK(res1)) {
24296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24297 }
24298 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24299 result = (bool) ((arg1)->m_rightDown);
24300 {
24301 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24302 }
24303 return resultobj;
24304 fail:
24305 return NULL;
24306 }
24307
24308
24309 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24310 PyObject *resultobj = 0;
24311 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24312 bool arg2 ;
24313 void *argp1 = 0 ;
24314 int res1 = 0 ;
24315 bool val2 ;
24316 int ecode2 = 0 ;
24317 PyObject *swig_obj[2] ;
24318
24319 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
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_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24323 }
24324 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24325 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24326 if (!SWIG_IsOK(ecode2)) {
24327 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24328 }
24329 arg2 = static_cast< bool >(val2);
24330 if (arg1) (arg1)->m_controlDown = arg2;
24331
24332 resultobj = SWIG_Py_Void();
24333 return resultobj;
24334 fail:
24335 return NULL;
24336 }
24337
24338
24339 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24340 PyObject *resultobj = 0;
24341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24342 bool result;
24343 void *argp1 = 0 ;
24344 int res1 = 0 ;
24345 PyObject *swig_obj[1] ;
24346
24347 if (!args) SWIG_fail;
24348 swig_obj[0] = args;
24349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24350 if (!SWIG_IsOK(res1)) {
24351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24352 }
24353 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24354 result = (bool) ((arg1)->m_controlDown);
24355 {
24356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24357 }
24358 return resultobj;
24359 fail:
24360 return NULL;
24361 }
24362
24363
24364 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24365 PyObject *resultobj = 0;
24366 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24367 bool arg2 ;
24368 void *argp1 = 0 ;
24369 int res1 = 0 ;
24370 bool val2 ;
24371 int ecode2 = 0 ;
24372 PyObject *swig_obj[2] ;
24373
24374 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24376 if (!SWIG_IsOK(res1)) {
24377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24378 }
24379 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24380 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24381 if (!SWIG_IsOK(ecode2)) {
24382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24383 }
24384 arg2 = static_cast< bool >(val2);
24385 if (arg1) (arg1)->m_shiftDown = arg2;
24386
24387 resultobj = SWIG_Py_Void();
24388 return resultobj;
24389 fail:
24390 return NULL;
24391 }
24392
24393
24394 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24395 PyObject *resultobj = 0;
24396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24397 bool result;
24398 void *argp1 = 0 ;
24399 int res1 = 0 ;
24400 PyObject *swig_obj[1] ;
24401
24402 if (!args) SWIG_fail;
24403 swig_obj[0] = args;
24404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24405 if (!SWIG_IsOK(res1)) {
24406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24407 }
24408 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24409 result = (bool) ((arg1)->m_shiftDown);
24410 {
24411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24412 }
24413 return resultobj;
24414 fail:
24415 return NULL;
24416 }
24417
24418
24419 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24420 PyObject *resultobj = 0;
24421 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24422 bool arg2 ;
24423 void *argp1 = 0 ;
24424 int res1 = 0 ;
24425 bool val2 ;
24426 int ecode2 = 0 ;
24427 PyObject *swig_obj[2] ;
24428
24429 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
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_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24433 }
24434 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24435 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24436 if (!SWIG_IsOK(ecode2)) {
24437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24438 }
24439 arg2 = static_cast< bool >(val2);
24440 if (arg1) (arg1)->m_altDown = arg2;
24441
24442 resultobj = SWIG_Py_Void();
24443 return resultobj;
24444 fail:
24445 return NULL;
24446 }
24447
24448
24449 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24450 PyObject *resultobj = 0;
24451 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24452 bool result;
24453 void *argp1 = 0 ;
24454 int res1 = 0 ;
24455 PyObject *swig_obj[1] ;
24456
24457 if (!args) SWIG_fail;
24458 swig_obj[0] = args;
24459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24460 if (!SWIG_IsOK(res1)) {
24461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24462 }
24463 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24464 result = (bool) ((arg1)->m_altDown);
24465 {
24466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24467 }
24468 return resultobj;
24469 fail:
24470 return NULL;
24471 }
24472
24473
24474 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24475 PyObject *resultobj = 0;
24476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24477 bool arg2 ;
24478 void *argp1 = 0 ;
24479 int res1 = 0 ;
24480 bool val2 ;
24481 int ecode2 = 0 ;
24482 PyObject *swig_obj[2] ;
24483
24484 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24486 if (!SWIG_IsOK(res1)) {
24487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24488 }
24489 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24490 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24491 if (!SWIG_IsOK(ecode2)) {
24492 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24493 }
24494 arg2 = static_cast< bool >(val2);
24495 if (arg1) (arg1)->m_metaDown = arg2;
24496
24497 resultobj = SWIG_Py_Void();
24498 return resultobj;
24499 fail:
24500 return NULL;
24501 }
24502
24503
24504 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24505 PyObject *resultobj = 0;
24506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24507 bool 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_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24517 }
24518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24519 result = (bool) ((arg1)->m_metaDown);
24520 {
24521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24522 }
24523 return resultobj;
24524 fail:
24525 return NULL;
24526 }
24527
24528
24529 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24530 PyObject *resultobj = 0;
24531 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24532 int arg2 ;
24533 void *argp1 = 0 ;
24534 int res1 = 0 ;
24535 int val2 ;
24536 int ecode2 = 0 ;
24537 PyObject *swig_obj[2] ;
24538
24539 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24541 if (!SWIG_IsOK(res1)) {
24542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24543 }
24544 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24545 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24546 if (!SWIG_IsOK(ecode2)) {
24547 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24548 }
24549 arg2 = static_cast< int >(val2);
24550 if (arg1) (arg1)->m_wheelRotation = arg2;
24551
24552 resultobj = SWIG_Py_Void();
24553 return resultobj;
24554 fail:
24555 return NULL;
24556 }
24557
24558
24559 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24560 PyObject *resultobj = 0;
24561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24562 int result;
24563 void *argp1 = 0 ;
24564 int res1 = 0 ;
24565 PyObject *swig_obj[1] ;
24566
24567 if (!args) SWIG_fail;
24568 swig_obj[0] = args;
24569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24570 if (!SWIG_IsOK(res1)) {
24571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24572 }
24573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24574 result = (int) ((arg1)->m_wheelRotation);
24575 resultobj = SWIG_From_int(static_cast< int >(result));
24576 return resultobj;
24577 fail:
24578 return NULL;
24579 }
24580
24581
24582 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24583 PyObject *resultobj = 0;
24584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24585 int arg2 ;
24586 void *argp1 = 0 ;
24587 int res1 = 0 ;
24588 int val2 ;
24589 int ecode2 = 0 ;
24590 PyObject *swig_obj[2] ;
24591
24592 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24594 if (!SWIG_IsOK(res1)) {
24595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24596 }
24597 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24598 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24599 if (!SWIG_IsOK(ecode2)) {
24600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24601 }
24602 arg2 = static_cast< int >(val2);
24603 if (arg1) (arg1)->m_wheelDelta = arg2;
24604
24605 resultobj = SWIG_Py_Void();
24606 return resultobj;
24607 fail:
24608 return NULL;
24609 }
24610
24611
24612 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24613 PyObject *resultobj = 0;
24614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24615 int result;
24616 void *argp1 = 0 ;
24617 int res1 = 0 ;
24618 PyObject *swig_obj[1] ;
24619
24620 if (!args) SWIG_fail;
24621 swig_obj[0] = args;
24622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24623 if (!SWIG_IsOK(res1)) {
24624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24625 }
24626 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24627 result = (int) ((arg1)->m_wheelDelta);
24628 resultobj = SWIG_From_int(static_cast< int >(result));
24629 return resultobj;
24630 fail:
24631 return NULL;
24632 }
24633
24634
24635 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24636 PyObject *resultobj = 0;
24637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24638 int arg2 ;
24639 void *argp1 = 0 ;
24640 int res1 = 0 ;
24641 int val2 ;
24642 int ecode2 = 0 ;
24643 PyObject *swig_obj[2] ;
24644
24645 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24647 if (!SWIG_IsOK(res1)) {
24648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24649 }
24650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24651 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24652 if (!SWIG_IsOK(ecode2)) {
24653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24654 }
24655 arg2 = static_cast< int >(val2);
24656 if (arg1) (arg1)->m_linesPerAction = arg2;
24657
24658 resultobj = SWIG_Py_Void();
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24666 PyObject *resultobj = 0;
24667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24668 int result;
24669 void *argp1 = 0 ;
24670 int res1 = 0 ;
24671 PyObject *swig_obj[1] ;
24672
24673 if (!args) SWIG_fail;
24674 swig_obj[0] = args;
24675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24676 if (!SWIG_IsOK(res1)) {
24677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24678 }
24679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24680 result = (int) ((arg1)->m_linesPerAction);
24681 resultobj = SWIG_From_int(static_cast< int >(result));
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24689 PyObject *obj;
24690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24691 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24692 return SWIG_Py_Void();
24693 }
24694
24695 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24696 return SWIG_Python_InitShadowInstance(args);
24697 }
24698
24699 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24700 PyObject *resultobj = 0;
24701 int arg1 = (int) 0 ;
24702 int arg2 = (int) 0 ;
24703 wxSetCursorEvent *result = 0 ;
24704 int val1 ;
24705 int ecode1 = 0 ;
24706 int val2 ;
24707 int ecode2 = 0 ;
24708 PyObject * obj0 = 0 ;
24709 PyObject * obj1 = 0 ;
24710 char * kwnames[] = {
24711 (char *) "x",(char *) "y", NULL
24712 };
24713
24714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24715 if (obj0) {
24716 ecode1 = SWIG_AsVal_int(obj0, &val1);
24717 if (!SWIG_IsOK(ecode1)) {
24718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24719 }
24720 arg1 = static_cast< int >(val1);
24721 }
24722 if (obj1) {
24723 ecode2 = SWIG_AsVal_int(obj1, &val2);
24724 if (!SWIG_IsOK(ecode2)) {
24725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24726 }
24727 arg2 = static_cast< int >(val2);
24728 }
24729 {
24730 PyThreadState* __tstate = wxPyBeginAllowThreads();
24731 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24732 wxPyEndAllowThreads(__tstate);
24733 if (PyErr_Occurred()) SWIG_fail;
24734 }
24735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24736 return resultobj;
24737 fail:
24738 return NULL;
24739 }
24740
24741
24742 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24743 PyObject *resultobj = 0;
24744 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24745 int result;
24746 void *argp1 = 0 ;
24747 int res1 = 0 ;
24748 PyObject *swig_obj[1] ;
24749
24750 if (!args) SWIG_fail;
24751 swig_obj[0] = args;
24752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24753 if (!SWIG_IsOK(res1)) {
24754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24755 }
24756 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24757 {
24758 PyThreadState* __tstate = wxPyBeginAllowThreads();
24759 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 resultobj = SWIG_From_int(static_cast< int >(result));
24764 return resultobj;
24765 fail:
24766 return NULL;
24767 }
24768
24769
24770 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24771 PyObject *resultobj = 0;
24772 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24773 int result;
24774 void *argp1 = 0 ;
24775 int res1 = 0 ;
24776 PyObject *swig_obj[1] ;
24777
24778 if (!args) SWIG_fail;
24779 swig_obj[0] = args;
24780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24781 if (!SWIG_IsOK(res1)) {
24782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24783 }
24784 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24785 {
24786 PyThreadState* __tstate = wxPyBeginAllowThreads();
24787 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24788 wxPyEndAllowThreads(__tstate);
24789 if (PyErr_Occurred()) SWIG_fail;
24790 }
24791 resultobj = SWIG_From_int(static_cast< int >(result));
24792 return resultobj;
24793 fail:
24794 return NULL;
24795 }
24796
24797
24798 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24799 PyObject *resultobj = 0;
24800 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24801 wxCursor *arg2 = 0 ;
24802 void *argp1 = 0 ;
24803 int res1 = 0 ;
24804 void *argp2 = 0 ;
24805 int res2 = 0 ;
24806 PyObject * obj0 = 0 ;
24807 PyObject * obj1 = 0 ;
24808 char * kwnames[] = {
24809 (char *) "self",(char *) "cursor", NULL
24810 };
24811
24812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24814 if (!SWIG_IsOK(res1)) {
24815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24816 }
24817 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24818 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24819 if (!SWIG_IsOK(res2)) {
24820 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24821 }
24822 if (!argp2) {
24823 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24824 }
24825 arg2 = reinterpret_cast< wxCursor * >(argp2);
24826 {
24827 PyThreadState* __tstate = wxPyBeginAllowThreads();
24828 (arg1)->SetCursor((wxCursor const &)*arg2);
24829 wxPyEndAllowThreads(__tstate);
24830 if (PyErr_Occurred()) SWIG_fail;
24831 }
24832 resultobj = SWIG_Py_Void();
24833 return resultobj;
24834 fail:
24835 return NULL;
24836 }
24837
24838
24839 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24840 PyObject *resultobj = 0;
24841 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24842 wxCursor *result = 0 ;
24843 void *argp1 = 0 ;
24844 int res1 = 0 ;
24845 PyObject *swig_obj[1] ;
24846
24847 if (!args) SWIG_fail;
24848 swig_obj[0] = args;
24849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24850 if (!SWIG_IsOK(res1)) {
24851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24852 }
24853 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24854 {
24855 PyThreadState* __tstate = wxPyBeginAllowThreads();
24856 {
24857 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24858 result = (wxCursor *) &_result_ref;
24859 }
24860 wxPyEndAllowThreads(__tstate);
24861 if (PyErr_Occurred()) SWIG_fail;
24862 }
24863 {
24864 wxCursor* resultptr = new wxCursor(*result);
24865 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24866 }
24867 return resultobj;
24868 fail:
24869 return NULL;
24870 }
24871
24872
24873 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24874 PyObject *resultobj = 0;
24875 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24876 bool result;
24877 void *argp1 = 0 ;
24878 int res1 = 0 ;
24879 PyObject *swig_obj[1] ;
24880
24881 if (!args) SWIG_fail;
24882 swig_obj[0] = args;
24883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24884 if (!SWIG_IsOK(res1)) {
24885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24886 }
24887 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24888 {
24889 PyThreadState* __tstate = wxPyBeginAllowThreads();
24890 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 {
24895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24896 }
24897 return resultobj;
24898 fail:
24899 return NULL;
24900 }
24901
24902
24903 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24904 PyObject *obj;
24905 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24906 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24907 return SWIG_Py_Void();
24908 }
24909
24910 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24911 return SWIG_Python_InitShadowInstance(args);
24912 }
24913
24914 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24915 PyObject *resultobj = 0;
24916 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24917 wxKeyEvent *result = 0 ;
24918 int val1 ;
24919 int ecode1 = 0 ;
24920 PyObject * obj0 = 0 ;
24921 char * kwnames[] = {
24922 (char *) "eventType", NULL
24923 };
24924
24925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24926 if (obj0) {
24927 ecode1 = SWIG_AsVal_int(obj0, &val1);
24928 if (!SWIG_IsOK(ecode1)) {
24929 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24930 }
24931 arg1 = static_cast< wxEventType >(val1);
24932 }
24933 {
24934 PyThreadState* __tstate = wxPyBeginAllowThreads();
24935 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24936 wxPyEndAllowThreads(__tstate);
24937 if (PyErr_Occurred()) SWIG_fail;
24938 }
24939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24940 return resultobj;
24941 fail:
24942 return NULL;
24943 }
24944
24945
24946 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24947 PyObject *resultobj = 0;
24948 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24949 int 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_wxKeyEvent, 0 | 0 );
24957 if (!SWIG_IsOK(res1)) {
24958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24959 }
24960 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24961 {
24962 PyThreadState* __tstate = wxPyBeginAllowThreads();
24963 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24964 wxPyEndAllowThreads(__tstate);
24965 if (PyErr_Occurred()) SWIG_fail;
24966 }
24967 resultobj = SWIG_From_int(static_cast< int >(result));
24968 return resultobj;
24969 fail:
24970 return NULL;
24971 }
24972
24973
24974 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24975 PyObject *resultobj = 0;
24976 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24977 bool result;
24978 void *argp1 = 0 ;
24979 int res1 = 0 ;
24980 PyObject *swig_obj[1] ;
24981
24982 if (!args) SWIG_fail;
24983 swig_obj[0] = args;
24984 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24985 if (!SWIG_IsOK(res1)) {
24986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24987 }
24988 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24989 {
24990 PyThreadState* __tstate = wxPyBeginAllowThreads();
24991 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24992 wxPyEndAllowThreads(__tstate);
24993 if (PyErr_Occurred()) SWIG_fail;
24994 }
24995 {
24996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24997 }
24998 return resultobj;
24999 fail:
25000 return NULL;
25001 }
25002
25003
25004 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25005 PyObject *resultobj = 0;
25006 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25007 bool result;
25008 void *argp1 = 0 ;
25009 int res1 = 0 ;
25010 PyObject *swig_obj[1] ;
25011
25012 if (!args) SWIG_fail;
25013 swig_obj[0] = args;
25014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25015 if (!SWIG_IsOK(res1)) {
25016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25017 }
25018 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25019 {
25020 PyThreadState* __tstate = wxPyBeginAllowThreads();
25021 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
25022 wxPyEndAllowThreads(__tstate);
25023 if (PyErr_Occurred()) SWIG_fail;
25024 }
25025 {
25026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25027 }
25028 return resultobj;
25029 fail:
25030 return NULL;
25031 }
25032
25033
25034 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25035 PyObject *resultobj = 0;
25036 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25037 bool result;
25038 void *argp1 = 0 ;
25039 int res1 = 0 ;
25040 PyObject *swig_obj[1] ;
25041
25042 if (!args) SWIG_fail;
25043 swig_obj[0] = args;
25044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25045 if (!SWIG_IsOK(res1)) {
25046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25047 }
25048 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25049 {
25050 PyThreadState* __tstate = wxPyBeginAllowThreads();
25051 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
25052 wxPyEndAllowThreads(__tstate);
25053 if (PyErr_Occurred()) SWIG_fail;
25054 }
25055 {
25056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25057 }
25058 return resultobj;
25059 fail:
25060 return NULL;
25061 }
25062
25063
25064 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25065 PyObject *resultobj = 0;
25066 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25067 bool result;
25068 void *argp1 = 0 ;
25069 int res1 = 0 ;
25070 PyObject *swig_obj[1] ;
25071
25072 if (!args) SWIG_fail;
25073 swig_obj[0] = args;
25074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25075 if (!SWIG_IsOK(res1)) {
25076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25077 }
25078 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25079 {
25080 PyThreadState* __tstate = wxPyBeginAllowThreads();
25081 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25082 wxPyEndAllowThreads(__tstate);
25083 if (PyErr_Occurred()) SWIG_fail;
25084 }
25085 {
25086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25087 }
25088 return resultobj;
25089 fail:
25090 return NULL;
25091 }
25092
25093
25094 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25095 PyObject *resultobj = 0;
25096 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25097 bool result;
25098 void *argp1 = 0 ;
25099 int res1 = 0 ;
25100 PyObject *swig_obj[1] ;
25101
25102 if (!args) SWIG_fail;
25103 swig_obj[0] = args;
25104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25105 if (!SWIG_IsOK(res1)) {
25106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25107 }
25108 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25109 {
25110 PyThreadState* __tstate = wxPyBeginAllowThreads();
25111 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25112 wxPyEndAllowThreads(__tstate);
25113 if (PyErr_Occurred()) SWIG_fail;
25114 }
25115 {
25116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25117 }
25118 return resultobj;
25119 fail:
25120 return NULL;
25121 }
25122
25123
25124 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25125 PyObject *resultobj = 0;
25126 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25127 bool result;
25128 void *argp1 = 0 ;
25129 int res1 = 0 ;
25130 PyObject *swig_obj[1] ;
25131
25132 if (!args) SWIG_fail;
25133 swig_obj[0] = args;
25134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25135 if (!SWIG_IsOK(res1)) {
25136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25137 }
25138 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25139 {
25140 PyThreadState* __tstate = wxPyBeginAllowThreads();
25141 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25142 wxPyEndAllowThreads(__tstate);
25143 if (PyErr_Occurred()) SWIG_fail;
25144 }
25145 {
25146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25147 }
25148 return resultobj;
25149 fail:
25150 return NULL;
25151 }
25152
25153
25154 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25155 PyObject *resultobj = 0;
25156 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25157 int result;
25158 void *argp1 = 0 ;
25159 int res1 = 0 ;
25160 PyObject *swig_obj[1] ;
25161
25162 if (!args) SWIG_fail;
25163 swig_obj[0] = args;
25164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25165 if (!SWIG_IsOK(res1)) {
25166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25167 }
25168 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25169 {
25170 PyThreadState* __tstate = wxPyBeginAllowThreads();
25171 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25172 wxPyEndAllowThreads(__tstate);
25173 if (PyErr_Occurred()) SWIG_fail;
25174 }
25175 resultobj = SWIG_From_int(static_cast< int >(result));
25176 return resultobj;
25177 fail:
25178 return NULL;
25179 }
25180
25181
25182 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25183 PyObject *resultobj = 0;
25184 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25185 int result;
25186 void *argp1 = 0 ;
25187 int res1 = 0 ;
25188 PyObject *swig_obj[1] ;
25189
25190 if (!args) SWIG_fail;
25191 swig_obj[0] = args;
25192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25193 if (!SWIG_IsOK(res1)) {
25194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25195 }
25196 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_From_int(static_cast< int >(result));
25204 return resultobj;
25205 fail:
25206 return NULL;
25207 }
25208
25209
25210 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25211 PyObject *resultobj = 0;
25212 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25213 int arg2 ;
25214 void *argp1 = 0 ;
25215 int res1 = 0 ;
25216 int val2 ;
25217 int ecode2 = 0 ;
25218 PyObject * obj0 = 0 ;
25219 PyObject * obj1 = 0 ;
25220 char * kwnames[] = {
25221 (char *) "self",(char *) "uniChar", NULL
25222 };
25223
25224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25226 if (!SWIG_IsOK(res1)) {
25227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25228 }
25229 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25230 ecode2 = SWIG_AsVal_int(obj1, &val2);
25231 if (!SWIG_IsOK(ecode2)) {
25232 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25233 }
25234 arg2 = static_cast< int >(val2);
25235 {
25236 PyThreadState* __tstate = wxPyBeginAllowThreads();
25237 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25238 wxPyEndAllowThreads(__tstate);
25239 if (PyErr_Occurred()) SWIG_fail;
25240 }
25241 resultobj = SWIG_Py_Void();
25242 return resultobj;
25243 fail:
25244 return NULL;
25245 }
25246
25247
25248 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25249 PyObject *resultobj = 0;
25250 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25251 unsigned int result;
25252 void *argp1 = 0 ;
25253 int res1 = 0 ;
25254 PyObject *swig_obj[1] ;
25255
25256 if (!args) SWIG_fail;
25257 swig_obj[0] = args;
25258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25259 if (!SWIG_IsOK(res1)) {
25260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25261 }
25262 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25263 {
25264 PyThreadState* __tstate = wxPyBeginAllowThreads();
25265 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25266 wxPyEndAllowThreads(__tstate);
25267 if (PyErr_Occurred()) SWIG_fail;
25268 }
25269 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25270 return resultobj;
25271 fail:
25272 return NULL;
25273 }
25274
25275
25276 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25277 PyObject *resultobj = 0;
25278 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25279 unsigned int result;
25280 void *argp1 = 0 ;
25281 int res1 = 0 ;
25282 PyObject *swig_obj[1] ;
25283
25284 if (!args) SWIG_fail;
25285 swig_obj[0] = args;
25286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25287 if (!SWIG_IsOK(res1)) {
25288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25289 }
25290 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25291 {
25292 PyThreadState* __tstate = wxPyBeginAllowThreads();
25293 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25294 wxPyEndAllowThreads(__tstate);
25295 if (PyErr_Occurred()) SWIG_fail;
25296 }
25297 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25298 return resultobj;
25299 fail:
25300 return NULL;
25301 }
25302
25303
25304 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25305 PyObject *resultobj = 0;
25306 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25307 wxPoint result;
25308 void *argp1 = 0 ;
25309 int res1 = 0 ;
25310 PyObject *swig_obj[1] ;
25311
25312 if (!args) SWIG_fail;
25313 swig_obj[0] = args;
25314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25315 if (!SWIG_IsOK(res1)) {
25316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25317 }
25318 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25319 {
25320 PyThreadState* __tstate = wxPyBeginAllowThreads();
25321 result = (arg1)->GetPosition();
25322 wxPyEndAllowThreads(__tstate);
25323 if (PyErr_Occurred()) SWIG_fail;
25324 }
25325 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25326 return resultobj;
25327 fail:
25328 return NULL;
25329 }
25330
25331
25332 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25333 PyObject *resultobj = 0;
25334 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25335 long *arg2 = (long *) 0 ;
25336 long *arg3 = (long *) 0 ;
25337 void *argp1 = 0 ;
25338 int res1 = 0 ;
25339 long temp2 ;
25340 int res2 = SWIG_TMPOBJ ;
25341 long temp3 ;
25342 int res3 = SWIG_TMPOBJ ;
25343 PyObject *swig_obj[1] ;
25344
25345 arg2 = &temp2;
25346 arg3 = &temp3;
25347 if (!args) SWIG_fail;
25348 swig_obj[0] = args;
25349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25350 if (!SWIG_IsOK(res1)) {
25351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25352 }
25353 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25354 {
25355 PyThreadState* __tstate = wxPyBeginAllowThreads();
25356 (arg1)->GetPosition(arg2,arg3);
25357 wxPyEndAllowThreads(__tstate);
25358 if (PyErr_Occurred()) SWIG_fail;
25359 }
25360 resultobj = SWIG_Py_Void();
25361 if (SWIG_IsTmpObj(res2)) {
25362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25363 } else {
25364 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25366 }
25367 if (SWIG_IsTmpObj(res3)) {
25368 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25369 } else {
25370 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25371 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25372 }
25373 return resultobj;
25374 fail:
25375 return NULL;
25376 }
25377
25378
25379 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25380 PyObject *resultobj = 0;
25381 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25382 int result;
25383 void *argp1 = 0 ;
25384 int res1 = 0 ;
25385 PyObject *swig_obj[1] ;
25386
25387 if (!args) SWIG_fail;
25388 swig_obj[0] = args;
25389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25390 if (!SWIG_IsOK(res1)) {
25391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25392 }
25393 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25394 {
25395 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 result = (int)((wxKeyEvent const *)arg1)->GetX();
25397 wxPyEndAllowThreads(__tstate);
25398 if (PyErr_Occurred()) SWIG_fail;
25399 }
25400 resultobj = SWIG_From_int(static_cast< int >(result));
25401 return resultobj;
25402 fail:
25403 return NULL;
25404 }
25405
25406
25407 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25408 PyObject *resultobj = 0;
25409 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25410 int result;
25411 void *argp1 = 0 ;
25412 int res1 = 0 ;
25413 PyObject *swig_obj[1] ;
25414
25415 if (!args) SWIG_fail;
25416 swig_obj[0] = args;
25417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25418 if (!SWIG_IsOK(res1)) {
25419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25420 }
25421 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 result = (int)((wxKeyEvent const *)arg1)->GetY();
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_From_int(static_cast< int >(result));
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25436 PyObject *resultobj = 0;
25437 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25438 int arg2 ;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 int val2 ;
25442 int ecode2 = 0 ;
25443 PyObject *swig_obj[2] ;
25444
25445 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25447 if (!SWIG_IsOK(res1)) {
25448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25449 }
25450 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25451 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25452 if (!SWIG_IsOK(ecode2)) {
25453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25454 }
25455 arg2 = static_cast< int >(val2);
25456 if (arg1) (arg1)->m_x = arg2;
25457
25458 resultobj = SWIG_Py_Void();
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *resultobj = 0;
25467 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25468 int result;
25469 void *argp1 = 0 ;
25470 int res1 = 0 ;
25471 PyObject *swig_obj[1] ;
25472
25473 if (!args) SWIG_fail;
25474 swig_obj[0] = args;
25475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25476 if (!SWIG_IsOK(res1)) {
25477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25478 }
25479 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25480 result = (int) ((arg1)->m_x);
25481 resultobj = SWIG_From_int(static_cast< int >(result));
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25489 PyObject *resultobj = 0;
25490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25491 int arg2 ;
25492 void *argp1 = 0 ;
25493 int res1 = 0 ;
25494 int val2 ;
25495 int ecode2 = 0 ;
25496 PyObject *swig_obj[2] ;
25497
25498 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25500 if (!SWIG_IsOK(res1)) {
25501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25502 }
25503 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25504 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25505 if (!SWIG_IsOK(ecode2)) {
25506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25507 }
25508 arg2 = static_cast< int >(val2);
25509 if (arg1) (arg1)->m_y = arg2;
25510
25511 resultobj = SWIG_Py_Void();
25512 return resultobj;
25513 fail:
25514 return NULL;
25515 }
25516
25517
25518 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25519 PyObject *resultobj = 0;
25520 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25521 int result;
25522 void *argp1 = 0 ;
25523 int res1 = 0 ;
25524 PyObject *swig_obj[1] ;
25525
25526 if (!args) SWIG_fail;
25527 swig_obj[0] = args;
25528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25529 if (!SWIG_IsOK(res1)) {
25530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25531 }
25532 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25533 result = (int) ((arg1)->m_y);
25534 resultobj = SWIG_From_int(static_cast< int >(result));
25535 return resultobj;
25536 fail:
25537 return NULL;
25538 }
25539
25540
25541 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25542 PyObject *resultobj = 0;
25543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25544 long arg2 ;
25545 void *argp1 = 0 ;
25546 int res1 = 0 ;
25547 long val2 ;
25548 int ecode2 = 0 ;
25549 PyObject *swig_obj[2] ;
25550
25551 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25553 if (!SWIG_IsOK(res1)) {
25554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25555 }
25556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25557 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25558 if (!SWIG_IsOK(ecode2)) {
25559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25560 }
25561 arg2 = static_cast< long >(val2);
25562 if (arg1) (arg1)->m_keyCode = arg2;
25563
25564 resultobj = SWIG_Py_Void();
25565 return resultobj;
25566 fail:
25567 return NULL;
25568 }
25569
25570
25571 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25572 PyObject *resultobj = 0;
25573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25574 long result;
25575 void *argp1 = 0 ;
25576 int res1 = 0 ;
25577 PyObject *swig_obj[1] ;
25578
25579 if (!args) SWIG_fail;
25580 swig_obj[0] = args;
25581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25582 if (!SWIG_IsOK(res1)) {
25583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25584 }
25585 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25586 result = (long) ((arg1)->m_keyCode);
25587 resultobj = SWIG_From_long(static_cast< long >(result));
25588 return resultobj;
25589 fail:
25590 return NULL;
25591 }
25592
25593
25594 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25595 PyObject *resultobj = 0;
25596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25597 bool arg2 ;
25598 void *argp1 = 0 ;
25599 int res1 = 0 ;
25600 bool val2 ;
25601 int ecode2 = 0 ;
25602 PyObject *swig_obj[2] ;
25603
25604 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25606 if (!SWIG_IsOK(res1)) {
25607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25608 }
25609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25610 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25611 if (!SWIG_IsOK(ecode2)) {
25612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25613 }
25614 arg2 = static_cast< bool >(val2);
25615 if (arg1) (arg1)->m_controlDown = arg2;
25616
25617 resultobj = SWIG_Py_Void();
25618 return resultobj;
25619 fail:
25620 return NULL;
25621 }
25622
25623
25624 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25625 PyObject *resultobj = 0;
25626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25627 bool result;
25628 void *argp1 = 0 ;
25629 int res1 = 0 ;
25630 PyObject *swig_obj[1] ;
25631
25632 if (!args) SWIG_fail;
25633 swig_obj[0] = args;
25634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25635 if (!SWIG_IsOK(res1)) {
25636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25637 }
25638 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25639 result = (bool) ((arg1)->m_controlDown);
25640 {
25641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25642 }
25643 return resultobj;
25644 fail:
25645 return NULL;
25646 }
25647
25648
25649 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25650 PyObject *resultobj = 0;
25651 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25652 bool arg2 ;
25653 void *argp1 = 0 ;
25654 int res1 = 0 ;
25655 bool val2 ;
25656 int ecode2 = 0 ;
25657 PyObject *swig_obj[2] ;
25658
25659 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25661 if (!SWIG_IsOK(res1)) {
25662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25663 }
25664 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25665 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25666 if (!SWIG_IsOK(ecode2)) {
25667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25668 }
25669 arg2 = static_cast< bool >(val2);
25670 if (arg1) (arg1)->m_shiftDown = arg2;
25671
25672 resultobj = SWIG_Py_Void();
25673 return resultobj;
25674 fail:
25675 return NULL;
25676 }
25677
25678
25679 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25680 PyObject *resultobj = 0;
25681 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25682 bool result;
25683 void *argp1 = 0 ;
25684 int res1 = 0 ;
25685 PyObject *swig_obj[1] ;
25686
25687 if (!args) SWIG_fail;
25688 swig_obj[0] = args;
25689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25690 if (!SWIG_IsOK(res1)) {
25691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25692 }
25693 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25694 result = (bool) ((arg1)->m_shiftDown);
25695 {
25696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25697 }
25698 return resultobj;
25699 fail:
25700 return NULL;
25701 }
25702
25703
25704 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25705 PyObject *resultobj = 0;
25706 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25707 bool arg2 ;
25708 void *argp1 = 0 ;
25709 int res1 = 0 ;
25710 bool val2 ;
25711 int ecode2 = 0 ;
25712 PyObject *swig_obj[2] ;
25713
25714 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25718 }
25719 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25720 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25721 if (!SWIG_IsOK(ecode2)) {
25722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25723 }
25724 arg2 = static_cast< bool >(val2);
25725 if (arg1) (arg1)->m_altDown = arg2;
25726
25727 resultobj = SWIG_Py_Void();
25728 return resultobj;
25729 fail:
25730 return NULL;
25731 }
25732
25733
25734 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25735 PyObject *resultobj = 0;
25736 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25737 bool 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_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25747 }
25748 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25749 result = (bool) ((arg1)->m_altDown);
25750 {
25751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25752 }
25753 return resultobj;
25754 fail:
25755 return NULL;
25756 }
25757
25758
25759 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25760 PyObject *resultobj = 0;
25761 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25762 bool arg2 ;
25763 void *argp1 = 0 ;
25764 int res1 = 0 ;
25765 bool val2 ;
25766 int ecode2 = 0 ;
25767 PyObject *swig_obj[2] ;
25768
25769 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25771 if (!SWIG_IsOK(res1)) {
25772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25773 }
25774 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25775 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25776 if (!SWIG_IsOK(ecode2)) {
25777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25778 }
25779 arg2 = static_cast< bool >(val2);
25780 if (arg1) (arg1)->m_metaDown = arg2;
25781
25782 resultobj = SWIG_Py_Void();
25783 return resultobj;
25784 fail:
25785 return NULL;
25786 }
25787
25788
25789 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25790 PyObject *resultobj = 0;
25791 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25792 bool result;
25793 void *argp1 = 0 ;
25794 int res1 = 0 ;
25795 PyObject *swig_obj[1] ;
25796
25797 if (!args) SWIG_fail;
25798 swig_obj[0] = args;
25799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25800 if (!SWIG_IsOK(res1)) {
25801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25802 }
25803 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25804 result = (bool) ((arg1)->m_metaDown);
25805 {
25806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25807 }
25808 return resultobj;
25809 fail:
25810 return NULL;
25811 }
25812
25813
25814 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25815 PyObject *resultobj = 0;
25816 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25817 bool arg2 ;
25818 void *argp1 = 0 ;
25819 int res1 = 0 ;
25820 bool val2 ;
25821 int ecode2 = 0 ;
25822 PyObject *swig_obj[2] ;
25823
25824 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25826 if (!SWIG_IsOK(res1)) {
25827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25828 }
25829 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25830 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25831 if (!SWIG_IsOK(ecode2)) {
25832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25833 }
25834 arg2 = static_cast< bool >(val2);
25835 if (arg1) (arg1)->m_scanCode = arg2;
25836
25837 resultobj = SWIG_Py_Void();
25838 return resultobj;
25839 fail:
25840 return NULL;
25841 }
25842
25843
25844 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25845 PyObject *resultobj = 0;
25846 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25847 bool result;
25848 void *argp1 = 0 ;
25849 int res1 = 0 ;
25850 PyObject *swig_obj[1] ;
25851
25852 if (!args) SWIG_fail;
25853 swig_obj[0] = args;
25854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25855 if (!SWIG_IsOK(res1)) {
25856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25857 }
25858 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25859 result = (bool) ((arg1)->m_scanCode);
25860 {
25861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25862 }
25863 return resultobj;
25864 fail:
25865 return NULL;
25866 }
25867
25868
25869 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25870 PyObject *resultobj = 0;
25871 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25872 unsigned int arg2 ;
25873 void *argp1 = 0 ;
25874 int res1 = 0 ;
25875 unsigned int val2 ;
25876 int ecode2 = 0 ;
25877 PyObject *swig_obj[2] ;
25878
25879 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25881 if (!SWIG_IsOK(res1)) {
25882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25883 }
25884 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25885 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25886 if (!SWIG_IsOK(ecode2)) {
25887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25888 }
25889 arg2 = static_cast< unsigned int >(val2);
25890 if (arg1) (arg1)->m_rawCode = arg2;
25891
25892 resultobj = SWIG_Py_Void();
25893 return resultobj;
25894 fail:
25895 return NULL;
25896 }
25897
25898
25899 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25900 PyObject *resultobj = 0;
25901 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25902 unsigned int result;
25903 void *argp1 = 0 ;
25904 int res1 = 0 ;
25905 PyObject *swig_obj[1] ;
25906
25907 if (!args) SWIG_fail;
25908 swig_obj[0] = args;
25909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25910 if (!SWIG_IsOK(res1)) {
25911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25912 }
25913 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25914 result = (unsigned int) ((arg1)->m_rawCode);
25915 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25916 return resultobj;
25917 fail:
25918 return NULL;
25919 }
25920
25921
25922 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25923 PyObject *resultobj = 0;
25924 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25925 unsigned int arg2 ;
25926 void *argp1 = 0 ;
25927 int res1 = 0 ;
25928 unsigned int val2 ;
25929 int ecode2 = 0 ;
25930 PyObject *swig_obj[2] ;
25931
25932 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25934 if (!SWIG_IsOK(res1)) {
25935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25936 }
25937 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25938 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25939 if (!SWIG_IsOK(ecode2)) {
25940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25941 }
25942 arg2 = static_cast< unsigned int >(val2);
25943 if (arg1) (arg1)->m_rawFlags = arg2;
25944
25945 resultobj = SWIG_Py_Void();
25946 return resultobj;
25947 fail:
25948 return NULL;
25949 }
25950
25951
25952 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25953 PyObject *resultobj = 0;
25954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25955 unsigned int result;
25956 void *argp1 = 0 ;
25957 int res1 = 0 ;
25958 PyObject *swig_obj[1] ;
25959
25960 if (!args) SWIG_fail;
25961 swig_obj[0] = args;
25962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25963 if (!SWIG_IsOK(res1)) {
25964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25965 }
25966 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25967 result = (unsigned int) ((arg1)->m_rawFlags);
25968 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25969 return resultobj;
25970 fail:
25971 return NULL;
25972 }
25973
25974
25975 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25976 PyObject *obj;
25977 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25978 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25979 return SWIG_Py_Void();
25980 }
25981
25982 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25983 return SWIG_Python_InitShadowInstance(args);
25984 }
25985
25986 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25987 PyObject *resultobj = 0;
25988 wxSize const &arg1_defvalue = wxDefaultSize ;
25989 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25990 int arg2 = (int) 0 ;
25991 wxSizeEvent *result = 0 ;
25992 wxSize temp1 ;
25993 int val2 ;
25994 int ecode2 = 0 ;
25995 PyObject * obj0 = 0 ;
25996 PyObject * obj1 = 0 ;
25997 char * kwnames[] = {
25998 (char *) "sz",(char *) "winid", NULL
25999 };
26000
26001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26002 if (obj0) {
26003 {
26004 arg1 = &temp1;
26005 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
26006 }
26007 }
26008 if (obj1) {
26009 ecode2 = SWIG_AsVal_int(obj1, &val2);
26010 if (!SWIG_IsOK(ecode2)) {
26011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
26012 }
26013 arg2 = static_cast< int >(val2);
26014 }
26015 {
26016 PyThreadState* __tstate = wxPyBeginAllowThreads();
26017 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
26018 wxPyEndAllowThreads(__tstate);
26019 if (PyErr_Occurred()) SWIG_fail;
26020 }
26021 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
26022 return resultobj;
26023 fail:
26024 return NULL;
26025 }
26026
26027
26028 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26029 PyObject *resultobj = 0;
26030 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26031 wxSize result;
26032 void *argp1 = 0 ;
26033 int res1 = 0 ;
26034 PyObject *swig_obj[1] ;
26035
26036 if (!args) SWIG_fail;
26037 swig_obj[0] = args;
26038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26039 if (!SWIG_IsOK(res1)) {
26040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26041 }
26042 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 result = ((wxSizeEvent const *)arg1)->GetSize();
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
26050 return resultobj;
26051 fail:
26052 return NULL;
26053 }
26054
26055
26056 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26057 PyObject *resultobj = 0;
26058 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26059 wxRect result;
26060 void *argp1 = 0 ;
26061 int res1 = 0 ;
26062 PyObject *swig_obj[1] ;
26063
26064 if (!args) SWIG_fail;
26065 swig_obj[0] = args;
26066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26067 if (!SWIG_IsOK(res1)) {
26068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26069 }
26070 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26071 {
26072 PyThreadState* __tstate = wxPyBeginAllowThreads();
26073 result = ((wxSizeEvent const *)arg1)->GetRect();
26074 wxPyEndAllowThreads(__tstate);
26075 if (PyErr_Occurred()) SWIG_fail;
26076 }
26077 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26078 return resultobj;
26079 fail:
26080 return NULL;
26081 }
26082
26083
26084 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26085 PyObject *resultobj = 0;
26086 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26087 wxRect arg2 ;
26088 void *argp1 = 0 ;
26089 int res1 = 0 ;
26090 void *argp2 ;
26091 int res2 = 0 ;
26092 PyObject * obj0 = 0 ;
26093 PyObject * obj1 = 0 ;
26094 char * kwnames[] = {
26095 (char *) "self",(char *) "rect", NULL
26096 };
26097
26098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26100 if (!SWIG_IsOK(res1)) {
26101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26102 }
26103 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26104 {
26105 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26106 if (!SWIG_IsOK(res2)) {
26107 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26108 }
26109 if (!argp2) {
26110 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26111 } else {
26112 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26113 arg2 = *temp;
26114 if (SWIG_IsNewObj(res2)) delete temp;
26115 }
26116 }
26117 {
26118 PyThreadState* __tstate = wxPyBeginAllowThreads();
26119 (arg1)->SetRect(arg2);
26120 wxPyEndAllowThreads(__tstate);
26121 if (PyErr_Occurred()) SWIG_fail;
26122 }
26123 resultobj = SWIG_Py_Void();
26124 return resultobj;
26125 fail:
26126 return NULL;
26127 }
26128
26129
26130 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26131 PyObject *resultobj = 0;
26132 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26133 wxSize arg2 ;
26134 void *argp1 = 0 ;
26135 int res1 = 0 ;
26136 void *argp2 ;
26137 int res2 = 0 ;
26138 PyObject * obj0 = 0 ;
26139 PyObject * obj1 = 0 ;
26140 char * kwnames[] = {
26141 (char *) "self",(char *) "size", NULL
26142 };
26143
26144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26146 if (!SWIG_IsOK(res1)) {
26147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26148 }
26149 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26150 {
26151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26152 if (!SWIG_IsOK(res2)) {
26153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26154 }
26155 if (!argp2) {
26156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26157 } else {
26158 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26159 arg2 = *temp;
26160 if (SWIG_IsNewObj(res2)) delete temp;
26161 }
26162 }
26163 {
26164 PyThreadState* __tstate = wxPyBeginAllowThreads();
26165 wxSizeEvent_SetSize(arg1,arg2);
26166 wxPyEndAllowThreads(__tstate);
26167 if (PyErr_Occurred()) SWIG_fail;
26168 }
26169 resultobj = SWIG_Py_Void();
26170 return resultobj;
26171 fail:
26172 return NULL;
26173 }
26174
26175
26176 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26177 PyObject *resultobj = 0;
26178 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26179 wxSize *arg2 = (wxSize *) 0 ;
26180 void *argp1 = 0 ;
26181 int res1 = 0 ;
26182 void *argp2 = 0 ;
26183 int res2 = 0 ;
26184 PyObject *swig_obj[2] ;
26185
26186 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26188 if (!SWIG_IsOK(res1)) {
26189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26190 }
26191 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26192 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26193 if (!SWIG_IsOK(res2)) {
26194 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26195 }
26196 arg2 = reinterpret_cast< wxSize * >(argp2);
26197 if (arg1) (arg1)->m_size = *arg2;
26198
26199 resultobj = SWIG_Py_Void();
26200 return resultobj;
26201 fail:
26202 return NULL;
26203 }
26204
26205
26206 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26207 PyObject *resultobj = 0;
26208 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26209 wxSize *result = 0 ;
26210 void *argp1 = 0 ;
26211 int res1 = 0 ;
26212 PyObject *swig_obj[1] ;
26213
26214 if (!args) SWIG_fail;
26215 swig_obj[0] = args;
26216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26217 if (!SWIG_IsOK(res1)) {
26218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26219 }
26220 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26221 result = (wxSize *)& ((arg1)->m_size);
26222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26223 return resultobj;
26224 fail:
26225 return NULL;
26226 }
26227
26228
26229 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26230 PyObject *resultobj = 0;
26231 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26232 wxRect *arg2 = (wxRect *) 0 ;
26233 void *argp1 = 0 ;
26234 int res1 = 0 ;
26235 void *argp2 = 0 ;
26236 int res2 = 0 ;
26237 PyObject *swig_obj[2] ;
26238
26239 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26241 if (!SWIG_IsOK(res1)) {
26242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26243 }
26244 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26245 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26246 if (!SWIG_IsOK(res2)) {
26247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26248 }
26249 arg2 = reinterpret_cast< wxRect * >(argp2);
26250 if (arg1) (arg1)->m_rect = *arg2;
26251
26252 resultobj = SWIG_Py_Void();
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26260 PyObject *resultobj = 0;
26261 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26262 wxRect *result = 0 ;
26263 void *argp1 = 0 ;
26264 int res1 = 0 ;
26265 PyObject *swig_obj[1] ;
26266
26267 if (!args) SWIG_fail;
26268 swig_obj[0] = args;
26269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26270 if (!SWIG_IsOK(res1)) {
26271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26272 }
26273 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26274 result = (wxRect *)& ((arg1)->m_rect);
26275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26276 return resultobj;
26277 fail:
26278 return NULL;
26279 }
26280
26281
26282 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26283 PyObject *obj;
26284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26285 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26286 return SWIG_Py_Void();
26287 }
26288
26289 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 return SWIG_Python_InitShadowInstance(args);
26291 }
26292
26293 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26294 PyObject *resultobj = 0;
26295 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26296 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26297 int arg2 = (int) 0 ;
26298 wxMoveEvent *result = 0 ;
26299 wxPoint temp1 ;
26300 int val2 ;
26301 int ecode2 = 0 ;
26302 PyObject * obj0 = 0 ;
26303 PyObject * obj1 = 0 ;
26304 char * kwnames[] = {
26305 (char *) "pos",(char *) "winid", NULL
26306 };
26307
26308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26309 if (obj0) {
26310 {
26311 arg1 = &temp1;
26312 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26313 }
26314 }
26315 if (obj1) {
26316 ecode2 = SWIG_AsVal_int(obj1, &val2);
26317 if (!SWIG_IsOK(ecode2)) {
26318 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26319 }
26320 arg2 = static_cast< int >(val2);
26321 }
26322 {
26323 PyThreadState* __tstate = wxPyBeginAllowThreads();
26324 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26325 wxPyEndAllowThreads(__tstate);
26326 if (PyErr_Occurred()) SWIG_fail;
26327 }
26328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26329 return resultobj;
26330 fail:
26331 return NULL;
26332 }
26333
26334
26335 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26336 PyObject *resultobj = 0;
26337 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26338 wxPoint result;
26339 void *argp1 = 0 ;
26340 int res1 = 0 ;
26341 PyObject *swig_obj[1] ;
26342
26343 if (!args) SWIG_fail;
26344 swig_obj[0] = args;
26345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26346 if (!SWIG_IsOK(res1)) {
26347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26348 }
26349 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 result = ((wxMoveEvent const *)arg1)->GetPosition();
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26364 PyObject *resultobj = 0;
26365 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26366 wxRect result;
26367 void *argp1 = 0 ;
26368 int res1 = 0 ;
26369 PyObject *swig_obj[1] ;
26370
26371 if (!args) SWIG_fail;
26372 swig_obj[0] = args;
26373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26374 if (!SWIG_IsOK(res1)) {
26375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26376 }
26377 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26378 {
26379 PyThreadState* __tstate = wxPyBeginAllowThreads();
26380 result = ((wxMoveEvent const *)arg1)->GetRect();
26381 wxPyEndAllowThreads(__tstate);
26382 if (PyErr_Occurred()) SWIG_fail;
26383 }
26384 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26385 return resultobj;
26386 fail:
26387 return NULL;
26388 }
26389
26390
26391 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26392 PyObject *resultobj = 0;
26393 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26394 wxRect *arg2 = 0 ;
26395 void *argp1 = 0 ;
26396 int res1 = 0 ;
26397 wxRect temp2 ;
26398 PyObject * obj0 = 0 ;
26399 PyObject * obj1 = 0 ;
26400 char * kwnames[] = {
26401 (char *) "self",(char *) "rect", NULL
26402 };
26403
26404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26406 if (!SWIG_IsOK(res1)) {
26407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26408 }
26409 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26410 {
26411 arg2 = &temp2;
26412 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26413 }
26414 {
26415 PyThreadState* __tstate = wxPyBeginAllowThreads();
26416 (arg1)->SetRect((wxRect const &)*arg2);
26417 wxPyEndAllowThreads(__tstate);
26418 if (PyErr_Occurred()) SWIG_fail;
26419 }
26420 resultobj = SWIG_Py_Void();
26421 return resultobj;
26422 fail:
26423 return NULL;
26424 }
26425
26426
26427 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26428 PyObject *resultobj = 0;
26429 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26430 wxPoint *arg2 = 0 ;
26431 void *argp1 = 0 ;
26432 int res1 = 0 ;
26433 wxPoint temp2 ;
26434 PyObject * obj0 = 0 ;
26435 PyObject * obj1 = 0 ;
26436 char * kwnames[] = {
26437 (char *) "self",(char *) "pos", NULL
26438 };
26439
26440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26442 if (!SWIG_IsOK(res1)) {
26443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26444 }
26445 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26446 {
26447 arg2 = &temp2;
26448 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26449 }
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 (arg1)->SetPosition((wxPoint const &)*arg2);
26453 wxPyEndAllowThreads(__tstate);
26454 if (PyErr_Occurred()) SWIG_fail;
26455 }
26456 resultobj = SWIG_Py_Void();
26457 return resultobj;
26458 fail:
26459 return NULL;
26460 }
26461
26462
26463 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26464 PyObject *obj;
26465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26466 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26467 return SWIG_Py_Void();
26468 }
26469
26470 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26471 return SWIG_Python_InitShadowInstance(args);
26472 }
26473
26474 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26475 PyObject *resultobj = 0;
26476 int arg1 = (int) 0 ;
26477 wxPaintEvent *result = 0 ;
26478 int val1 ;
26479 int ecode1 = 0 ;
26480 PyObject * obj0 = 0 ;
26481 char * kwnames[] = {
26482 (char *) "Id", NULL
26483 };
26484
26485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26486 if (obj0) {
26487 ecode1 = SWIG_AsVal_int(obj0, &val1);
26488 if (!SWIG_IsOK(ecode1)) {
26489 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26490 }
26491 arg1 = static_cast< int >(val1);
26492 }
26493 {
26494 PyThreadState* __tstate = wxPyBeginAllowThreads();
26495 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26496 wxPyEndAllowThreads(__tstate);
26497 if (PyErr_Occurred()) SWIG_fail;
26498 }
26499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26507 PyObject *obj;
26508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26509 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26510 return SWIG_Py_Void();
26511 }
26512
26513 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26514 return SWIG_Python_InitShadowInstance(args);
26515 }
26516
26517 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26518 PyObject *resultobj = 0;
26519 int arg1 = (int) 0 ;
26520 wxNcPaintEvent *result = 0 ;
26521 int val1 ;
26522 int ecode1 = 0 ;
26523 PyObject * obj0 = 0 ;
26524 char * kwnames[] = {
26525 (char *) "winid", NULL
26526 };
26527
26528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26529 if (obj0) {
26530 ecode1 = SWIG_AsVal_int(obj0, &val1);
26531 if (!SWIG_IsOK(ecode1)) {
26532 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26533 }
26534 arg1 = static_cast< int >(val1);
26535 }
26536 {
26537 PyThreadState* __tstate = wxPyBeginAllowThreads();
26538 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26543 return resultobj;
26544 fail:
26545 return NULL;
26546 }
26547
26548
26549 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26550 PyObject *obj;
26551 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26552 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26553 return SWIG_Py_Void();
26554 }
26555
26556 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 return SWIG_Python_InitShadowInstance(args);
26558 }
26559
26560 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26561 PyObject *resultobj = 0;
26562 int arg1 = (int) 0 ;
26563 wxDC *arg2 = (wxDC *) NULL ;
26564 wxEraseEvent *result = 0 ;
26565 int val1 ;
26566 int ecode1 = 0 ;
26567 void *argp2 = 0 ;
26568 int res2 = 0 ;
26569 PyObject * obj0 = 0 ;
26570 PyObject * obj1 = 0 ;
26571 char * kwnames[] = {
26572 (char *) "Id",(char *) "dc", NULL
26573 };
26574
26575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26576 if (obj0) {
26577 ecode1 = SWIG_AsVal_int(obj0, &val1);
26578 if (!SWIG_IsOK(ecode1)) {
26579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26580 }
26581 arg1 = static_cast< int >(val1);
26582 }
26583 if (obj1) {
26584 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26585 if (!SWIG_IsOK(res2)) {
26586 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26587 }
26588 arg2 = reinterpret_cast< wxDC * >(argp2);
26589 }
26590 {
26591 PyThreadState* __tstate = wxPyBeginAllowThreads();
26592 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26593 wxPyEndAllowThreads(__tstate);
26594 if (PyErr_Occurred()) SWIG_fail;
26595 }
26596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26597 return resultobj;
26598 fail:
26599 return NULL;
26600 }
26601
26602
26603 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26604 PyObject *resultobj = 0;
26605 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26606 wxDC *result = 0 ;
26607 void *argp1 = 0 ;
26608 int res1 = 0 ;
26609 PyObject *swig_obj[1] ;
26610
26611 if (!args) SWIG_fail;
26612 swig_obj[0] = args;
26613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26614 if (!SWIG_IsOK(res1)) {
26615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26616 }
26617 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26618 {
26619 PyThreadState* __tstate = wxPyBeginAllowThreads();
26620 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26621 wxPyEndAllowThreads(__tstate);
26622 if (PyErr_Occurred()) SWIG_fail;
26623 }
26624 {
26625 resultobj = wxPyMake_wxObject(result, (bool)0);
26626 }
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26634 PyObject *obj;
26635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26636 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26637 return SWIG_Py_Void();
26638 }
26639
26640 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26641 return SWIG_Python_InitShadowInstance(args);
26642 }
26643
26644 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26645 PyObject *resultobj = 0;
26646 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26647 int arg2 = (int) 0 ;
26648 wxFocusEvent *result = 0 ;
26649 int val1 ;
26650 int ecode1 = 0 ;
26651 int val2 ;
26652 int ecode2 = 0 ;
26653 PyObject * obj0 = 0 ;
26654 PyObject * obj1 = 0 ;
26655 char * kwnames[] = {
26656 (char *) "type",(char *) "winid", NULL
26657 };
26658
26659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26660 if (obj0) {
26661 ecode1 = SWIG_AsVal_int(obj0, &val1);
26662 if (!SWIG_IsOK(ecode1)) {
26663 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26664 }
26665 arg1 = static_cast< wxEventType >(val1);
26666 }
26667 if (obj1) {
26668 ecode2 = SWIG_AsVal_int(obj1, &val2);
26669 if (!SWIG_IsOK(ecode2)) {
26670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26671 }
26672 arg2 = static_cast< int >(val2);
26673 }
26674 {
26675 PyThreadState* __tstate = wxPyBeginAllowThreads();
26676 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26677 wxPyEndAllowThreads(__tstate);
26678 if (PyErr_Occurred()) SWIG_fail;
26679 }
26680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26681 return resultobj;
26682 fail:
26683 return NULL;
26684 }
26685
26686
26687 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26688 PyObject *resultobj = 0;
26689 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26690 wxWindow *result = 0 ;
26691 void *argp1 = 0 ;
26692 int res1 = 0 ;
26693 PyObject *swig_obj[1] ;
26694
26695 if (!args) SWIG_fail;
26696 swig_obj[0] = args;
26697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26698 if (!SWIG_IsOK(res1)) {
26699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26700 }
26701 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26705 wxPyEndAllowThreads(__tstate);
26706 if (PyErr_Occurred()) SWIG_fail;
26707 }
26708 {
26709 resultobj = wxPyMake_wxObject(result, (bool)0);
26710 }
26711 return resultobj;
26712 fail:
26713 return NULL;
26714 }
26715
26716
26717 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26718 PyObject *resultobj = 0;
26719 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26720 wxWindow *arg2 = (wxWindow *) 0 ;
26721 void *argp1 = 0 ;
26722 int res1 = 0 ;
26723 void *argp2 = 0 ;
26724 int res2 = 0 ;
26725 PyObject * obj0 = 0 ;
26726 PyObject * obj1 = 0 ;
26727 char * kwnames[] = {
26728 (char *) "self",(char *) "win", NULL
26729 };
26730
26731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26733 if (!SWIG_IsOK(res1)) {
26734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26735 }
26736 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26737 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26738 if (!SWIG_IsOK(res2)) {
26739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26740 }
26741 arg2 = reinterpret_cast< wxWindow * >(argp2);
26742 {
26743 PyThreadState* __tstate = wxPyBeginAllowThreads();
26744 (arg1)->SetWindow(arg2);
26745 wxPyEndAllowThreads(__tstate);
26746 if (PyErr_Occurred()) SWIG_fail;
26747 }
26748 resultobj = SWIG_Py_Void();
26749 return resultobj;
26750 fail:
26751 return NULL;
26752 }
26753
26754
26755 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26756 PyObject *obj;
26757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26758 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26759 return SWIG_Py_Void();
26760 }
26761
26762 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26763 return SWIG_Python_InitShadowInstance(args);
26764 }
26765
26766 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26767 PyObject *resultobj = 0;
26768 wxWindow *arg1 = (wxWindow *) NULL ;
26769 wxChildFocusEvent *result = 0 ;
26770 void *argp1 = 0 ;
26771 int res1 = 0 ;
26772 PyObject * obj0 = 0 ;
26773 char * kwnames[] = {
26774 (char *) "win", NULL
26775 };
26776
26777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26778 if (obj0) {
26779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26780 if (!SWIG_IsOK(res1)) {
26781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26782 }
26783 arg1 = reinterpret_cast< wxWindow * >(argp1);
26784 }
26785 {
26786 PyThreadState* __tstate = wxPyBeginAllowThreads();
26787 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26788 wxPyEndAllowThreads(__tstate);
26789 if (PyErr_Occurred()) SWIG_fail;
26790 }
26791 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26792 return resultobj;
26793 fail:
26794 return NULL;
26795 }
26796
26797
26798 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26799 PyObject *resultobj = 0;
26800 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26801 wxWindow *result = 0 ;
26802 void *argp1 = 0 ;
26803 int res1 = 0 ;
26804 PyObject *swig_obj[1] ;
26805
26806 if (!args) SWIG_fail;
26807 swig_obj[0] = args;
26808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26809 if (!SWIG_IsOK(res1)) {
26810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26811 }
26812 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26813 {
26814 PyThreadState* __tstate = wxPyBeginAllowThreads();
26815 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26816 wxPyEndAllowThreads(__tstate);
26817 if (PyErr_Occurred()) SWIG_fail;
26818 }
26819 {
26820 resultobj = wxPyMake_wxObject(result, (bool)0);
26821 }
26822 return resultobj;
26823 fail:
26824 return NULL;
26825 }
26826
26827
26828 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26829 PyObject *obj;
26830 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26831 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26832 return SWIG_Py_Void();
26833 }
26834
26835 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26836 return SWIG_Python_InitShadowInstance(args);
26837 }
26838
26839 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26840 PyObject *resultobj = 0;
26841 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26842 bool arg2 = (bool) true ;
26843 int arg3 = (int) 0 ;
26844 wxActivateEvent *result = 0 ;
26845 int val1 ;
26846 int ecode1 = 0 ;
26847 bool val2 ;
26848 int ecode2 = 0 ;
26849 int val3 ;
26850 int ecode3 = 0 ;
26851 PyObject * obj0 = 0 ;
26852 PyObject * obj1 = 0 ;
26853 PyObject * obj2 = 0 ;
26854 char * kwnames[] = {
26855 (char *) "type",(char *) "active",(char *) "Id", NULL
26856 };
26857
26858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26859 if (obj0) {
26860 ecode1 = SWIG_AsVal_int(obj0, &val1);
26861 if (!SWIG_IsOK(ecode1)) {
26862 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26863 }
26864 arg1 = static_cast< wxEventType >(val1);
26865 }
26866 if (obj1) {
26867 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26868 if (!SWIG_IsOK(ecode2)) {
26869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26870 }
26871 arg2 = static_cast< bool >(val2);
26872 }
26873 if (obj2) {
26874 ecode3 = SWIG_AsVal_int(obj2, &val3);
26875 if (!SWIG_IsOK(ecode3)) {
26876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26877 }
26878 arg3 = static_cast< int >(val3);
26879 }
26880 {
26881 PyThreadState* __tstate = wxPyBeginAllowThreads();
26882 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26883 wxPyEndAllowThreads(__tstate);
26884 if (PyErr_Occurred()) SWIG_fail;
26885 }
26886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26887 return resultobj;
26888 fail:
26889 return NULL;
26890 }
26891
26892
26893 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26894 PyObject *resultobj = 0;
26895 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26896 bool result;
26897 void *argp1 = 0 ;
26898 int res1 = 0 ;
26899 PyObject *swig_obj[1] ;
26900
26901 if (!args) SWIG_fail;
26902 swig_obj[0] = args;
26903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26904 if (!SWIG_IsOK(res1)) {
26905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26906 }
26907 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26908 {
26909 PyThreadState* __tstate = wxPyBeginAllowThreads();
26910 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26911 wxPyEndAllowThreads(__tstate);
26912 if (PyErr_Occurred()) SWIG_fail;
26913 }
26914 {
26915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26916 }
26917 return resultobj;
26918 fail:
26919 return NULL;
26920 }
26921
26922
26923 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26924 PyObject *obj;
26925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26926 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26927 return SWIG_Py_Void();
26928 }
26929
26930 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26931 return SWIG_Python_InitShadowInstance(args);
26932 }
26933
26934 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26935 PyObject *resultobj = 0;
26936 int arg1 = (int) 0 ;
26937 wxInitDialogEvent *result = 0 ;
26938 int val1 ;
26939 int ecode1 = 0 ;
26940 PyObject * obj0 = 0 ;
26941 char * kwnames[] = {
26942 (char *) "Id", NULL
26943 };
26944
26945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26946 if (obj0) {
26947 ecode1 = SWIG_AsVal_int(obj0, &val1);
26948 if (!SWIG_IsOK(ecode1)) {
26949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26950 }
26951 arg1 = static_cast< int >(val1);
26952 }
26953 {
26954 PyThreadState* __tstate = wxPyBeginAllowThreads();
26955 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26956 wxPyEndAllowThreads(__tstate);
26957 if (PyErr_Occurred()) SWIG_fail;
26958 }
26959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26960 return resultobj;
26961 fail:
26962 return NULL;
26963 }
26964
26965
26966 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26967 PyObject *obj;
26968 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26969 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26970 return SWIG_Py_Void();
26971 }
26972
26973 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26974 return SWIG_Python_InitShadowInstance(args);
26975 }
26976
26977 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26978 PyObject *resultobj = 0;
26979 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26980 int arg2 = (int) 0 ;
26981 wxMenu *arg3 = (wxMenu *) NULL ;
26982 wxMenuEvent *result = 0 ;
26983 int val1 ;
26984 int ecode1 = 0 ;
26985 int val2 ;
26986 int ecode2 = 0 ;
26987 void *argp3 = 0 ;
26988 int res3 = 0 ;
26989 PyObject * obj0 = 0 ;
26990 PyObject * obj1 = 0 ;
26991 PyObject * obj2 = 0 ;
26992 char * kwnames[] = {
26993 (char *) "type",(char *) "winid",(char *) "menu", NULL
26994 };
26995
26996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26997 if (obj0) {
26998 ecode1 = SWIG_AsVal_int(obj0, &val1);
26999 if (!SWIG_IsOK(ecode1)) {
27000 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27001 }
27002 arg1 = static_cast< wxEventType >(val1);
27003 }
27004 if (obj1) {
27005 ecode2 = SWIG_AsVal_int(obj1, &val2);
27006 if (!SWIG_IsOK(ecode2)) {
27007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
27008 }
27009 arg2 = static_cast< int >(val2);
27010 }
27011 if (obj2) {
27012 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
27013 if (!SWIG_IsOK(res3)) {
27014 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
27015 }
27016 arg3 = reinterpret_cast< wxMenu * >(argp3);
27017 }
27018 {
27019 PyThreadState* __tstate = wxPyBeginAllowThreads();
27020 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
27021 wxPyEndAllowThreads(__tstate);
27022 if (PyErr_Occurred()) SWIG_fail;
27023 }
27024 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
27025 return resultobj;
27026 fail:
27027 return NULL;
27028 }
27029
27030
27031 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27032 PyObject *resultobj = 0;
27033 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27034 int result;
27035 void *argp1 = 0 ;
27036 int res1 = 0 ;
27037 PyObject *swig_obj[1] ;
27038
27039 if (!args) SWIG_fail;
27040 swig_obj[0] = args;
27041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27042 if (!SWIG_IsOK(res1)) {
27043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27044 }
27045 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27046 {
27047 PyThreadState* __tstate = wxPyBeginAllowThreads();
27048 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
27049 wxPyEndAllowThreads(__tstate);
27050 if (PyErr_Occurred()) SWIG_fail;
27051 }
27052 resultobj = SWIG_From_int(static_cast< int >(result));
27053 return resultobj;
27054 fail:
27055 return NULL;
27056 }
27057
27058
27059 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27060 PyObject *resultobj = 0;
27061 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27062 bool result;
27063 void *argp1 = 0 ;
27064 int res1 = 0 ;
27065 PyObject *swig_obj[1] ;
27066
27067 if (!args) SWIG_fail;
27068 swig_obj[0] = args;
27069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27070 if (!SWIG_IsOK(res1)) {
27071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27072 }
27073 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27074 {
27075 PyThreadState* __tstate = wxPyBeginAllowThreads();
27076 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27077 wxPyEndAllowThreads(__tstate);
27078 if (PyErr_Occurred()) SWIG_fail;
27079 }
27080 {
27081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27082 }
27083 return resultobj;
27084 fail:
27085 return NULL;
27086 }
27087
27088
27089 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27090 PyObject *resultobj = 0;
27091 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27092 wxMenu *result = 0 ;
27093 void *argp1 = 0 ;
27094 int res1 = 0 ;
27095 PyObject *swig_obj[1] ;
27096
27097 if (!args) SWIG_fail;
27098 swig_obj[0] = args;
27099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27100 if (!SWIG_IsOK(res1)) {
27101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27102 }
27103 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27104 {
27105 PyThreadState* __tstate = wxPyBeginAllowThreads();
27106 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27107 wxPyEndAllowThreads(__tstate);
27108 if (PyErr_Occurred()) SWIG_fail;
27109 }
27110 {
27111 resultobj = wxPyMake_wxObject(result, (bool)0);
27112 }
27113 return resultobj;
27114 fail:
27115 return NULL;
27116 }
27117
27118
27119 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27120 PyObject *obj;
27121 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27122 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27123 return SWIG_Py_Void();
27124 }
27125
27126 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27127 return SWIG_Python_InitShadowInstance(args);
27128 }
27129
27130 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27131 PyObject *resultobj = 0;
27132 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27133 int arg2 = (int) 0 ;
27134 wxCloseEvent *result = 0 ;
27135 int val1 ;
27136 int ecode1 = 0 ;
27137 int val2 ;
27138 int ecode2 = 0 ;
27139 PyObject * obj0 = 0 ;
27140 PyObject * obj1 = 0 ;
27141 char * kwnames[] = {
27142 (char *) "type",(char *) "winid", NULL
27143 };
27144
27145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27146 if (obj0) {
27147 ecode1 = SWIG_AsVal_int(obj0, &val1);
27148 if (!SWIG_IsOK(ecode1)) {
27149 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27150 }
27151 arg1 = static_cast< wxEventType >(val1);
27152 }
27153 if (obj1) {
27154 ecode2 = SWIG_AsVal_int(obj1, &val2);
27155 if (!SWIG_IsOK(ecode2)) {
27156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27157 }
27158 arg2 = static_cast< int >(val2);
27159 }
27160 {
27161 PyThreadState* __tstate = wxPyBeginAllowThreads();
27162 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27163 wxPyEndAllowThreads(__tstate);
27164 if (PyErr_Occurred()) SWIG_fail;
27165 }
27166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27167 return resultobj;
27168 fail:
27169 return NULL;
27170 }
27171
27172
27173 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27174 PyObject *resultobj = 0;
27175 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27176 bool arg2 ;
27177 void *argp1 = 0 ;
27178 int res1 = 0 ;
27179 bool val2 ;
27180 int ecode2 = 0 ;
27181 PyObject * obj0 = 0 ;
27182 PyObject * obj1 = 0 ;
27183 char * kwnames[] = {
27184 (char *) "self",(char *) "logOff", NULL
27185 };
27186
27187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27189 if (!SWIG_IsOK(res1)) {
27190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27191 }
27192 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27193 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27194 if (!SWIG_IsOK(ecode2)) {
27195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27196 }
27197 arg2 = static_cast< bool >(val2);
27198 {
27199 PyThreadState* __tstate = wxPyBeginAllowThreads();
27200 (arg1)->SetLoggingOff(arg2);
27201 wxPyEndAllowThreads(__tstate);
27202 if (PyErr_Occurred()) SWIG_fail;
27203 }
27204 resultobj = SWIG_Py_Void();
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27212 PyObject *resultobj = 0;
27213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27214 bool result;
27215 void *argp1 = 0 ;
27216 int res1 = 0 ;
27217 PyObject *swig_obj[1] ;
27218
27219 if (!args) SWIG_fail;
27220 swig_obj[0] = args;
27221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27222 if (!SWIG_IsOK(res1)) {
27223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27224 }
27225 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27226 {
27227 PyThreadState* __tstate = wxPyBeginAllowThreads();
27228 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27229 wxPyEndAllowThreads(__tstate);
27230 if (PyErr_Occurred()) SWIG_fail;
27231 }
27232 {
27233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27234 }
27235 return resultobj;
27236 fail:
27237 return NULL;
27238 }
27239
27240
27241 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27242 PyObject *resultobj = 0;
27243 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27244 bool arg2 = (bool) true ;
27245 void *argp1 = 0 ;
27246 int res1 = 0 ;
27247 bool val2 ;
27248 int ecode2 = 0 ;
27249 PyObject * obj0 = 0 ;
27250 PyObject * obj1 = 0 ;
27251 char * kwnames[] = {
27252 (char *) "self",(char *) "veto", NULL
27253 };
27254
27255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27257 if (!SWIG_IsOK(res1)) {
27258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27259 }
27260 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27261 if (obj1) {
27262 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27263 if (!SWIG_IsOK(ecode2)) {
27264 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27265 }
27266 arg2 = static_cast< bool >(val2);
27267 }
27268 {
27269 PyThreadState* __tstate = wxPyBeginAllowThreads();
27270 (arg1)->Veto(arg2);
27271 wxPyEndAllowThreads(__tstate);
27272 if (PyErr_Occurred()) SWIG_fail;
27273 }
27274 resultobj = SWIG_Py_Void();
27275 return resultobj;
27276 fail:
27277 return NULL;
27278 }
27279
27280
27281 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27282 PyObject *resultobj = 0;
27283 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27284 bool result;
27285 void *argp1 = 0 ;
27286 int res1 = 0 ;
27287 PyObject *swig_obj[1] ;
27288
27289 if (!args) SWIG_fail;
27290 swig_obj[0] = args;
27291 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27292 if (!SWIG_IsOK(res1)) {
27293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27294 }
27295 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27296 {
27297 PyThreadState* __tstate = wxPyBeginAllowThreads();
27298 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27299 wxPyEndAllowThreads(__tstate);
27300 if (PyErr_Occurred()) SWIG_fail;
27301 }
27302 {
27303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27304 }
27305 return resultobj;
27306 fail:
27307 return NULL;
27308 }
27309
27310
27311 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27312 PyObject *resultobj = 0;
27313 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27314 bool arg2 ;
27315 void *argp1 = 0 ;
27316 int res1 = 0 ;
27317 bool val2 ;
27318 int ecode2 = 0 ;
27319 PyObject * obj0 = 0 ;
27320 PyObject * obj1 = 0 ;
27321 char * kwnames[] = {
27322 (char *) "self",(char *) "canVeto", NULL
27323 };
27324
27325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27327 if (!SWIG_IsOK(res1)) {
27328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27329 }
27330 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27331 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27332 if (!SWIG_IsOK(ecode2)) {
27333 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27334 }
27335 arg2 = static_cast< bool >(val2);
27336 {
27337 PyThreadState* __tstate = wxPyBeginAllowThreads();
27338 (arg1)->SetCanVeto(arg2);
27339 wxPyEndAllowThreads(__tstate);
27340 if (PyErr_Occurred()) SWIG_fail;
27341 }
27342 resultobj = SWIG_Py_Void();
27343 return resultobj;
27344 fail:
27345 return NULL;
27346 }
27347
27348
27349 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27350 PyObject *resultobj = 0;
27351 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27352 bool result;
27353 void *argp1 = 0 ;
27354 int res1 = 0 ;
27355 PyObject *swig_obj[1] ;
27356
27357 if (!args) SWIG_fail;
27358 swig_obj[0] = args;
27359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27360 if (!SWIG_IsOK(res1)) {
27361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27362 }
27363 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27364 {
27365 PyThreadState* __tstate = wxPyBeginAllowThreads();
27366 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27367 wxPyEndAllowThreads(__tstate);
27368 if (PyErr_Occurred()) SWIG_fail;
27369 }
27370 {
27371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27372 }
27373 return resultobj;
27374 fail:
27375 return NULL;
27376 }
27377
27378
27379 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27380 PyObject *obj;
27381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27382 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27383 return SWIG_Py_Void();
27384 }
27385
27386 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27387 return SWIG_Python_InitShadowInstance(args);
27388 }
27389
27390 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27391 PyObject *resultobj = 0;
27392 int arg1 = (int) 0 ;
27393 bool arg2 = (bool) false ;
27394 wxShowEvent *result = 0 ;
27395 int val1 ;
27396 int ecode1 = 0 ;
27397 bool val2 ;
27398 int ecode2 = 0 ;
27399 PyObject * obj0 = 0 ;
27400 PyObject * obj1 = 0 ;
27401 char * kwnames[] = {
27402 (char *) "winid",(char *) "show", NULL
27403 };
27404
27405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27406 if (obj0) {
27407 ecode1 = SWIG_AsVal_int(obj0, &val1);
27408 if (!SWIG_IsOK(ecode1)) {
27409 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27410 }
27411 arg1 = static_cast< int >(val1);
27412 }
27413 if (obj1) {
27414 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27415 if (!SWIG_IsOK(ecode2)) {
27416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27417 }
27418 arg2 = static_cast< bool >(val2);
27419 }
27420 {
27421 PyThreadState* __tstate = wxPyBeginAllowThreads();
27422 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27423 wxPyEndAllowThreads(__tstate);
27424 if (PyErr_Occurred()) SWIG_fail;
27425 }
27426 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27427 return resultobj;
27428 fail:
27429 return NULL;
27430 }
27431
27432
27433 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27434 PyObject *resultobj = 0;
27435 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27436 bool arg2 ;
27437 void *argp1 = 0 ;
27438 int res1 = 0 ;
27439 bool val2 ;
27440 int ecode2 = 0 ;
27441 PyObject * obj0 = 0 ;
27442 PyObject * obj1 = 0 ;
27443 char * kwnames[] = {
27444 (char *) "self",(char *) "show", NULL
27445 };
27446
27447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27449 if (!SWIG_IsOK(res1)) {
27450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27451 }
27452 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27453 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27454 if (!SWIG_IsOK(ecode2)) {
27455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27456 }
27457 arg2 = static_cast< bool >(val2);
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 (arg1)->SetShow(arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 resultobj = SWIG_Py_Void();
27465 return resultobj;
27466 fail:
27467 return NULL;
27468 }
27469
27470
27471 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27472 PyObject *resultobj = 0;
27473 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27474 bool result;
27475 void *argp1 = 0 ;
27476 int res1 = 0 ;
27477 PyObject *swig_obj[1] ;
27478
27479 if (!args) SWIG_fail;
27480 swig_obj[0] = args;
27481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27482 if (!SWIG_IsOK(res1)) {
27483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27484 }
27485 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27486 {
27487 PyThreadState* __tstate = wxPyBeginAllowThreads();
27488 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27489 wxPyEndAllowThreads(__tstate);
27490 if (PyErr_Occurred()) SWIG_fail;
27491 }
27492 {
27493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27494 }
27495 return resultobj;
27496 fail:
27497 return NULL;
27498 }
27499
27500
27501 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27502 PyObject *obj;
27503 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27504 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27505 return SWIG_Py_Void();
27506 }
27507
27508 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27509 return SWIG_Python_InitShadowInstance(args);
27510 }
27511
27512 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27513 PyObject *resultobj = 0;
27514 int arg1 = (int) 0 ;
27515 bool arg2 = (bool) true ;
27516 wxIconizeEvent *result = 0 ;
27517 int val1 ;
27518 int ecode1 = 0 ;
27519 bool val2 ;
27520 int ecode2 = 0 ;
27521 PyObject * obj0 = 0 ;
27522 PyObject * obj1 = 0 ;
27523 char * kwnames[] = {
27524 (char *) "id",(char *) "iconized", NULL
27525 };
27526
27527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27528 if (obj0) {
27529 ecode1 = SWIG_AsVal_int(obj0, &val1);
27530 if (!SWIG_IsOK(ecode1)) {
27531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27532 }
27533 arg1 = static_cast< int >(val1);
27534 }
27535 if (obj1) {
27536 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27537 if (!SWIG_IsOK(ecode2)) {
27538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27539 }
27540 arg2 = static_cast< bool >(val2);
27541 }
27542 {
27543 PyThreadState* __tstate = wxPyBeginAllowThreads();
27544 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27545 wxPyEndAllowThreads(__tstate);
27546 if (PyErr_Occurred()) SWIG_fail;
27547 }
27548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27549 return resultobj;
27550 fail:
27551 return NULL;
27552 }
27553
27554
27555 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27556 PyObject *resultobj = 0;
27557 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27558 bool result;
27559 void *argp1 = 0 ;
27560 int res1 = 0 ;
27561 PyObject *swig_obj[1] ;
27562
27563 if (!args) SWIG_fail;
27564 swig_obj[0] = args;
27565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27566 if (!SWIG_IsOK(res1)) {
27567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27568 }
27569 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27570 {
27571 PyThreadState* __tstate = wxPyBeginAllowThreads();
27572 result = (bool)(arg1)->Iconized();
27573 wxPyEndAllowThreads(__tstate);
27574 if (PyErr_Occurred()) SWIG_fail;
27575 }
27576 {
27577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27578 }
27579 return resultobj;
27580 fail:
27581 return NULL;
27582 }
27583
27584
27585 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27586 PyObject *obj;
27587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27588 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27589 return SWIG_Py_Void();
27590 }
27591
27592 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27593 return SWIG_Python_InitShadowInstance(args);
27594 }
27595
27596 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27597 PyObject *resultobj = 0;
27598 int arg1 = (int) 0 ;
27599 wxMaximizeEvent *result = 0 ;
27600 int val1 ;
27601 int ecode1 = 0 ;
27602 PyObject * obj0 = 0 ;
27603 char * kwnames[] = {
27604 (char *) "id", NULL
27605 };
27606
27607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27608 if (obj0) {
27609 ecode1 = SWIG_AsVal_int(obj0, &val1);
27610 if (!SWIG_IsOK(ecode1)) {
27611 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27612 }
27613 arg1 = static_cast< int >(val1);
27614 }
27615 {
27616 PyThreadState* __tstate = wxPyBeginAllowThreads();
27617 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27618 wxPyEndAllowThreads(__tstate);
27619 if (PyErr_Occurred()) SWIG_fail;
27620 }
27621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27622 return resultobj;
27623 fail:
27624 return NULL;
27625 }
27626
27627
27628 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27629 PyObject *obj;
27630 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27631 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27632 return SWIG_Py_Void();
27633 }
27634
27635 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27636 return SWIG_Python_InitShadowInstance(args);
27637 }
27638
27639 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27640 PyObject *resultobj = 0;
27641 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27642 wxPoint result;
27643 void *argp1 = 0 ;
27644 int res1 = 0 ;
27645 PyObject *swig_obj[1] ;
27646
27647 if (!args) SWIG_fail;
27648 swig_obj[0] = args;
27649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27650 if (!SWIG_IsOK(res1)) {
27651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27652 }
27653 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27654 {
27655 PyThreadState* __tstate = wxPyBeginAllowThreads();
27656 result = (arg1)->GetPosition();
27657 wxPyEndAllowThreads(__tstate);
27658 if (PyErr_Occurred()) SWIG_fail;
27659 }
27660 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27661 return resultobj;
27662 fail:
27663 return NULL;
27664 }
27665
27666
27667 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27668 PyObject *resultobj = 0;
27669 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27670 int result;
27671 void *argp1 = 0 ;
27672 int res1 = 0 ;
27673 PyObject *swig_obj[1] ;
27674
27675 if (!args) SWIG_fail;
27676 swig_obj[0] = args;
27677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27678 if (!SWIG_IsOK(res1)) {
27679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27680 }
27681 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27682 {
27683 PyThreadState* __tstate = wxPyBeginAllowThreads();
27684 result = (int)(arg1)->GetNumberOfFiles();
27685 wxPyEndAllowThreads(__tstate);
27686 if (PyErr_Occurred()) SWIG_fail;
27687 }
27688 resultobj = SWIG_From_int(static_cast< int >(result));
27689 return resultobj;
27690 fail:
27691 return NULL;
27692 }
27693
27694
27695 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27696 PyObject *resultobj = 0;
27697 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27698 PyObject *result = 0 ;
27699 void *argp1 = 0 ;
27700 int res1 = 0 ;
27701 PyObject *swig_obj[1] ;
27702
27703 if (!args) SWIG_fail;
27704 swig_obj[0] = args;
27705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27706 if (!SWIG_IsOK(res1)) {
27707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27708 }
27709 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27710 {
27711 PyThreadState* __tstate = wxPyBeginAllowThreads();
27712 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27713 wxPyEndAllowThreads(__tstate);
27714 if (PyErr_Occurred()) SWIG_fail;
27715 }
27716 resultobj = result;
27717 return resultobj;
27718 fail:
27719 return NULL;
27720 }
27721
27722
27723 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27724 PyObject *obj;
27725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27726 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27727 return SWIG_Py_Void();
27728 }
27729
27730 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27731 PyObject *resultobj = 0;
27732 int arg1 = (int) 0 ;
27733 wxUpdateUIEvent *result = 0 ;
27734 int val1 ;
27735 int ecode1 = 0 ;
27736 PyObject * obj0 = 0 ;
27737 char * kwnames[] = {
27738 (char *) "commandId", NULL
27739 };
27740
27741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27742 if (obj0) {
27743 ecode1 = SWIG_AsVal_int(obj0, &val1);
27744 if (!SWIG_IsOK(ecode1)) {
27745 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27746 }
27747 arg1 = static_cast< int >(val1);
27748 }
27749 {
27750 PyThreadState* __tstate = wxPyBeginAllowThreads();
27751 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27756 return resultobj;
27757 fail:
27758 return NULL;
27759 }
27760
27761
27762 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27763 PyObject *resultobj = 0;
27764 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27765 bool result;
27766 void *argp1 = 0 ;
27767 int res1 = 0 ;
27768 PyObject *swig_obj[1] ;
27769
27770 if (!args) SWIG_fail;
27771 swig_obj[0] = args;
27772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27773 if (!SWIG_IsOK(res1)) {
27774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27775 }
27776 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27777 {
27778 PyThreadState* __tstate = wxPyBeginAllowThreads();
27779 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27780 wxPyEndAllowThreads(__tstate);
27781 if (PyErr_Occurred()) SWIG_fail;
27782 }
27783 {
27784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27785 }
27786 return resultobj;
27787 fail:
27788 return NULL;
27789 }
27790
27791
27792 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27793 PyObject *resultobj = 0;
27794 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27795 bool result;
27796 void *argp1 = 0 ;
27797 int res1 = 0 ;
27798 PyObject *swig_obj[1] ;
27799
27800 if (!args) SWIG_fail;
27801 swig_obj[0] = args;
27802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27803 if (!SWIG_IsOK(res1)) {
27804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27805 }
27806 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27807 {
27808 PyThreadState* __tstate = wxPyBeginAllowThreads();
27809 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27810 wxPyEndAllowThreads(__tstate);
27811 if (PyErr_Occurred()) SWIG_fail;
27812 }
27813 {
27814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27815 }
27816 return resultobj;
27817 fail:
27818 return NULL;
27819 }
27820
27821
27822 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27823 PyObject *resultobj = 0;
27824 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27825 bool result;
27826 void *argp1 = 0 ;
27827 int res1 = 0 ;
27828 PyObject *swig_obj[1] ;
27829
27830 if (!args) SWIG_fail;
27831 swig_obj[0] = args;
27832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27833 if (!SWIG_IsOK(res1)) {
27834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27835 }
27836 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27837 {
27838 PyThreadState* __tstate = wxPyBeginAllowThreads();
27839 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27840 wxPyEndAllowThreads(__tstate);
27841 if (PyErr_Occurred()) SWIG_fail;
27842 }
27843 {
27844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27845 }
27846 return resultobj;
27847 fail:
27848 return NULL;
27849 }
27850
27851
27852 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27853 PyObject *resultobj = 0;
27854 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27855 wxString result;
27856 void *argp1 = 0 ;
27857 int res1 = 0 ;
27858 PyObject *swig_obj[1] ;
27859
27860 if (!args) SWIG_fail;
27861 swig_obj[0] = args;
27862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27863 if (!SWIG_IsOK(res1)) {
27864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27865 }
27866 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27867 {
27868 PyThreadState* __tstate = wxPyBeginAllowThreads();
27869 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27870 wxPyEndAllowThreads(__tstate);
27871 if (PyErr_Occurred()) SWIG_fail;
27872 }
27873 {
27874 #if wxUSE_UNICODE
27875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27876 #else
27877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27878 #endif
27879 }
27880 return resultobj;
27881 fail:
27882 return NULL;
27883 }
27884
27885
27886 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27887 PyObject *resultobj = 0;
27888 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27889 bool result;
27890 void *argp1 = 0 ;
27891 int res1 = 0 ;
27892 PyObject *swig_obj[1] ;
27893
27894 if (!args) SWIG_fail;
27895 swig_obj[0] = args;
27896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27897 if (!SWIG_IsOK(res1)) {
27898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27899 }
27900 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27901 {
27902 PyThreadState* __tstate = wxPyBeginAllowThreads();
27903 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27904 wxPyEndAllowThreads(__tstate);
27905 if (PyErr_Occurred()) SWIG_fail;
27906 }
27907 {
27908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27909 }
27910 return resultobj;
27911 fail:
27912 return NULL;
27913 }
27914
27915
27916 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27917 PyObject *resultobj = 0;
27918 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27919 bool result;
27920 void *argp1 = 0 ;
27921 int res1 = 0 ;
27922 PyObject *swig_obj[1] ;
27923
27924 if (!args) SWIG_fail;
27925 swig_obj[0] = args;
27926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27927 if (!SWIG_IsOK(res1)) {
27928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27929 }
27930 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 {
27938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27939 }
27940 return resultobj;
27941 fail:
27942 return NULL;
27943 }
27944
27945
27946 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27947 PyObject *resultobj = 0;
27948 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27949 bool result;
27950 void *argp1 = 0 ;
27951 int res1 = 0 ;
27952 PyObject *swig_obj[1] ;
27953
27954 if (!args) SWIG_fail;
27955 swig_obj[0] = args;
27956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27957 if (!SWIG_IsOK(res1)) {
27958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27959 }
27960 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 {
27968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27969 }
27970 return resultobj;
27971 fail:
27972 return NULL;
27973 }
27974
27975
27976 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27977 PyObject *resultobj = 0;
27978 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27979 bool result;
27980 void *argp1 = 0 ;
27981 int res1 = 0 ;
27982 PyObject *swig_obj[1] ;
27983
27984 if (!args) SWIG_fail;
27985 swig_obj[0] = args;
27986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27987 if (!SWIG_IsOK(res1)) {
27988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27989 }
27990 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27991 {
27992 PyThreadState* __tstate = wxPyBeginAllowThreads();
27993 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27994 wxPyEndAllowThreads(__tstate);
27995 if (PyErr_Occurred()) SWIG_fail;
27996 }
27997 {
27998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27999 }
28000 return resultobj;
28001 fail:
28002 return NULL;
28003 }
28004
28005
28006 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28007 PyObject *resultobj = 0;
28008 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28009 bool arg2 ;
28010 void *argp1 = 0 ;
28011 int res1 = 0 ;
28012 bool val2 ;
28013 int ecode2 = 0 ;
28014 PyObject * obj0 = 0 ;
28015 PyObject * obj1 = 0 ;
28016 char * kwnames[] = {
28017 (char *) "self",(char *) "check", NULL
28018 };
28019
28020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
28021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28022 if (!SWIG_IsOK(res1)) {
28023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28024 }
28025 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28026 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28027 if (!SWIG_IsOK(ecode2)) {
28028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
28029 }
28030 arg2 = static_cast< bool >(val2);
28031 {
28032 PyThreadState* __tstate = wxPyBeginAllowThreads();
28033 (arg1)->Check(arg2);
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 resultobj = SWIG_Py_Void();
28038 return resultobj;
28039 fail:
28040 return NULL;
28041 }
28042
28043
28044 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28045 PyObject *resultobj = 0;
28046 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28047 bool arg2 ;
28048 void *argp1 = 0 ;
28049 int res1 = 0 ;
28050 bool val2 ;
28051 int ecode2 = 0 ;
28052 PyObject * obj0 = 0 ;
28053 PyObject * obj1 = 0 ;
28054 char * kwnames[] = {
28055 (char *) "self",(char *) "enable", NULL
28056 };
28057
28058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28060 if (!SWIG_IsOK(res1)) {
28061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28062 }
28063 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28064 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28065 if (!SWIG_IsOK(ecode2)) {
28066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28067 }
28068 arg2 = static_cast< bool >(val2);
28069 {
28070 PyThreadState* __tstate = wxPyBeginAllowThreads();
28071 (arg1)->Enable(arg2);
28072 wxPyEndAllowThreads(__tstate);
28073 if (PyErr_Occurred()) SWIG_fail;
28074 }
28075 resultobj = SWIG_Py_Void();
28076 return resultobj;
28077 fail:
28078 return NULL;
28079 }
28080
28081
28082 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28083 PyObject *resultobj = 0;
28084 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28085 bool arg2 ;
28086 void *argp1 = 0 ;
28087 int res1 = 0 ;
28088 bool val2 ;
28089 int ecode2 = 0 ;
28090 PyObject * obj0 = 0 ;
28091 PyObject * obj1 = 0 ;
28092 char * kwnames[] = {
28093 (char *) "self",(char *) "show", NULL
28094 };
28095
28096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28098 if (!SWIG_IsOK(res1)) {
28099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28100 }
28101 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28102 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28103 if (!SWIG_IsOK(ecode2)) {
28104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28105 }
28106 arg2 = static_cast< bool >(val2);
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 (arg1)->Show(arg2);
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 resultobj = SWIG_Py_Void();
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28121 PyObject *resultobj = 0;
28122 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28123 wxString *arg2 = 0 ;
28124 void *argp1 = 0 ;
28125 int res1 = 0 ;
28126 bool temp2 = false ;
28127 PyObject * obj0 = 0 ;
28128 PyObject * obj1 = 0 ;
28129 char * kwnames[] = {
28130 (char *) "self",(char *) "text", NULL
28131 };
28132
28133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28135 if (!SWIG_IsOK(res1)) {
28136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28137 }
28138 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28139 {
28140 arg2 = wxString_in_helper(obj1);
28141 if (arg2 == NULL) SWIG_fail;
28142 temp2 = true;
28143 }
28144 {
28145 PyThreadState* __tstate = wxPyBeginAllowThreads();
28146 (arg1)->SetText((wxString const &)*arg2);
28147 wxPyEndAllowThreads(__tstate);
28148 if (PyErr_Occurred()) SWIG_fail;
28149 }
28150 resultobj = SWIG_Py_Void();
28151 {
28152 if (temp2)
28153 delete arg2;
28154 }
28155 return resultobj;
28156 fail:
28157 {
28158 if (temp2)
28159 delete arg2;
28160 }
28161 return NULL;
28162 }
28163
28164
28165 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28166 PyObject *resultobj = 0;
28167 long arg1 ;
28168 long val1 ;
28169 int ecode1 = 0 ;
28170 PyObject * obj0 = 0 ;
28171 char * kwnames[] = {
28172 (char *) "updateInterval", NULL
28173 };
28174
28175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28176 ecode1 = SWIG_AsVal_long(obj0, &val1);
28177 if (!SWIG_IsOK(ecode1)) {
28178 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28179 }
28180 arg1 = static_cast< long >(val1);
28181 {
28182 PyThreadState* __tstate = wxPyBeginAllowThreads();
28183 wxUpdateUIEvent::SetUpdateInterval(arg1);
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 resultobj = SWIG_Py_Void();
28188 return resultobj;
28189 fail:
28190 return NULL;
28191 }
28192
28193
28194 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28195 PyObject *resultobj = 0;
28196 long result;
28197
28198 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28199 {
28200 PyThreadState* __tstate = wxPyBeginAllowThreads();
28201 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 resultobj = SWIG_From_long(static_cast< long >(result));
28206 return resultobj;
28207 fail:
28208 return NULL;
28209 }
28210
28211
28212 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28213 PyObject *resultobj = 0;
28214 wxWindow *arg1 = (wxWindow *) 0 ;
28215 bool result;
28216 void *argp1 = 0 ;
28217 int res1 = 0 ;
28218 PyObject * obj0 = 0 ;
28219 char * kwnames[] = {
28220 (char *) "win", NULL
28221 };
28222
28223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28225 if (!SWIG_IsOK(res1)) {
28226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28227 }
28228 arg1 = reinterpret_cast< wxWindow * >(argp1);
28229 {
28230 PyThreadState* __tstate = wxPyBeginAllowThreads();
28231 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28232 wxPyEndAllowThreads(__tstate);
28233 if (PyErr_Occurred()) SWIG_fail;
28234 }
28235 {
28236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28237 }
28238 return resultobj;
28239 fail:
28240 return NULL;
28241 }
28242
28243
28244 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28245 PyObject *resultobj = 0;
28246
28247 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28248 {
28249 PyThreadState* __tstate = wxPyBeginAllowThreads();
28250 wxUpdateUIEvent::ResetUpdateTime();
28251 wxPyEndAllowThreads(__tstate);
28252 if (PyErr_Occurred()) SWIG_fail;
28253 }
28254 resultobj = SWIG_Py_Void();
28255 return resultobj;
28256 fail:
28257 return NULL;
28258 }
28259
28260
28261 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28262 PyObject *resultobj = 0;
28263 wxUpdateUIMode arg1 ;
28264 int val1 ;
28265 int ecode1 = 0 ;
28266 PyObject * obj0 = 0 ;
28267 char * kwnames[] = {
28268 (char *) "mode", NULL
28269 };
28270
28271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28272 ecode1 = SWIG_AsVal_int(obj0, &val1);
28273 if (!SWIG_IsOK(ecode1)) {
28274 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28275 }
28276 arg1 = static_cast< wxUpdateUIMode >(val1);
28277 {
28278 PyThreadState* __tstate = wxPyBeginAllowThreads();
28279 wxUpdateUIEvent::SetMode(arg1);
28280 wxPyEndAllowThreads(__tstate);
28281 if (PyErr_Occurred()) SWIG_fail;
28282 }
28283 resultobj = SWIG_Py_Void();
28284 return resultobj;
28285 fail:
28286 return NULL;
28287 }
28288
28289
28290 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28291 PyObject *resultobj = 0;
28292 wxUpdateUIMode result;
28293
28294 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28295 {
28296 PyThreadState* __tstate = wxPyBeginAllowThreads();
28297 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28298 wxPyEndAllowThreads(__tstate);
28299 if (PyErr_Occurred()) SWIG_fail;
28300 }
28301 resultobj = SWIG_From_int(static_cast< int >(result));
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28309 PyObject *obj;
28310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28311 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28312 return SWIG_Py_Void();
28313 }
28314
28315 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28316 return SWIG_Python_InitShadowInstance(args);
28317 }
28318
28319 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28320 PyObject *resultobj = 0;
28321 wxSysColourChangedEvent *result = 0 ;
28322
28323 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28324 {
28325 PyThreadState* __tstate = wxPyBeginAllowThreads();
28326 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28327 wxPyEndAllowThreads(__tstate);
28328 if (PyErr_Occurred()) SWIG_fail;
28329 }
28330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28331 return resultobj;
28332 fail:
28333 return NULL;
28334 }
28335
28336
28337 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28338 PyObject *obj;
28339 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28340 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28341 return SWIG_Py_Void();
28342 }
28343
28344 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28345 return SWIG_Python_InitShadowInstance(args);
28346 }
28347
28348 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28349 PyObject *resultobj = 0;
28350 int arg1 = (int) 0 ;
28351 wxWindow *arg2 = (wxWindow *) NULL ;
28352 wxMouseCaptureChangedEvent *result = 0 ;
28353 int val1 ;
28354 int ecode1 = 0 ;
28355 void *argp2 = 0 ;
28356 int res2 = 0 ;
28357 PyObject * obj0 = 0 ;
28358 PyObject * obj1 = 0 ;
28359 char * kwnames[] = {
28360 (char *) "winid",(char *) "gainedCapture", NULL
28361 };
28362
28363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28364 if (obj0) {
28365 ecode1 = SWIG_AsVal_int(obj0, &val1);
28366 if (!SWIG_IsOK(ecode1)) {
28367 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28368 }
28369 arg1 = static_cast< int >(val1);
28370 }
28371 if (obj1) {
28372 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28373 if (!SWIG_IsOK(res2)) {
28374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28375 }
28376 arg2 = reinterpret_cast< wxWindow * >(argp2);
28377 }
28378 {
28379 PyThreadState* __tstate = wxPyBeginAllowThreads();
28380 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28381 wxPyEndAllowThreads(__tstate);
28382 if (PyErr_Occurred()) SWIG_fail;
28383 }
28384 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28392 PyObject *resultobj = 0;
28393 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28394 wxWindow *result = 0 ;
28395 void *argp1 = 0 ;
28396 int res1 = 0 ;
28397 PyObject *swig_obj[1] ;
28398
28399 if (!args) SWIG_fail;
28400 swig_obj[0] = args;
28401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28402 if (!SWIG_IsOK(res1)) {
28403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28404 }
28405 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 {
28413 resultobj = wxPyMake_wxObject(result, (bool)0);
28414 }
28415 return resultobj;
28416 fail:
28417 return NULL;
28418 }
28419
28420
28421 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28422 PyObject *obj;
28423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28424 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28425 return SWIG_Py_Void();
28426 }
28427
28428 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28429 return SWIG_Python_InitShadowInstance(args);
28430 }
28431
28432 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28433 PyObject *resultobj = 0;
28434 int arg1 = (int) 0 ;
28435 wxMouseCaptureLostEvent *result = 0 ;
28436 int val1 ;
28437 int ecode1 = 0 ;
28438 PyObject * obj0 = 0 ;
28439 char * kwnames[] = {
28440 (char *) "winid", NULL
28441 };
28442
28443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28444 if (obj0) {
28445 ecode1 = SWIG_AsVal_int(obj0, &val1);
28446 if (!SWIG_IsOK(ecode1)) {
28447 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28448 }
28449 arg1 = static_cast< int >(val1);
28450 }
28451 {
28452 PyThreadState* __tstate = wxPyBeginAllowThreads();
28453 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28454 wxPyEndAllowThreads(__tstate);
28455 if (PyErr_Occurred()) SWIG_fail;
28456 }
28457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28458 return resultobj;
28459 fail:
28460 return NULL;
28461 }
28462
28463
28464 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28465 PyObject *obj;
28466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28467 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28468 return SWIG_Py_Void();
28469 }
28470
28471 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28472 return SWIG_Python_InitShadowInstance(args);
28473 }
28474
28475 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28476 PyObject *resultobj = 0;
28477 wxDisplayChangedEvent *result = 0 ;
28478
28479 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28480 {
28481 PyThreadState* __tstate = wxPyBeginAllowThreads();
28482 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28483 wxPyEndAllowThreads(__tstate);
28484 if (PyErr_Occurred()) SWIG_fail;
28485 }
28486 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28487 return resultobj;
28488 fail:
28489 return NULL;
28490 }
28491
28492
28493 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28494 PyObject *obj;
28495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28496 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28497 return SWIG_Py_Void();
28498 }
28499
28500 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28501 return SWIG_Python_InitShadowInstance(args);
28502 }
28503
28504 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj = 0;
28506 int arg1 = (int) 0 ;
28507 wxPaletteChangedEvent *result = 0 ;
28508 int val1 ;
28509 int ecode1 = 0 ;
28510 PyObject * obj0 = 0 ;
28511 char * kwnames[] = {
28512 (char *) "id", NULL
28513 };
28514
28515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28516 if (obj0) {
28517 ecode1 = SWIG_AsVal_int(obj0, &val1);
28518 if (!SWIG_IsOK(ecode1)) {
28519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28520 }
28521 arg1 = static_cast< int >(val1);
28522 }
28523 {
28524 PyThreadState* __tstate = wxPyBeginAllowThreads();
28525 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28526 wxPyEndAllowThreads(__tstate);
28527 if (PyErr_Occurred()) SWIG_fail;
28528 }
28529 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28530 return resultobj;
28531 fail:
28532 return NULL;
28533 }
28534
28535
28536 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28537 PyObject *resultobj = 0;
28538 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28539 wxWindow *arg2 = (wxWindow *) 0 ;
28540 void *argp1 = 0 ;
28541 int res1 = 0 ;
28542 void *argp2 = 0 ;
28543 int res2 = 0 ;
28544 PyObject * obj0 = 0 ;
28545 PyObject * obj1 = 0 ;
28546 char * kwnames[] = {
28547 (char *) "self",(char *) "win", NULL
28548 };
28549
28550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28552 if (!SWIG_IsOK(res1)) {
28553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28554 }
28555 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28556 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28557 if (!SWIG_IsOK(res2)) {
28558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28559 }
28560 arg2 = reinterpret_cast< wxWindow * >(argp2);
28561 {
28562 PyThreadState* __tstate = wxPyBeginAllowThreads();
28563 (arg1)->SetChangedWindow(arg2);
28564 wxPyEndAllowThreads(__tstate);
28565 if (PyErr_Occurred()) SWIG_fail;
28566 }
28567 resultobj = SWIG_Py_Void();
28568 return resultobj;
28569 fail:
28570 return NULL;
28571 }
28572
28573
28574 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28575 PyObject *resultobj = 0;
28576 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28577 wxWindow *result = 0 ;
28578 void *argp1 = 0 ;
28579 int res1 = 0 ;
28580 PyObject *swig_obj[1] ;
28581
28582 if (!args) SWIG_fail;
28583 swig_obj[0] = args;
28584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28585 if (!SWIG_IsOK(res1)) {
28586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28587 }
28588 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28589 {
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 result = (wxWindow *)(arg1)->GetChangedWindow();
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 {
28596 resultobj = wxPyMake_wxObject(result, (bool)0);
28597 }
28598 return resultobj;
28599 fail:
28600 return NULL;
28601 }
28602
28603
28604 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28605 PyObject *obj;
28606 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28607 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28608 return SWIG_Py_Void();
28609 }
28610
28611 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28612 return SWIG_Python_InitShadowInstance(args);
28613 }
28614
28615 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj = 0;
28617 int arg1 = (int) 0 ;
28618 wxQueryNewPaletteEvent *result = 0 ;
28619 int val1 ;
28620 int ecode1 = 0 ;
28621 PyObject * obj0 = 0 ;
28622 char * kwnames[] = {
28623 (char *) "winid", NULL
28624 };
28625
28626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28627 if (obj0) {
28628 ecode1 = SWIG_AsVal_int(obj0, &val1);
28629 if (!SWIG_IsOK(ecode1)) {
28630 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28631 }
28632 arg1 = static_cast< int >(val1);
28633 }
28634 {
28635 PyThreadState* __tstate = wxPyBeginAllowThreads();
28636 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28637 wxPyEndAllowThreads(__tstate);
28638 if (PyErr_Occurred()) SWIG_fail;
28639 }
28640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28641 return resultobj;
28642 fail:
28643 return NULL;
28644 }
28645
28646
28647 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28648 PyObject *resultobj = 0;
28649 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28650 bool arg2 ;
28651 void *argp1 = 0 ;
28652 int res1 = 0 ;
28653 bool val2 ;
28654 int ecode2 = 0 ;
28655 PyObject * obj0 = 0 ;
28656 PyObject * obj1 = 0 ;
28657 char * kwnames[] = {
28658 (char *) "self",(char *) "realized", NULL
28659 };
28660
28661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28663 if (!SWIG_IsOK(res1)) {
28664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28665 }
28666 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28667 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28668 if (!SWIG_IsOK(ecode2)) {
28669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28670 }
28671 arg2 = static_cast< bool >(val2);
28672 {
28673 PyThreadState* __tstate = wxPyBeginAllowThreads();
28674 (arg1)->SetPaletteRealized(arg2);
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 resultobj = SWIG_Py_Void();
28679 return resultobj;
28680 fail:
28681 return NULL;
28682 }
28683
28684
28685 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28686 PyObject *resultobj = 0;
28687 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28688 bool result;
28689 void *argp1 = 0 ;
28690 int res1 = 0 ;
28691 PyObject *swig_obj[1] ;
28692
28693 if (!args) SWIG_fail;
28694 swig_obj[0] = args;
28695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28696 if (!SWIG_IsOK(res1)) {
28697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28698 }
28699 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28700 {
28701 PyThreadState* __tstate = wxPyBeginAllowThreads();
28702 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28703 wxPyEndAllowThreads(__tstate);
28704 if (PyErr_Occurred()) SWIG_fail;
28705 }
28706 {
28707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28708 }
28709 return resultobj;
28710 fail:
28711 return NULL;
28712 }
28713
28714
28715 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28716 PyObject *obj;
28717 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28718 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28719 return SWIG_Py_Void();
28720 }
28721
28722 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28723 return SWIG_Python_InitShadowInstance(args);
28724 }
28725
28726 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28727 PyObject *resultobj = 0;
28728 wxNavigationKeyEvent *result = 0 ;
28729
28730 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28731 {
28732 PyThreadState* __tstate = wxPyBeginAllowThreads();
28733 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28734 wxPyEndAllowThreads(__tstate);
28735 if (PyErr_Occurred()) SWIG_fail;
28736 }
28737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28738 return resultobj;
28739 fail:
28740 return NULL;
28741 }
28742
28743
28744 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28745 PyObject *resultobj = 0;
28746 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28747 bool result;
28748 void *argp1 = 0 ;
28749 int res1 = 0 ;
28750 PyObject *swig_obj[1] ;
28751
28752 if (!args) SWIG_fail;
28753 swig_obj[0] = args;
28754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28755 if (!SWIG_IsOK(res1)) {
28756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28757 }
28758 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28762 wxPyEndAllowThreads(__tstate);
28763 if (PyErr_Occurred()) SWIG_fail;
28764 }
28765 {
28766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28767 }
28768 return resultobj;
28769 fail:
28770 return NULL;
28771 }
28772
28773
28774 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28775 PyObject *resultobj = 0;
28776 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28777 bool arg2 ;
28778 void *argp1 = 0 ;
28779 int res1 = 0 ;
28780 bool val2 ;
28781 int ecode2 = 0 ;
28782 PyObject * obj0 = 0 ;
28783 PyObject * obj1 = 0 ;
28784 char * kwnames[] = {
28785 (char *) "self",(char *) "forward", NULL
28786 };
28787
28788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28790 if (!SWIG_IsOK(res1)) {
28791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28792 }
28793 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28794 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28795 if (!SWIG_IsOK(ecode2)) {
28796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28797 }
28798 arg2 = static_cast< bool >(val2);
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 (arg1)->SetDirection(arg2);
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 resultobj = SWIG_Py_Void();
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28813 PyObject *resultobj = 0;
28814 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28815 bool result;
28816 void *argp1 = 0 ;
28817 int res1 = 0 ;
28818 PyObject *swig_obj[1] ;
28819
28820 if (!args) SWIG_fail;
28821 swig_obj[0] = args;
28822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28823 if (!SWIG_IsOK(res1)) {
28824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28825 }
28826 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28827 {
28828 PyThreadState* __tstate = wxPyBeginAllowThreads();
28829 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28830 wxPyEndAllowThreads(__tstate);
28831 if (PyErr_Occurred()) SWIG_fail;
28832 }
28833 {
28834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28835 }
28836 return resultobj;
28837 fail:
28838 return NULL;
28839 }
28840
28841
28842 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28843 PyObject *resultobj = 0;
28844 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28845 bool arg2 ;
28846 void *argp1 = 0 ;
28847 int res1 = 0 ;
28848 bool val2 ;
28849 int ecode2 = 0 ;
28850 PyObject * obj0 = 0 ;
28851 PyObject * obj1 = 0 ;
28852 char * kwnames[] = {
28853 (char *) "self",(char *) "ischange", NULL
28854 };
28855
28856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28858 if (!SWIG_IsOK(res1)) {
28859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28860 }
28861 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28862 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28863 if (!SWIG_IsOK(ecode2)) {
28864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28865 }
28866 arg2 = static_cast< bool >(val2);
28867 {
28868 PyThreadState* __tstate = wxPyBeginAllowThreads();
28869 (arg1)->SetWindowChange(arg2);
28870 wxPyEndAllowThreads(__tstate);
28871 if (PyErr_Occurred()) SWIG_fail;
28872 }
28873 resultobj = SWIG_Py_Void();
28874 return resultobj;
28875 fail:
28876 return NULL;
28877 }
28878
28879
28880 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28881 PyObject *resultobj = 0;
28882 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28883 bool result;
28884 void *argp1 = 0 ;
28885 int res1 = 0 ;
28886 PyObject *swig_obj[1] ;
28887
28888 if (!args) SWIG_fail;
28889 swig_obj[0] = args;
28890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28891 if (!SWIG_IsOK(res1)) {
28892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28893 }
28894 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28895 {
28896 PyThreadState* __tstate = wxPyBeginAllowThreads();
28897 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28898 wxPyEndAllowThreads(__tstate);
28899 if (PyErr_Occurred()) SWIG_fail;
28900 }
28901 {
28902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28903 }
28904 return resultobj;
28905 fail:
28906 return NULL;
28907 }
28908
28909
28910 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28911 PyObject *resultobj = 0;
28912 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28913 bool arg2 ;
28914 void *argp1 = 0 ;
28915 int res1 = 0 ;
28916 bool val2 ;
28917 int ecode2 = 0 ;
28918 PyObject * obj0 = 0 ;
28919 PyObject * obj1 = 0 ;
28920 char * kwnames[] = {
28921 (char *) "self",(char *) "bIs", NULL
28922 };
28923
28924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28926 if (!SWIG_IsOK(res1)) {
28927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28928 }
28929 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28930 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28931 if (!SWIG_IsOK(ecode2)) {
28932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28933 }
28934 arg2 = static_cast< bool >(val2);
28935 {
28936 PyThreadState* __tstate = wxPyBeginAllowThreads();
28937 (arg1)->SetFromTab(arg2);
28938 wxPyEndAllowThreads(__tstate);
28939 if (PyErr_Occurred()) SWIG_fail;
28940 }
28941 resultobj = SWIG_Py_Void();
28942 return resultobj;
28943 fail:
28944 return NULL;
28945 }
28946
28947
28948 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28949 PyObject *resultobj = 0;
28950 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28951 long arg2 ;
28952 void *argp1 = 0 ;
28953 int res1 = 0 ;
28954 long val2 ;
28955 int ecode2 = 0 ;
28956 PyObject * obj0 = 0 ;
28957 PyObject * obj1 = 0 ;
28958 char * kwnames[] = {
28959 (char *) "self",(char *) "flags", NULL
28960 };
28961
28962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28964 if (!SWIG_IsOK(res1)) {
28965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28966 }
28967 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28968 ecode2 = SWIG_AsVal_long(obj1, &val2);
28969 if (!SWIG_IsOK(ecode2)) {
28970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28971 }
28972 arg2 = static_cast< long >(val2);
28973 {
28974 PyThreadState* __tstate = wxPyBeginAllowThreads();
28975 (arg1)->SetFlags(arg2);
28976 wxPyEndAllowThreads(__tstate);
28977 if (PyErr_Occurred()) SWIG_fail;
28978 }
28979 resultobj = SWIG_Py_Void();
28980 return resultobj;
28981 fail:
28982 return NULL;
28983 }
28984
28985
28986 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28987 PyObject *resultobj = 0;
28988 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28989 wxWindow *result = 0 ;
28990 void *argp1 = 0 ;
28991 int res1 = 0 ;
28992 PyObject *swig_obj[1] ;
28993
28994 if (!args) SWIG_fail;
28995 swig_obj[0] = args;
28996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28997 if (!SWIG_IsOK(res1)) {
28998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28999 }
29000 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29001 {
29002 PyThreadState* __tstate = wxPyBeginAllowThreads();
29003 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
29004 wxPyEndAllowThreads(__tstate);
29005 if (PyErr_Occurred()) SWIG_fail;
29006 }
29007 {
29008 resultobj = wxPyMake_wxObject(result, (bool)0);
29009 }
29010 return resultobj;
29011 fail:
29012 return NULL;
29013 }
29014
29015
29016 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29017 PyObject *resultobj = 0;
29018 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
29019 wxWindow *arg2 = (wxWindow *) 0 ;
29020 void *argp1 = 0 ;
29021 int res1 = 0 ;
29022 void *argp2 = 0 ;
29023 int res2 = 0 ;
29024 PyObject * obj0 = 0 ;
29025 PyObject * obj1 = 0 ;
29026 char * kwnames[] = {
29027 (char *) "self",(char *) "win", NULL
29028 };
29029
29030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
29031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
29032 if (!SWIG_IsOK(res1)) {
29033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
29034 }
29035 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
29036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29037 if (!SWIG_IsOK(res2)) {
29038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
29039 }
29040 arg2 = reinterpret_cast< wxWindow * >(argp2);
29041 {
29042 PyThreadState* __tstate = wxPyBeginAllowThreads();
29043 (arg1)->SetCurrentFocus(arg2);
29044 wxPyEndAllowThreads(__tstate);
29045 if (PyErr_Occurred()) SWIG_fail;
29046 }
29047 resultobj = SWIG_Py_Void();
29048 return resultobj;
29049 fail:
29050 return NULL;
29051 }
29052
29053
29054 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29055 PyObject *obj;
29056 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29057 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
29058 return SWIG_Py_Void();
29059 }
29060
29061 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29062 return SWIG_Python_InitShadowInstance(args);
29063 }
29064
29065 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29066 PyObject *resultobj = 0;
29067 wxWindow *arg1 = (wxWindow *) NULL ;
29068 wxWindowCreateEvent *result = 0 ;
29069 void *argp1 = 0 ;
29070 int res1 = 0 ;
29071 PyObject * obj0 = 0 ;
29072 char * kwnames[] = {
29073 (char *) "win", NULL
29074 };
29075
29076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29077 if (obj0) {
29078 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29079 if (!SWIG_IsOK(res1)) {
29080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29081 }
29082 arg1 = reinterpret_cast< wxWindow * >(argp1);
29083 }
29084 {
29085 PyThreadState* __tstate = wxPyBeginAllowThreads();
29086 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29087 wxPyEndAllowThreads(__tstate);
29088 if (PyErr_Occurred()) SWIG_fail;
29089 }
29090 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29098 PyObject *resultobj = 0;
29099 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29100 wxWindow *result = 0 ;
29101 void *argp1 = 0 ;
29102 int res1 = 0 ;
29103 PyObject *swig_obj[1] ;
29104
29105 if (!args) SWIG_fail;
29106 swig_obj[0] = args;
29107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29108 if (!SWIG_IsOK(res1)) {
29109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29110 }
29111 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29112 {
29113 PyThreadState* __tstate = wxPyBeginAllowThreads();
29114 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29115 wxPyEndAllowThreads(__tstate);
29116 if (PyErr_Occurred()) SWIG_fail;
29117 }
29118 {
29119 resultobj = wxPyMake_wxObject(result, (bool)0);
29120 }
29121 return resultobj;
29122 fail:
29123 return NULL;
29124 }
29125
29126
29127 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29128 PyObject *obj;
29129 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29130 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29131 return SWIG_Py_Void();
29132 }
29133
29134 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29135 return SWIG_Python_InitShadowInstance(args);
29136 }
29137
29138 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29139 PyObject *resultobj = 0;
29140 wxWindow *arg1 = (wxWindow *) NULL ;
29141 wxWindowDestroyEvent *result = 0 ;
29142 void *argp1 = 0 ;
29143 int res1 = 0 ;
29144 PyObject * obj0 = 0 ;
29145 char * kwnames[] = {
29146 (char *) "win", NULL
29147 };
29148
29149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29150 if (obj0) {
29151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29152 if (!SWIG_IsOK(res1)) {
29153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29154 }
29155 arg1 = reinterpret_cast< wxWindow * >(argp1);
29156 }
29157 {
29158 PyThreadState* __tstate = wxPyBeginAllowThreads();
29159 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29160 wxPyEndAllowThreads(__tstate);
29161 if (PyErr_Occurred()) SWIG_fail;
29162 }
29163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29164 return resultobj;
29165 fail:
29166 return NULL;
29167 }
29168
29169
29170 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29171 PyObject *resultobj = 0;
29172 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29173 wxWindow *result = 0 ;
29174 void *argp1 = 0 ;
29175 int res1 = 0 ;
29176 PyObject *swig_obj[1] ;
29177
29178 if (!args) SWIG_fail;
29179 swig_obj[0] = args;
29180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29181 if (!SWIG_IsOK(res1)) {
29182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29183 }
29184 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29185 {
29186 PyThreadState* __tstate = wxPyBeginAllowThreads();
29187 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29188 wxPyEndAllowThreads(__tstate);
29189 if (PyErr_Occurred()) SWIG_fail;
29190 }
29191 {
29192 resultobj = wxPyMake_wxObject(result, (bool)0);
29193 }
29194 return resultobj;
29195 fail:
29196 return NULL;
29197 }
29198
29199
29200 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29201 PyObject *obj;
29202 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29203 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29204 return SWIG_Py_Void();
29205 }
29206
29207 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29208 return SWIG_Python_InitShadowInstance(args);
29209 }
29210
29211 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj = 0;
29213 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29214 int arg2 = (int) 0 ;
29215 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29216 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29217 wxContextMenuEvent *result = 0 ;
29218 int val1 ;
29219 int ecode1 = 0 ;
29220 int val2 ;
29221 int ecode2 = 0 ;
29222 wxPoint temp3 ;
29223 PyObject * obj0 = 0 ;
29224 PyObject * obj1 = 0 ;
29225 PyObject * obj2 = 0 ;
29226 char * kwnames[] = {
29227 (char *) "type",(char *) "winid",(char *) "pt", NULL
29228 };
29229
29230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29231 if (obj0) {
29232 ecode1 = SWIG_AsVal_int(obj0, &val1);
29233 if (!SWIG_IsOK(ecode1)) {
29234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29235 }
29236 arg1 = static_cast< wxEventType >(val1);
29237 }
29238 if (obj1) {
29239 ecode2 = SWIG_AsVal_int(obj1, &val2);
29240 if (!SWIG_IsOK(ecode2)) {
29241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29242 }
29243 arg2 = static_cast< int >(val2);
29244 }
29245 if (obj2) {
29246 {
29247 arg3 = &temp3;
29248 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29249 }
29250 }
29251 {
29252 PyThreadState* __tstate = wxPyBeginAllowThreads();
29253 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29254 wxPyEndAllowThreads(__tstate);
29255 if (PyErr_Occurred()) SWIG_fail;
29256 }
29257 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29258 return resultobj;
29259 fail:
29260 return NULL;
29261 }
29262
29263
29264 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29265 PyObject *resultobj = 0;
29266 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29267 wxPoint *result = 0 ;
29268 void *argp1 = 0 ;
29269 int res1 = 0 ;
29270 PyObject *swig_obj[1] ;
29271
29272 if (!args) SWIG_fail;
29273 swig_obj[0] = args;
29274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29275 if (!SWIG_IsOK(res1)) {
29276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29277 }
29278 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29279 {
29280 PyThreadState* __tstate = wxPyBeginAllowThreads();
29281 {
29282 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29283 result = (wxPoint *) &_result_ref;
29284 }
29285 wxPyEndAllowThreads(__tstate);
29286 if (PyErr_Occurred()) SWIG_fail;
29287 }
29288 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29289 return resultobj;
29290 fail:
29291 return NULL;
29292 }
29293
29294
29295 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29296 PyObject *resultobj = 0;
29297 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29298 wxPoint *arg2 = 0 ;
29299 void *argp1 = 0 ;
29300 int res1 = 0 ;
29301 wxPoint temp2 ;
29302 PyObject * obj0 = 0 ;
29303 PyObject * obj1 = 0 ;
29304 char * kwnames[] = {
29305 (char *) "self",(char *) "pos", NULL
29306 };
29307
29308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29310 if (!SWIG_IsOK(res1)) {
29311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29312 }
29313 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29314 {
29315 arg2 = &temp2;
29316 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29317 }
29318 {
29319 PyThreadState* __tstate = wxPyBeginAllowThreads();
29320 (arg1)->SetPosition((wxPoint const &)*arg2);
29321 wxPyEndAllowThreads(__tstate);
29322 if (PyErr_Occurred()) SWIG_fail;
29323 }
29324 resultobj = SWIG_Py_Void();
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29332 PyObject *obj;
29333 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29334 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29335 return SWIG_Py_Void();
29336 }
29337
29338 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29339 return SWIG_Python_InitShadowInstance(args);
29340 }
29341
29342 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29343 PyObject *resultobj = 0;
29344 wxIdleEvent *result = 0 ;
29345
29346 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29347 {
29348 PyThreadState* __tstate = wxPyBeginAllowThreads();
29349 result = (wxIdleEvent *)new wxIdleEvent();
29350 wxPyEndAllowThreads(__tstate);
29351 if (PyErr_Occurred()) SWIG_fail;
29352 }
29353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29354 return resultobj;
29355 fail:
29356 return NULL;
29357 }
29358
29359
29360 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29361 PyObject *resultobj = 0;
29362 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29363 bool arg2 = (bool) true ;
29364 void *argp1 = 0 ;
29365 int res1 = 0 ;
29366 bool val2 ;
29367 int ecode2 = 0 ;
29368 PyObject * obj0 = 0 ;
29369 PyObject * obj1 = 0 ;
29370 char * kwnames[] = {
29371 (char *) "self",(char *) "needMore", NULL
29372 };
29373
29374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29376 if (!SWIG_IsOK(res1)) {
29377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29378 }
29379 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29380 if (obj1) {
29381 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29382 if (!SWIG_IsOK(ecode2)) {
29383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29384 }
29385 arg2 = static_cast< bool >(val2);
29386 }
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 (arg1)->RequestMore(arg2);
29390 wxPyEndAllowThreads(__tstate);
29391 if (PyErr_Occurred()) SWIG_fail;
29392 }
29393 resultobj = SWIG_Py_Void();
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29403 bool result;
29404 void *argp1 = 0 ;
29405 int res1 = 0 ;
29406 PyObject *swig_obj[1] ;
29407
29408 if (!args) SWIG_fail;
29409 swig_obj[0] = args;
29410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29411 if (!SWIG_IsOK(res1)) {
29412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29413 }
29414 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29415 {
29416 PyThreadState* __tstate = wxPyBeginAllowThreads();
29417 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29418 wxPyEndAllowThreads(__tstate);
29419 if (PyErr_Occurred()) SWIG_fail;
29420 }
29421 {
29422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29423 }
29424 return resultobj;
29425 fail:
29426 return NULL;
29427 }
29428
29429
29430 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29431 PyObject *resultobj = 0;
29432 wxIdleMode arg1 ;
29433 int val1 ;
29434 int ecode1 = 0 ;
29435 PyObject * obj0 = 0 ;
29436 char * kwnames[] = {
29437 (char *) "mode", NULL
29438 };
29439
29440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29441 ecode1 = SWIG_AsVal_int(obj0, &val1);
29442 if (!SWIG_IsOK(ecode1)) {
29443 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29444 }
29445 arg1 = static_cast< wxIdleMode >(val1);
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 wxIdleEvent::SetMode(arg1);
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 resultobj = SWIG_Py_Void();
29453 return resultobj;
29454 fail:
29455 return NULL;
29456 }
29457
29458
29459 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29460 PyObject *resultobj = 0;
29461 wxIdleMode result;
29462
29463 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29464 {
29465 PyThreadState* __tstate = wxPyBeginAllowThreads();
29466 result = (wxIdleMode)wxIdleEvent::GetMode();
29467 wxPyEndAllowThreads(__tstate);
29468 if (PyErr_Occurred()) SWIG_fail;
29469 }
29470 resultobj = SWIG_From_int(static_cast< int >(result));
29471 return resultobj;
29472 fail:
29473 return NULL;
29474 }
29475
29476
29477 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29478 PyObject *resultobj = 0;
29479 wxWindow *arg1 = (wxWindow *) 0 ;
29480 bool result;
29481 void *argp1 = 0 ;
29482 int res1 = 0 ;
29483 PyObject * obj0 = 0 ;
29484 char * kwnames[] = {
29485 (char *) "win", NULL
29486 };
29487
29488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29490 if (!SWIG_IsOK(res1)) {
29491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29492 }
29493 arg1 = reinterpret_cast< wxWindow * >(argp1);
29494 {
29495 PyThreadState* __tstate = wxPyBeginAllowThreads();
29496 result = (bool)wxIdleEvent::CanSend(arg1);
29497 wxPyEndAllowThreads(__tstate);
29498 if (PyErr_Occurred()) SWIG_fail;
29499 }
29500 {
29501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29502 }
29503 return resultobj;
29504 fail:
29505 return NULL;
29506 }
29507
29508
29509 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29510 PyObject *obj;
29511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29512 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29513 return SWIG_Py_Void();
29514 }
29515
29516 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29517 return SWIG_Python_InitShadowInstance(args);
29518 }
29519
29520 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29521 PyObject *resultobj = 0;
29522 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29523 int arg2 = (int) 0 ;
29524 wxClipboardTextEvent *result = 0 ;
29525 int val1 ;
29526 int ecode1 = 0 ;
29527 int val2 ;
29528 int ecode2 = 0 ;
29529 PyObject * obj0 = 0 ;
29530 PyObject * obj1 = 0 ;
29531 char * kwnames[] = {
29532 (char *) "type",(char *) "winid", NULL
29533 };
29534
29535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29536 if (obj0) {
29537 ecode1 = SWIG_AsVal_int(obj0, &val1);
29538 if (!SWIG_IsOK(ecode1)) {
29539 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29540 }
29541 arg1 = static_cast< wxEventType >(val1);
29542 }
29543 if (obj1) {
29544 ecode2 = SWIG_AsVal_int(obj1, &val2);
29545 if (!SWIG_IsOK(ecode2)) {
29546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29547 }
29548 arg2 = static_cast< int >(val2);
29549 }
29550 {
29551 PyThreadState* __tstate = wxPyBeginAllowThreads();
29552 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29553 wxPyEndAllowThreads(__tstate);
29554 if (PyErr_Occurred()) SWIG_fail;
29555 }
29556 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29557 return resultobj;
29558 fail:
29559 return NULL;
29560 }
29561
29562
29563 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29564 PyObject *obj;
29565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29566 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29567 return SWIG_Py_Void();
29568 }
29569
29570 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29571 return SWIG_Python_InitShadowInstance(args);
29572 }
29573
29574 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29575 PyObject *resultobj = 0;
29576 int arg1 = (int) 0 ;
29577 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29578 wxPyEvent *result = 0 ;
29579 int val1 ;
29580 int ecode1 = 0 ;
29581 int val2 ;
29582 int ecode2 = 0 ;
29583 PyObject * obj0 = 0 ;
29584 PyObject * obj1 = 0 ;
29585 char * kwnames[] = {
29586 (char *) "winid",(char *) "eventType", NULL
29587 };
29588
29589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29590 if (obj0) {
29591 ecode1 = SWIG_AsVal_int(obj0, &val1);
29592 if (!SWIG_IsOK(ecode1)) {
29593 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29594 }
29595 arg1 = static_cast< int >(val1);
29596 }
29597 if (obj1) {
29598 ecode2 = SWIG_AsVal_int(obj1, &val2);
29599 if (!SWIG_IsOK(ecode2)) {
29600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29601 }
29602 arg2 = static_cast< wxEventType >(val2);
29603 }
29604 {
29605 PyThreadState* __tstate = wxPyBeginAllowThreads();
29606 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29607 wxPyEndAllowThreads(__tstate);
29608 if (PyErr_Occurred()) SWIG_fail;
29609 }
29610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29611 return resultobj;
29612 fail:
29613 return NULL;
29614 }
29615
29616
29617 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29618 PyObject *resultobj = 0;
29619 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29620 void *argp1 = 0 ;
29621 int res1 = 0 ;
29622 PyObject *swig_obj[1] ;
29623
29624 if (!args) SWIG_fail;
29625 swig_obj[0] = args;
29626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29627 if (!SWIG_IsOK(res1)) {
29628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29629 }
29630 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29631 {
29632 PyThreadState* __tstate = wxPyBeginAllowThreads();
29633 delete arg1;
29634
29635 wxPyEndAllowThreads(__tstate);
29636 if (PyErr_Occurred()) SWIG_fail;
29637 }
29638 resultobj = SWIG_Py_Void();
29639 return resultobj;
29640 fail:
29641 return NULL;
29642 }
29643
29644
29645 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29646 PyObject *resultobj = 0;
29647 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29648 PyObject *arg2 = (PyObject *) 0 ;
29649 void *argp1 = 0 ;
29650 int res1 = 0 ;
29651 PyObject * obj0 = 0 ;
29652 PyObject * obj1 = 0 ;
29653 char * kwnames[] = {
29654 (char *) "self",(char *) "self", NULL
29655 };
29656
29657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29659 if (!SWIG_IsOK(res1)) {
29660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29661 }
29662 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29663 arg2 = obj1;
29664 {
29665 PyThreadState* __tstate = wxPyBeginAllowThreads();
29666 (arg1)->SetSelf(arg2);
29667 wxPyEndAllowThreads(__tstate);
29668 if (PyErr_Occurred()) SWIG_fail;
29669 }
29670 resultobj = SWIG_Py_Void();
29671 return resultobj;
29672 fail:
29673 return NULL;
29674 }
29675
29676
29677 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29678 PyObject *resultobj = 0;
29679 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29680 PyObject *result = 0 ;
29681 void *argp1 = 0 ;
29682 int res1 = 0 ;
29683 PyObject *swig_obj[1] ;
29684
29685 if (!args) SWIG_fail;
29686 swig_obj[0] = args;
29687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29688 if (!SWIG_IsOK(res1)) {
29689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29690 }
29691 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29692 {
29693 PyThreadState* __tstate = wxPyBeginAllowThreads();
29694 result = (PyObject *)(arg1)->GetSelf();
29695 wxPyEndAllowThreads(__tstate);
29696 if (PyErr_Occurred()) SWIG_fail;
29697 }
29698 resultobj = result;
29699 return resultobj;
29700 fail:
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 PyObject *obj;
29707 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29708 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29709 return SWIG_Py_Void();
29710 }
29711
29712 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29713 return SWIG_Python_InitShadowInstance(args);
29714 }
29715
29716 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29717 PyObject *resultobj = 0;
29718 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29719 int arg2 = (int) 0 ;
29720 wxPyCommandEvent *result = 0 ;
29721 int val1 ;
29722 int ecode1 = 0 ;
29723 int val2 ;
29724 int ecode2 = 0 ;
29725 PyObject * obj0 = 0 ;
29726 PyObject * obj1 = 0 ;
29727 char * kwnames[] = {
29728 (char *) "eventType",(char *) "id", NULL
29729 };
29730
29731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29732 if (obj0) {
29733 ecode1 = SWIG_AsVal_int(obj0, &val1);
29734 if (!SWIG_IsOK(ecode1)) {
29735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29736 }
29737 arg1 = static_cast< wxEventType >(val1);
29738 }
29739 if (obj1) {
29740 ecode2 = SWIG_AsVal_int(obj1, &val2);
29741 if (!SWIG_IsOK(ecode2)) {
29742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29743 }
29744 arg2 = static_cast< int >(val2);
29745 }
29746 {
29747 PyThreadState* __tstate = wxPyBeginAllowThreads();
29748 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29749 wxPyEndAllowThreads(__tstate);
29750 if (PyErr_Occurred()) SWIG_fail;
29751 }
29752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29753 return resultobj;
29754 fail:
29755 return NULL;
29756 }
29757
29758
29759 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29760 PyObject *resultobj = 0;
29761 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29762 void *argp1 = 0 ;
29763 int res1 = 0 ;
29764 PyObject *swig_obj[1] ;
29765
29766 if (!args) SWIG_fail;
29767 swig_obj[0] = args;
29768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29769 if (!SWIG_IsOK(res1)) {
29770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29771 }
29772 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29773 {
29774 PyThreadState* __tstate = wxPyBeginAllowThreads();
29775 delete arg1;
29776
29777 wxPyEndAllowThreads(__tstate);
29778 if (PyErr_Occurred()) SWIG_fail;
29779 }
29780 resultobj = SWIG_Py_Void();
29781 return resultobj;
29782 fail:
29783 return NULL;
29784 }
29785
29786
29787 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29788 PyObject *resultobj = 0;
29789 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29790 PyObject *arg2 = (PyObject *) 0 ;
29791 void *argp1 = 0 ;
29792 int res1 = 0 ;
29793 PyObject * obj0 = 0 ;
29794 PyObject * obj1 = 0 ;
29795 char * kwnames[] = {
29796 (char *) "self",(char *) "self", NULL
29797 };
29798
29799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29801 if (!SWIG_IsOK(res1)) {
29802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29803 }
29804 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29805 arg2 = obj1;
29806 {
29807 PyThreadState* __tstate = wxPyBeginAllowThreads();
29808 (arg1)->SetSelf(arg2);
29809 wxPyEndAllowThreads(__tstate);
29810 if (PyErr_Occurred()) SWIG_fail;
29811 }
29812 resultobj = SWIG_Py_Void();
29813 return resultobj;
29814 fail:
29815 return NULL;
29816 }
29817
29818
29819 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29820 PyObject *resultobj = 0;
29821 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29822 PyObject *result = 0 ;
29823 void *argp1 = 0 ;
29824 int res1 = 0 ;
29825 PyObject *swig_obj[1] ;
29826
29827 if (!args) SWIG_fail;
29828 swig_obj[0] = args;
29829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29830 if (!SWIG_IsOK(res1)) {
29831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29832 }
29833 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29834 {
29835 PyThreadState* __tstate = wxPyBeginAllowThreads();
29836 result = (PyObject *)(arg1)->GetSelf();
29837 wxPyEndAllowThreads(__tstate);
29838 if (PyErr_Occurred()) SWIG_fail;
29839 }
29840 resultobj = result;
29841 return resultobj;
29842 fail:
29843 return NULL;
29844 }
29845
29846
29847 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29848 PyObject *obj;
29849 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29850 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29851 return SWIG_Py_Void();
29852 }
29853
29854 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29855 return SWIG_Python_InitShadowInstance(args);
29856 }
29857
29858 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29859 PyObject *resultobj = 0;
29860 wxWindow *arg1 = (wxWindow *) 0 ;
29861 wxDateTime *arg2 = 0 ;
29862 wxEventType arg3 ;
29863 wxDateEvent *result = 0 ;
29864 void *argp1 = 0 ;
29865 int res1 = 0 ;
29866 void *argp2 = 0 ;
29867 int res2 = 0 ;
29868 int val3 ;
29869 int ecode3 = 0 ;
29870 PyObject * obj0 = 0 ;
29871 PyObject * obj1 = 0 ;
29872 PyObject * obj2 = 0 ;
29873 char * kwnames[] = {
29874 (char *) "win",(char *) "dt",(char *) "type", NULL
29875 };
29876
29877 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29878 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29879 if (!SWIG_IsOK(res1)) {
29880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29881 }
29882 arg1 = reinterpret_cast< wxWindow * >(argp1);
29883 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29884 if (!SWIG_IsOK(res2)) {
29885 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29886 }
29887 if (!argp2) {
29888 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29889 }
29890 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29891 ecode3 = SWIG_AsVal_int(obj2, &val3);
29892 if (!SWIG_IsOK(ecode3)) {
29893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29894 }
29895 arg3 = static_cast< wxEventType >(val3);
29896 {
29897 PyThreadState* __tstate = wxPyBeginAllowThreads();
29898 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29899 wxPyEndAllowThreads(__tstate);
29900 if (PyErr_Occurred()) SWIG_fail;
29901 }
29902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29903 return resultobj;
29904 fail:
29905 return NULL;
29906 }
29907
29908
29909 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29910 PyObject *resultobj = 0;
29911 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29912 wxDateTime *result = 0 ;
29913 void *argp1 = 0 ;
29914 int res1 = 0 ;
29915 PyObject *swig_obj[1] ;
29916
29917 if (!args) SWIG_fail;
29918 swig_obj[0] = args;
29919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29920 if (!SWIG_IsOK(res1)) {
29921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29922 }
29923 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 {
29927 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29928 result = (wxDateTime *) &_result_ref;
29929 }
29930 wxPyEndAllowThreads(__tstate);
29931 if (PyErr_Occurred()) SWIG_fail;
29932 }
29933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29934 return resultobj;
29935 fail:
29936 return NULL;
29937 }
29938
29939
29940 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29941 PyObject *resultobj = 0;
29942 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29943 wxDateTime *arg2 = 0 ;
29944 void *argp1 = 0 ;
29945 int res1 = 0 ;
29946 void *argp2 = 0 ;
29947 int res2 = 0 ;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 char * kwnames[] = {
29951 (char *) "self",(char *) "date", NULL
29952 };
29953
29954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29956 if (!SWIG_IsOK(res1)) {
29957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29958 }
29959 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29960 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29961 if (!SWIG_IsOK(res2)) {
29962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29963 }
29964 if (!argp2) {
29965 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29966 }
29967 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29968 {
29969 PyThreadState* __tstate = wxPyBeginAllowThreads();
29970 (arg1)->SetDate((wxDateTime const &)*arg2);
29971 wxPyEndAllowThreads(__tstate);
29972 if (PyErr_Occurred()) SWIG_fail;
29973 }
29974 resultobj = SWIG_Py_Void();
29975 return resultobj;
29976 fail:
29977 return NULL;
29978 }
29979
29980
29981 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29982 PyObject *obj;
29983 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29984 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29985 return SWIG_Py_Void();
29986 }
29987
29988 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29989 return SWIG_Python_InitShadowInstance(args);
29990 }
29991
29992 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29993 PyObject *resultobj = 0;
29994 wxPyApp *result = 0 ;
29995
29996 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29997 {
29998 PyThreadState* __tstate = wxPyBeginAllowThreads();
29999 result = (wxPyApp *)new_wxPyApp();
30000 wxPyEndAllowThreads(__tstate);
30001 if (PyErr_Occurred()) SWIG_fail;
30002 }
30003 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30004 return resultobj;
30005 fail:
30006 return NULL;
30007 }
30008
30009
30010 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30011 PyObject *resultobj = 0;
30012 wxPyApp *arg1 = (wxPyApp *) 0 ;
30013 void *argp1 = 0 ;
30014 int res1 = 0 ;
30015 PyObject *swig_obj[1] ;
30016
30017 if (!args) SWIG_fail;
30018 swig_obj[0] = args;
30019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30020 if (!SWIG_IsOK(res1)) {
30021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30022 }
30023 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30024 {
30025 PyThreadState* __tstate = wxPyBeginAllowThreads();
30026 delete arg1;
30027
30028 wxPyEndAllowThreads(__tstate);
30029 if (PyErr_Occurred()) SWIG_fail;
30030 }
30031 resultobj = SWIG_Py_Void();
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30039 PyObject *resultobj = 0;
30040 wxPyApp *arg1 = (wxPyApp *) 0 ;
30041 PyObject *arg2 = (PyObject *) 0 ;
30042 PyObject *arg3 = (PyObject *) 0 ;
30043 bool arg4 ;
30044 void *argp1 = 0 ;
30045 int res1 = 0 ;
30046 bool val4 ;
30047 int ecode4 = 0 ;
30048 PyObject * obj0 = 0 ;
30049 PyObject * obj1 = 0 ;
30050 PyObject * obj2 = 0 ;
30051 PyObject * obj3 = 0 ;
30052 char * kwnames[] = {
30053 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30054 };
30055
30056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30058 if (!SWIG_IsOK(res1)) {
30059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30060 }
30061 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30062 arg2 = obj1;
30063 arg3 = obj2;
30064 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30065 if (!SWIG_IsOK(ecode4)) {
30066 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30067 }
30068 arg4 = static_cast< bool >(val4);
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 resultobj = SWIG_Py_Void();
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30083 PyObject *resultobj = 0;
30084 wxPyApp *arg1 = (wxPyApp *) 0 ;
30085 wxString result;
30086 void *argp1 = 0 ;
30087 int res1 = 0 ;
30088 PyObject *swig_obj[1] ;
30089
30090 if (!args) SWIG_fail;
30091 swig_obj[0] = args;
30092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30093 if (!SWIG_IsOK(res1)) {
30094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30095 }
30096 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30097 {
30098 PyThreadState* __tstate = wxPyBeginAllowThreads();
30099 result = ((wxPyApp const *)arg1)->GetAppName();
30100 wxPyEndAllowThreads(__tstate);
30101 if (PyErr_Occurred()) SWIG_fail;
30102 }
30103 {
30104 #if wxUSE_UNICODE
30105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30106 #else
30107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30108 #endif
30109 }
30110 return resultobj;
30111 fail:
30112 return NULL;
30113 }
30114
30115
30116 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30117 PyObject *resultobj = 0;
30118 wxPyApp *arg1 = (wxPyApp *) 0 ;
30119 wxString *arg2 = 0 ;
30120 void *argp1 = 0 ;
30121 int res1 = 0 ;
30122 bool temp2 = false ;
30123 PyObject * obj0 = 0 ;
30124 PyObject * obj1 = 0 ;
30125 char * kwnames[] = {
30126 (char *) "self",(char *) "name", NULL
30127 };
30128
30129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30131 if (!SWIG_IsOK(res1)) {
30132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30133 }
30134 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30135 {
30136 arg2 = wxString_in_helper(obj1);
30137 if (arg2 == NULL) SWIG_fail;
30138 temp2 = true;
30139 }
30140 {
30141 PyThreadState* __tstate = wxPyBeginAllowThreads();
30142 (arg1)->SetAppName((wxString const &)*arg2);
30143 wxPyEndAllowThreads(__tstate);
30144 if (PyErr_Occurred()) SWIG_fail;
30145 }
30146 resultobj = SWIG_Py_Void();
30147 {
30148 if (temp2)
30149 delete arg2;
30150 }
30151 return resultobj;
30152 fail:
30153 {
30154 if (temp2)
30155 delete arg2;
30156 }
30157 return NULL;
30158 }
30159
30160
30161 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30162 PyObject *resultobj = 0;
30163 wxPyApp *arg1 = (wxPyApp *) 0 ;
30164 wxString result;
30165 void *argp1 = 0 ;
30166 int res1 = 0 ;
30167 PyObject *swig_obj[1] ;
30168
30169 if (!args) SWIG_fail;
30170 swig_obj[0] = args;
30171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30172 if (!SWIG_IsOK(res1)) {
30173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30174 }
30175 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30176 {
30177 PyThreadState* __tstate = wxPyBeginAllowThreads();
30178 result = ((wxPyApp const *)arg1)->GetClassName();
30179 wxPyEndAllowThreads(__tstate);
30180 if (PyErr_Occurred()) SWIG_fail;
30181 }
30182 {
30183 #if wxUSE_UNICODE
30184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30185 #else
30186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30187 #endif
30188 }
30189 return resultobj;
30190 fail:
30191 return NULL;
30192 }
30193
30194
30195 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30196 PyObject *resultobj = 0;
30197 wxPyApp *arg1 = (wxPyApp *) 0 ;
30198 wxString *arg2 = 0 ;
30199 void *argp1 = 0 ;
30200 int res1 = 0 ;
30201 bool temp2 = false ;
30202 PyObject * obj0 = 0 ;
30203 PyObject * obj1 = 0 ;
30204 char * kwnames[] = {
30205 (char *) "self",(char *) "name", NULL
30206 };
30207
30208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30210 if (!SWIG_IsOK(res1)) {
30211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30212 }
30213 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30214 {
30215 arg2 = wxString_in_helper(obj1);
30216 if (arg2 == NULL) SWIG_fail;
30217 temp2 = true;
30218 }
30219 {
30220 PyThreadState* __tstate = wxPyBeginAllowThreads();
30221 (arg1)->SetClassName((wxString const &)*arg2);
30222 wxPyEndAllowThreads(__tstate);
30223 if (PyErr_Occurred()) SWIG_fail;
30224 }
30225 resultobj = SWIG_Py_Void();
30226 {
30227 if (temp2)
30228 delete arg2;
30229 }
30230 return resultobj;
30231 fail:
30232 {
30233 if (temp2)
30234 delete arg2;
30235 }
30236 return NULL;
30237 }
30238
30239
30240 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30241 PyObject *resultobj = 0;
30242 wxPyApp *arg1 = (wxPyApp *) 0 ;
30243 wxString *result = 0 ;
30244 void *argp1 = 0 ;
30245 int res1 = 0 ;
30246 PyObject *swig_obj[1] ;
30247
30248 if (!args) SWIG_fail;
30249 swig_obj[0] = args;
30250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30251 if (!SWIG_IsOK(res1)) {
30252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30253 }
30254 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30255 {
30256 PyThreadState* __tstate = wxPyBeginAllowThreads();
30257 {
30258 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30259 result = (wxString *) &_result_ref;
30260 }
30261 wxPyEndAllowThreads(__tstate);
30262 if (PyErr_Occurred()) SWIG_fail;
30263 }
30264 {
30265 #if wxUSE_UNICODE
30266 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30267 #else
30268 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30269 #endif
30270 }
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30278 PyObject *resultobj = 0;
30279 wxPyApp *arg1 = (wxPyApp *) 0 ;
30280 wxString *arg2 = 0 ;
30281 void *argp1 = 0 ;
30282 int res1 = 0 ;
30283 bool temp2 = false ;
30284 PyObject * obj0 = 0 ;
30285 PyObject * obj1 = 0 ;
30286 char * kwnames[] = {
30287 (char *) "self",(char *) "name", NULL
30288 };
30289
30290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30292 if (!SWIG_IsOK(res1)) {
30293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30294 }
30295 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30296 {
30297 arg2 = wxString_in_helper(obj1);
30298 if (arg2 == NULL) SWIG_fail;
30299 temp2 = true;
30300 }
30301 {
30302 PyThreadState* __tstate = wxPyBeginAllowThreads();
30303 (arg1)->SetVendorName((wxString const &)*arg2);
30304 wxPyEndAllowThreads(__tstate);
30305 if (PyErr_Occurred()) SWIG_fail;
30306 }
30307 resultobj = SWIG_Py_Void();
30308 {
30309 if (temp2)
30310 delete arg2;
30311 }
30312 return resultobj;
30313 fail:
30314 {
30315 if (temp2)
30316 delete arg2;
30317 }
30318 return NULL;
30319 }
30320
30321
30322 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30323 PyObject *resultobj = 0;
30324 wxPyApp *arg1 = (wxPyApp *) 0 ;
30325 wxAppTraits *result = 0 ;
30326 void *argp1 = 0 ;
30327 int res1 = 0 ;
30328 PyObject *swig_obj[1] ;
30329
30330 if (!args) SWIG_fail;
30331 swig_obj[0] = args;
30332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30333 if (!SWIG_IsOK(res1)) {
30334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30335 }
30336 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30337 {
30338 PyThreadState* __tstate = wxPyBeginAllowThreads();
30339 result = (wxAppTraits *)(arg1)->GetTraits();
30340 wxPyEndAllowThreads(__tstate);
30341 if (PyErr_Occurred()) SWIG_fail;
30342 }
30343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30344 return resultobj;
30345 fail:
30346 return NULL;
30347 }
30348
30349
30350 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30351 PyObject *resultobj = 0;
30352 wxPyApp *arg1 = (wxPyApp *) 0 ;
30353 void *argp1 = 0 ;
30354 int res1 = 0 ;
30355 PyObject *swig_obj[1] ;
30356
30357 if (!args) SWIG_fail;
30358 swig_obj[0] = args;
30359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30360 if (!SWIG_IsOK(res1)) {
30361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30362 }
30363 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30364 {
30365 PyThreadState* __tstate = wxPyBeginAllowThreads();
30366 (arg1)->ProcessPendingEvents();
30367 wxPyEndAllowThreads(__tstate);
30368 if (PyErr_Occurred()) SWIG_fail;
30369 }
30370 resultobj = SWIG_Py_Void();
30371 return resultobj;
30372 fail:
30373 return NULL;
30374 }
30375
30376
30377 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30378 PyObject *resultobj = 0;
30379 wxPyApp *arg1 = (wxPyApp *) 0 ;
30380 bool arg2 = (bool) false ;
30381 bool result;
30382 void *argp1 = 0 ;
30383 int res1 = 0 ;
30384 bool val2 ;
30385 int ecode2 = 0 ;
30386 PyObject * obj0 = 0 ;
30387 PyObject * obj1 = 0 ;
30388 char * kwnames[] = {
30389 (char *) "self",(char *) "onlyIfNeeded", NULL
30390 };
30391
30392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30394 if (!SWIG_IsOK(res1)) {
30395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30396 }
30397 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30398 if (obj1) {
30399 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30400 if (!SWIG_IsOK(ecode2)) {
30401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30402 }
30403 arg2 = static_cast< bool >(val2);
30404 }
30405 {
30406 PyThreadState* __tstate = wxPyBeginAllowThreads();
30407 result = (bool)(arg1)->Yield(arg2);
30408 wxPyEndAllowThreads(__tstate);
30409 if (PyErr_Occurred()) SWIG_fail;
30410 }
30411 {
30412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30413 }
30414 return resultobj;
30415 fail:
30416 return NULL;
30417 }
30418
30419
30420 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30421 PyObject *resultobj = 0;
30422 wxPyApp *arg1 = (wxPyApp *) 0 ;
30423 void *argp1 = 0 ;
30424 int res1 = 0 ;
30425 PyObject *swig_obj[1] ;
30426
30427 if (!args) SWIG_fail;
30428 swig_obj[0] = args;
30429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30430 if (!SWIG_IsOK(res1)) {
30431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30432 }
30433 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30434 {
30435 PyThreadState* __tstate = wxPyBeginAllowThreads();
30436 (arg1)->WakeUpIdle();
30437 wxPyEndAllowThreads(__tstate);
30438 if (PyErr_Occurred()) SWIG_fail;
30439 }
30440 resultobj = SWIG_Py_Void();
30441 return resultobj;
30442 fail:
30443 return NULL;
30444 }
30445
30446
30447 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30448 PyObject *resultobj = 0;
30449 bool result;
30450
30451 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30452 {
30453 PyThreadState* __tstate = wxPyBeginAllowThreads();
30454 result = (bool)wxPyApp::IsMainLoopRunning();
30455 wxPyEndAllowThreads(__tstate);
30456 if (PyErr_Occurred()) SWIG_fail;
30457 }
30458 {
30459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30460 }
30461 return resultobj;
30462 fail:
30463 return NULL;
30464 }
30465
30466
30467 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30468 PyObject *resultobj = 0;
30469 wxPyApp *arg1 = (wxPyApp *) 0 ;
30470 int result;
30471 void *argp1 = 0 ;
30472 int res1 = 0 ;
30473 PyObject *swig_obj[1] ;
30474
30475 if (!args) SWIG_fail;
30476 swig_obj[0] = args;
30477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30478 if (!SWIG_IsOK(res1)) {
30479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30480 }
30481 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30482 {
30483 PyThreadState* __tstate = wxPyBeginAllowThreads();
30484 result = (int)(arg1)->MainLoop();
30485 wxPyEndAllowThreads(__tstate);
30486 if (PyErr_Occurred()) SWIG_fail;
30487 }
30488 resultobj = SWIG_From_int(static_cast< int >(result));
30489 return resultobj;
30490 fail:
30491 return NULL;
30492 }
30493
30494
30495 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30496 PyObject *resultobj = 0;
30497 wxPyApp *arg1 = (wxPyApp *) 0 ;
30498 void *argp1 = 0 ;
30499 int res1 = 0 ;
30500 PyObject *swig_obj[1] ;
30501
30502 if (!args) SWIG_fail;
30503 swig_obj[0] = args;
30504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30505 if (!SWIG_IsOK(res1)) {
30506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30507 }
30508 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30509 {
30510 PyThreadState* __tstate = wxPyBeginAllowThreads();
30511 (arg1)->Exit();
30512 wxPyEndAllowThreads(__tstate);
30513 if (PyErr_Occurred()) SWIG_fail;
30514 }
30515 resultobj = SWIG_Py_Void();
30516 return resultobj;
30517 fail:
30518 return NULL;
30519 }
30520
30521
30522 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30523 PyObject *resultobj = 0;
30524 wxPyApp *arg1 = (wxPyApp *) 0 ;
30525 wxLayoutDirection result;
30526 void *argp1 = 0 ;
30527 int res1 = 0 ;
30528 PyObject *swig_obj[1] ;
30529
30530 if (!args) SWIG_fail;
30531 swig_obj[0] = args;
30532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30533 if (!SWIG_IsOK(res1)) {
30534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30535 }
30536 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30537 {
30538 PyThreadState* __tstate = wxPyBeginAllowThreads();
30539 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30540 wxPyEndAllowThreads(__tstate);
30541 if (PyErr_Occurred()) SWIG_fail;
30542 }
30543 resultobj = SWIG_From_int(static_cast< int >(result));
30544 return resultobj;
30545 fail:
30546 return NULL;
30547 }
30548
30549
30550 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30551 PyObject *resultobj = 0;
30552 wxPyApp *arg1 = (wxPyApp *) 0 ;
30553 void *argp1 = 0 ;
30554 int res1 = 0 ;
30555 PyObject *swig_obj[1] ;
30556
30557 if (!args) SWIG_fail;
30558 swig_obj[0] = args;
30559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30560 if (!SWIG_IsOK(res1)) {
30561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30562 }
30563 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30564 {
30565 PyThreadState* __tstate = wxPyBeginAllowThreads();
30566 (arg1)->ExitMainLoop();
30567 wxPyEndAllowThreads(__tstate);
30568 if (PyErr_Occurred()) SWIG_fail;
30569 }
30570 resultobj = SWIG_Py_Void();
30571 return resultobj;
30572 fail:
30573 return NULL;
30574 }
30575
30576
30577 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30578 PyObject *resultobj = 0;
30579 wxPyApp *arg1 = (wxPyApp *) 0 ;
30580 bool result;
30581 void *argp1 = 0 ;
30582 int res1 = 0 ;
30583 PyObject *swig_obj[1] ;
30584
30585 if (!args) SWIG_fail;
30586 swig_obj[0] = args;
30587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30588 if (!SWIG_IsOK(res1)) {
30589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30590 }
30591 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30592 {
30593 PyThreadState* __tstate = wxPyBeginAllowThreads();
30594 result = (bool)(arg1)->Pending();
30595 wxPyEndAllowThreads(__tstate);
30596 if (PyErr_Occurred()) SWIG_fail;
30597 }
30598 {
30599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30600 }
30601 return resultobj;
30602 fail:
30603 return NULL;
30604 }
30605
30606
30607 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30608 PyObject *resultobj = 0;
30609 wxPyApp *arg1 = (wxPyApp *) 0 ;
30610 bool result;
30611 void *argp1 = 0 ;
30612 int res1 = 0 ;
30613 PyObject *swig_obj[1] ;
30614
30615 if (!args) SWIG_fail;
30616 swig_obj[0] = args;
30617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30618 if (!SWIG_IsOK(res1)) {
30619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30620 }
30621 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30622 {
30623 PyThreadState* __tstate = wxPyBeginAllowThreads();
30624 result = (bool)(arg1)->Dispatch();
30625 wxPyEndAllowThreads(__tstate);
30626 if (PyErr_Occurred()) SWIG_fail;
30627 }
30628 {
30629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30630 }
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30638 PyObject *resultobj = 0;
30639 wxPyApp *arg1 = (wxPyApp *) 0 ;
30640 bool result;
30641 void *argp1 = 0 ;
30642 int res1 = 0 ;
30643 PyObject *swig_obj[1] ;
30644
30645 if (!args) SWIG_fail;
30646 swig_obj[0] = args;
30647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30648 if (!SWIG_IsOK(res1)) {
30649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30650 }
30651 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30652 {
30653 PyThreadState* __tstate = wxPyBeginAllowThreads();
30654 result = (bool)(arg1)->ProcessIdle();
30655 wxPyEndAllowThreads(__tstate);
30656 if (PyErr_Occurred()) SWIG_fail;
30657 }
30658 {
30659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30660 }
30661 return resultobj;
30662 fail:
30663 return NULL;
30664 }
30665
30666
30667 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30668 PyObject *resultobj = 0;
30669 wxPyApp *arg1 = (wxPyApp *) 0 ;
30670 wxWindow *arg2 = (wxWindow *) 0 ;
30671 wxIdleEvent *arg3 = 0 ;
30672 bool result;
30673 void *argp1 = 0 ;
30674 int res1 = 0 ;
30675 void *argp2 = 0 ;
30676 int res2 = 0 ;
30677 void *argp3 = 0 ;
30678 int res3 = 0 ;
30679 PyObject * obj0 = 0 ;
30680 PyObject * obj1 = 0 ;
30681 PyObject * obj2 = 0 ;
30682 char * kwnames[] = {
30683 (char *) "self",(char *) "win",(char *) "event", NULL
30684 };
30685
30686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30688 if (!SWIG_IsOK(res1)) {
30689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30690 }
30691 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30692 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30693 if (!SWIG_IsOK(res2)) {
30694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30695 }
30696 arg2 = reinterpret_cast< wxWindow * >(argp2);
30697 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30698 if (!SWIG_IsOK(res3)) {
30699 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30700 }
30701 if (!argp3) {
30702 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30703 }
30704 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30705 {
30706 PyThreadState* __tstate = wxPyBeginAllowThreads();
30707 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 {
30712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30713 }
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30721 PyObject *resultobj = 0;
30722 wxPyApp *arg1 = (wxPyApp *) 0 ;
30723 bool result;
30724 void *argp1 = 0 ;
30725 int res1 = 0 ;
30726 PyObject *swig_obj[1] ;
30727
30728 if (!args) SWIG_fail;
30729 swig_obj[0] = args;
30730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30731 if (!SWIG_IsOK(res1)) {
30732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30733 }
30734 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30735 {
30736 PyThreadState* __tstate = wxPyBeginAllowThreads();
30737 result = (bool)((wxPyApp const *)arg1)->IsActive();
30738 wxPyEndAllowThreads(__tstate);
30739 if (PyErr_Occurred()) SWIG_fail;
30740 }
30741 {
30742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30743 }
30744 return resultobj;
30745 fail:
30746 return NULL;
30747 }
30748
30749
30750 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30751 PyObject *resultobj = 0;
30752 wxPyApp *arg1 = (wxPyApp *) 0 ;
30753 wxWindow *arg2 = (wxWindow *) 0 ;
30754 void *argp1 = 0 ;
30755 int res1 = 0 ;
30756 void *argp2 = 0 ;
30757 int res2 = 0 ;
30758 PyObject * obj0 = 0 ;
30759 PyObject * obj1 = 0 ;
30760 char * kwnames[] = {
30761 (char *) "self",(char *) "win", NULL
30762 };
30763
30764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30766 if (!SWIG_IsOK(res1)) {
30767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30768 }
30769 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30771 if (!SWIG_IsOK(res2)) {
30772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30773 }
30774 arg2 = reinterpret_cast< wxWindow * >(argp2);
30775 {
30776 PyThreadState* __tstate = wxPyBeginAllowThreads();
30777 (arg1)->SetTopWindow(arg2);
30778 wxPyEndAllowThreads(__tstate);
30779 if (PyErr_Occurred()) SWIG_fail;
30780 }
30781 resultobj = SWIG_Py_Void();
30782 return resultobj;
30783 fail:
30784 return NULL;
30785 }
30786
30787
30788 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30789 PyObject *resultobj = 0;
30790 wxPyApp *arg1 = (wxPyApp *) 0 ;
30791 wxWindow *result = 0 ;
30792 void *argp1 = 0 ;
30793 int res1 = 0 ;
30794 PyObject *swig_obj[1] ;
30795
30796 if (!args) SWIG_fail;
30797 swig_obj[0] = args;
30798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30799 if (!SWIG_IsOK(res1)) {
30800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30801 }
30802 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30803 {
30804 PyThreadState* __tstate = wxPyBeginAllowThreads();
30805 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30806 wxPyEndAllowThreads(__tstate);
30807 if (PyErr_Occurred()) SWIG_fail;
30808 }
30809 {
30810 resultobj = wxPyMake_wxObject(result, (bool)0);
30811 }
30812 return resultobj;
30813 fail:
30814 return NULL;
30815 }
30816
30817
30818 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30819 PyObject *resultobj = 0;
30820 wxPyApp *arg1 = (wxPyApp *) 0 ;
30821 bool arg2 ;
30822 void *argp1 = 0 ;
30823 int res1 = 0 ;
30824 bool val2 ;
30825 int ecode2 = 0 ;
30826 PyObject * obj0 = 0 ;
30827 PyObject * obj1 = 0 ;
30828 char * kwnames[] = {
30829 (char *) "self",(char *) "flag", NULL
30830 };
30831
30832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30834 if (!SWIG_IsOK(res1)) {
30835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30836 }
30837 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30839 if (!SWIG_IsOK(ecode2)) {
30840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30841 }
30842 arg2 = static_cast< bool >(val2);
30843 {
30844 PyThreadState* __tstate = wxPyBeginAllowThreads();
30845 (arg1)->SetExitOnFrameDelete(arg2);
30846 wxPyEndAllowThreads(__tstate);
30847 if (PyErr_Occurred()) SWIG_fail;
30848 }
30849 resultobj = SWIG_Py_Void();
30850 return resultobj;
30851 fail:
30852 return NULL;
30853 }
30854
30855
30856 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30857 PyObject *resultobj = 0;
30858 wxPyApp *arg1 = (wxPyApp *) 0 ;
30859 bool result;
30860 void *argp1 = 0 ;
30861 int res1 = 0 ;
30862 PyObject *swig_obj[1] ;
30863
30864 if (!args) SWIG_fail;
30865 swig_obj[0] = args;
30866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30867 if (!SWIG_IsOK(res1)) {
30868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30869 }
30870 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30871 {
30872 PyThreadState* __tstate = wxPyBeginAllowThreads();
30873 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30874 wxPyEndAllowThreads(__tstate);
30875 if (PyErr_Occurred()) SWIG_fail;
30876 }
30877 {
30878 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30879 }
30880 return resultobj;
30881 fail:
30882 return NULL;
30883 }
30884
30885
30886 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj = 0;
30888 wxPyApp *arg1 = (wxPyApp *) 0 ;
30889 bool arg2 ;
30890 void *argp1 = 0 ;
30891 int res1 = 0 ;
30892 bool val2 ;
30893 int ecode2 = 0 ;
30894 PyObject * obj0 = 0 ;
30895 PyObject * obj1 = 0 ;
30896 char * kwnames[] = {
30897 (char *) "self",(char *) "flag", NULL
30898 };
30899
30900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30902 if (!SWIG_IsOK(res1)) {
30903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30904 }
30905 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30906 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30907 if (!SWIG_IsOK(ecode2)) {
30908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30909 }
30910 arg2 = static_cast< bool >(val2);
30911 {
30912 PyThreadState* __tstate = wxPyBeginAllowThreads();
30913 (arg1)->SetUseBestVisual(arg2);
30914 wxPyEndAllowThreads(__tstate);
30915 if (PyErr_Occurred()) SWIG_fail;
30916 }
30917 resultobj = SWIG_Py_Void();
30918 return resultobj;
30919 fail:
30920 return NULL;
30921 }
30922
30923
30924 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30925 PyObject *resultobj = 0;
30926 wxPyApp *arg1 = (wxPyApp *) 0 ;
30927 bool result;
30928 void *argp1 = 0 ;
30929 int res1 = 0 ;
30930 PyObject *swig_obj[1] ;
30931
30932 if (!args) SWIG_fail;
30933 swig_obj[0] = args;
30934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30935 if (!SWIG_IsOK(res1)) {
30936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30937 }
30938 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30939 {
30940 PyThreadState* __tstate = wxPyBeginAllowThreads();
30941 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30942 wxPyEndAllowThreads(__tstate);
30943 if (PyErr_Occurred()) SWIG_fail;
30944 }
30945 {
30946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30947 }
30948 return resultobj;
30949 fail:
30950 return NULL;
30951 }
30952
30953
30954 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30955 PyObject *resultobj = 0;
30956 wxPyApp *arg1 = (wxPyApp *) 0 ;
30957 int arg2 ;
30958 void *argp1 = 0 ;
30959 int res1 = 0 ;
30960 int val2 ;
30961 int ecode2 = 0 ;
30962 PyObject * obj0 = 0 ;
30963 PyObject * obj1 = 0 ;
30964 char * kwnames[] = {
30965 (char *) "self",(char *) "mode", NULL
30966 };
30967
30968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30970 if (!SWIG_IsOK(res1)) {
30971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30972 }
30973 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30974 ecode2 = SWIG_AsVal_int(obj1, &val2);
30975 if (!SWIG_IsOK(ecode2)) {
30976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30977 }
30978 arg2 = static_cast< int >(val2);
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 (arg1)->SetPrintMode(arg2);
30982 wxPyEndAllowThreads(__tstate);
30983 if (PyErr_Occurred()) SWIG_fail;
30984 }
30985 resultobj = SWIG_Py_Void();
30986 return resultobj;
30987 fail:
30988 return NULL;
30989 }
30990
30991
30992 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30993 PyObject *resultobj = 0;
30994 wxPyApp *arg1 = (wxPyApp *) 0 ;
30995 int result;
30996 void *argp1 = 0 ;
30997 int res1 = 0 ;
30998 PyObject *swig_obj[1] ;
30999
31000 if (!args) SWIG_fail;
31001 swig_obj[0] = args;
31002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31003 if (!SWIG_IsOK(res1)) {
31004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31005 }
31006 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31007 {
31008 PyThreadState* __tstate = wxPyBeginAllowThreads();
31009 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31010 wxPyEndAllowThreads(__tstate);
31011 if (PyErr_Occurred()) SWIG_fail;
31012 }
31013 resultobj = SWIG_From_int(static_cast< int >(result));
31014 return resultobj;
31015 fail:
31016 return NULL;
31017 }
31018
31019
31020 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31021 PyObject *resultobj = 0;
31022 wxPyApp *arg1 = (wxPyApp *) 0 ;
31023 int arg2 ;
31024 void *argp1 = 0 ;
31025 int res1 = 0 ;
31026 int val2 ;
31027 int ecode2 = 0 ;
31028 PyObject * obj0 = 0 ;
31029 PyObject * obj1 = 0 ;
31030 char * kwnames[] = {
31031 (char *) "self",(char *) "mode", NULL
31032 };
31033
31034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31036 if (!SWIG_IsOK(res1)) {
31037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31038 }
31039 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31040 ecode2 = SWIG_AsVal_int(obj1, &val2);
31041 if (!SWIG_IsOK(ecode2)) {
31042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31043 }
31044 arg2 = static_cast< int >(val2);
31045 {
31046 PyThreadState* __tstate = wxPyBeginAllowThreads();
31047 (arg1)->SetAssertMode(arg2);
31048 wxPyEndAllowThreads(__tstate);
31049 if (PyErr_Occurred()) SWIG_fail;
31050 }
31051 resultobj = SWIG_Py_Void();
31052 return resultobj;
31053 fail:
31054 return NULL;
31055 }
31056
31057
31058 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31059 PyObject *resultobj = 0;
31060 wxPyApp *arg1 = (wxPyApp *) 0 ;
31061 int result;
31062 void *argp1 = 0 ;
31063 int res1 = 0 ;
31064 PyObject *swig_obj[1] ;
31065
31066 if (!args) SWIG_fail;
31067 swig_obj[0] = args;
31068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31069 if (!SWIG_IsOK(res1)) {
31070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31071 }
31072 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31073 {
31074 PyThreadState* __tstate = wxPyBeginAllowThreads();
31075 result = (int)(arg1)->GetAssertMode();
31076 wxPyEndAllowThreads(__tstate);
31077 if (PyErr_Occurred()) SWIG_fail;
31078 }
31079 resultobj = SWIG_From_int(static_cast< int >(result));
31080 return resultobj;
31081 fail:
31082 return NULL;
31083 }
31084
31085
31086 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31087 PyObject *resultobj = 0;
31088 bool result;
31089
31090 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31091 {
31092 PyThreadState* __tstate = wxPyBeginAllowThreads();
31093 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31094 wxPyEndAllowThreads(__tstate);
31095 if (PyErr_Occurred()) SWIG_fail;
31096 }
31097 {
31098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31099 }
31100 return resultobj;
31101 fail:
31102 return NULL;
31103 }
31104
31105
31106 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31107 PyObject *resultobj = 0;
31108 long result;
31109
31110 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31111 {
31112 PyThreadState* __tstate = wxPyBeginAllowThreads();
31113 result = (long)wxPyApp::GetMacAboutMenuItemId();
31114 wxPyEndAllowThreads(__tstate);
31115 if (PyErr_Occurred()) SWIG_fail;
31116 }
31117 resultobj = SWIG_From_long(static_cast< long >(result));
31118 return resultobj;
31119 fail:
31120 return NULL;
31121 }
31122
31123
31124 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31125 PyObject *resultobj = 0;
31126 long result;
31127
31128 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 resultobj = SWIG_From_long(static_cast< long >(result));
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31143 PyObject *resultobj = 0;
31144 long result;
31145
31146 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = (long)wxPyApp::GetMacExitMenuItemId();
31150 wxPyEndAllowThreads(__tstate);
31151 if (PyErr_Occurred()) SWIG_fail;
31152 }
31153 resultobj = SWIG_From_long(static_cast< long >(result));
31154 return resultobj;
31155 fail:
31156 return NULL;
31157 }
31158
31159
31160 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31161 PyObject *resultobj = 0;
31162 wxString result;
31163
31164 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31165 {
31166 PyThreadState* __tstate = wxPyBeginAllowThreads();
31167 result = wxPyApp::GetMacHelpMenuTitleName();
31168 wxPyEndAllowThreads(__tstate);
31169 if (PyErr_Occurred()) SWIG_fail;
31170 }
31171 {
31172 #if wxUSE_UNICODE
31173 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31174 #else
31175 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31176 #endif
31177 }
31178 return resultobj;
31179 fail:
31180 return NULL;
31181 }
31182
31183
31184 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31185 PyObject *resultobj = 0;
31186 bool arg1 ;
31187 bool val1 ;
31188 int ecode1 = 0 ;
31189 PyObject * obj0 = 0 ;
31190 char * kwnames[] = {
31191 (char *) "val", NULL
31192 };
31193
31194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31195 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31196 if (!SWIG_IsOK(ecode1)) {
31197 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31198 }
31199 arg1 = static_cast< bool >(val1);
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31203 wxPyEndAllowThreads(__tstate);
31204 if (PyErr_Occurred()) SWIG_fail;
31205 }
31206 resultobj = SWIG_Py_Void();
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj = 0;
31215 long arg1 ;
31216 long val1 ;
31217 int ecode1 = 0 ;
31218 PyObject * obj0 = 0 ;
31219 char * kwnames[] = {
31220 (char *) "val", NULL
31221 };
31222
31223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31224 ecode1 = SWIG_AsVal_long(obj0, &val1);
31225 if (!SWIG_IsOK(ecode1)) {
31226 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31227 }
31228 arg1 = static_cast< long >(val1);
31229 {
31230 PyThreadState* __tstate = wxPyBeginAllowThreads();
31231 wxPyApp::SetMacAboutMenuItemId(arg1);
31232 wxPyEndAllowThreads(__tstate);
31233 if (PyErr_Occurred()) SWIG_fail;
31234 }
31235 resultobj = SWIG_Py_Void();
31236 return resultobj;
31237 fail:
31238 return NULL;
31239 }
31240
31241
31242 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31243 PyObject *resultobj = 0;
31244 long arg1 ;
31245 long val1 ;
31246 int ecode1 = 0 ;
31247 PyObject * obj0 = 0 ;
31248 char * kwnames[] = {
31249 (char *) "val", NULL
31250 };
31251
31252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31253 ecode1 = SWIG_AsVal_long(obj0, &val1);
31254 if (!SWIG_IsOK(ecode1)) {
31255 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31256 }
31257 arg1 = static_cast< long >(val1);
31258 {
31259 PyThreadState* __tstate = wxPyBeginAllowThreads();
31260 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31261 wxPyEndAllowThreads(__tstate);
31262 if (PyErr_Occurred()) SWIG_fail;
31263 }
31264 resultobj = SWIG_Py_Void();
31265 return resultobj;
31266 fail:
31267 return NULL;
31268 }
31269
31270
31271 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31272 PyObject *resultobj = 0;
31273 long arg1 ;
31274 long val1 ;
31275 int ecode1 = 0 ;
31276 PyObject * obj0 = 0 ;
31277 char * kwnames[] = {
31278 (char *) "val", NULL
31279 };
31280
31281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31282 ecode1 = SWIG_AsVal_long(obj0, &val1);
31283 if (!SWIG_IsOK(ecode1)) {
31284 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31285 }
31286 arg1 = static_cast< long >(val1);
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 wxPyApp::SetMacExitMenuItemId(arg1);
31290 wxPyEndAllowThreads(__tstate);
31291 if (PyErr_Occurred()) SWIG_fail;
31292 }
31293 resultobj = SWIG_Py_Void();
31294 return resultobj;
31295 fail:
31296 return NULL;
31297 }
31298
31299
31300 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31301 PyObject *resultobj = 0;
31302 wxString *arg1 = 0 ;
31303 bool temp1 = false ;
31304 PyObject * obj0 = 0 ;
31305 char * kwnames[] = {
31306 (char *) "val", NULL
31307 };
31308
31309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31310 {
31311 arg1 = wxString_in_helper(obj0);
31312 if (arg1 == NULL) SWIG_fail;
31313 temp1 = true;
31314 }
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31318 wxPyEndAllowThreads(__tstate);
31319 if (PyErr_Occurred()) SWIG_fail;
31320 }
31321 resultobj = SWIG_Py_Void();
31322 {
31323 if (temp1)
31324 delete arg1;
31325 }
31326 return resultobj;
31327 fail:
31328 {
31329 if (temp1)
31330 delete arg1;
31331 }
31332 return NULL;
31333 }
31334
31335
31336 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31337 PyObject *resultobj = 0;
31338 wxPyApp *arg1 = (wxPyApp *) 0 ;
31339 void *argp1 = 0 ;
31340 int res1 = 0 ;
31341 PyObject *swig_obj[1] ;
31342
31343 if (!args) SWIG_fail;
31344 swig_obj[0] = args;
31345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31346 if (!SWIG_IsOK(res1)) {
31347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31348 }
31349 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31350 {
31351 PyThreadState* __tstate = wxPyBeginAllowThreads();
31352 (arg1)->_BootstrapApp();
31353 wxPyEndAllowThreads(__tstate);
31354 if (PyErr_Occurred()) SWIG_fail;
31355 }
31356 resultobj = SWIG_Py_Void();
31357 return resultobj;
31358 fail:
31359 return NULL;
31360 }
31361
31362
31363 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31364 PyObject *resultobj = 0;
31365 int result;
31366
31367 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31368 {
31369 PyThreadState* __tstate = wxPyBeginAllowThreads();
31370 result = (int)wxPyApp::GetComCtl32Version();
31371 wxPyEndAllowThreads(__tstate);
31372 if (PyErr_Occurred()) SWIG_fail;
31373 }
31374 resultobj = SWIG_From_int(static_cast< int >(result));
31375 return resultobj;
31376 fail:
31377 return NULL;
31378 }
31379
31380
31381 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31382 PyObject *resultobj = 0;
31383 bool result;
31384
31385 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31386 {
31387 PyThreadState* __tstate = wxPyBeginAllowThreads();
31388 result = (bool)wxPyApp_IsDisplayAvailable();
31389 wxPyEndAllowThreads(__tstate);
31390 if (PyErr_Occurred()) SWIG_fail;
31391 }
31392 {
31393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31394 }
31395 return resultobj;
31396 fail:
31397 return NULL;
31398 }
31399
31400
31401 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31402 PyObject *obj;
31403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31404 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31405 return SWIG_Py_Void();
31406 }
31407
31408 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31409 return SWIG_Python_InitShadowInstance(args);
31410 }
31411
31412 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31413 PyObject *resultobj = 0;
31414
31415 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31416 {
31417 PyThreadState* __tstate = wxPyBeginAllowThreads();
31418 wxExit();
31419 wxPyEndAllowThreads(__tstate);
31420 if (PyErr_Occurred()) SWIG_fail;
31421 }
31422 resultobj = SWIG_Py_Void();
31423 return resultobj;
31424 fail:
31425 return NULL;
31426 }
31427
31428
31429 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31430 PyObject *resultobj = 0;
31431 bool result;
31432
31433 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31434 {
31435 PyThreadState* __tstate = wxPyBeginAllowThreads();
31436 result = (bool)wxYield();
31437 wxPyEndAllowThreads(__tstate);
31438 if (PyErr_Occurred()) SWIG_fail;
31439 }
31440 {
31441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31442 }
31443 return resultobj;
31444 fail:
31445 return NULL;
31446 }
31447
31448
31449 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31450 PyObject *resultobj = 0;
31451 bool result;
31452
31453 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31454 {
31455 PyThreadState* __tstate = wxPyBeginAllowThreads();
31456 result = (bool)wxYieldIfNeeded();
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 {
31461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31462 }
31463 return resultobj;
31464 fail:
31465 return NULL;
31466 }
31467
31468
31469 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31470 PyObject *resultobj = 0;
31471 wxWindow *arg1 = (wxWindow *) NULL ;
31472 bool arg2 = (bool) false ;
31473 bool result;
31474 void *argp1 = 0 ;
31475 int res1 = 0 ;
31476 bool val2 ;
31477 int ecode2 = 0 ;
31478 PyObject * obj0 = 0 ;
31479 PyObject * obj1 = 0 ;
31480 char * kwnames[] = {
31481 (char *) "win",(char *) "onlyIfNeeded", NULL
31482 };
31483
31484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31485 if (obj0) {
31486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31487 if (!SWIG_IsOK(res1)) {
31488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31489 }
31490 arg1 = reinterpret_cast< wxWindow * >(argp1);
31491 }
31492 if (obj1) {
31493 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31494 if (!SWIG_IsOK(ecode2)) {
31495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31496 }
31497 arg2 = static_cast< bool >(val2);
31498 }
31499 {
31500 PyThreadState* __tstate = wxPyBeginAllowThreads();
31501 result = (bool)wxSafeYield(arg1,arg2);
31502 wxPyEndAllowThreads(__tstate);
31503 if (PyErr_Occurred()) SWIG_fail;
31504 }
31505 {
31506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31507 }
31508 return resultobj;
31509 fail:
31510 return NULL;
31511 }
31512
31513
31514 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31515 PyObject *resultobj = 0;
31516
31517 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31518 {
31519 PyThreadState* __tstate = wxPyBeginAllowThreads();
31520 wxWakeUpIdle();
31521 wxPyEndAllowThreads(__tstate);
31522 if (PyErr_Occurred()) SWIG_fail;
31523 }
31524 resultobj = SWIG_Py_Void();
31525 return resultobj;
31526 fail:
31527 return NULL;
31528 }
31529
31530
31531 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31532 PyObject *resultobj = 0;
31533 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31534 wxEvent *arg2 = 0 ;
31535 void *argp1 = 0 ;
31536 int res1 = 0 ;
31537 void *argp2 = 0 ;
31538 int res2 = 0 ;
31539 PyObject * obj0 = 0 ;
31540 PyObject * obj1 = 0 ;
31541 char * kwnames[] = {
31542 (char *) "dest",(char *) "event", NULL
31543 };
31544
31545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31547 if (!SWIG_IsOK(res1)) {
31548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31549 }
31550 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31552 if (!SWIG_IsOK(res2)) {
31553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31554 }
31555 if (!argp2) {
31556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31557 }
31558 arg2 = reinterpret_cast< wxEvent * >(argp2);
31559 {
31560 PyThreadState* __tstate = wxPyBeginAllowThreads();
31561 wxPostEvent(arg1,*arg2);
31562 wxPyEndAllowThreads(__tstate);
31563 if (PyErr_Occurred()) SWIG_fail;
31564 }
31565 resultobj = SWIG_Py_Void();
31566 return resultobj;
31567 fail:
31568 return NULL;
31569 }
31570
31571
31572 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31573 PyObject *resultobj = 0;
31574
31575 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31576 {
31577 PyThreadState* __tstate = wxPyBeginAllowThreads();
31578 wxApp_CleanUp();
31579 wxPyEndAllowThreads(__tstate);
31580 if (PyErr_Occurred()) SWIG_fail;
31581 }
31582 resultobj = SWIG_Py_Void();
31583 return resultobj;
31584 fail:
31585 return NULL;
31586 }
31587
31588
31589 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31590 PyObject *resultobj = 0;
31591 wxPyApp *result = 0 ;
31592
31593 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31594 {
31595 PyThreadState* __tstate = wxPyBeginAllowThreads();
31596 result = (wxPyApp *)wxPyGetApp();
31597 wxPyEndAllowThreads(__tstate);
31598 if (PyErr_Occurred()) SWIG_fail;
31599 }
31600 {
31601 resultobj = wxPyMake_wxObject(result, 0);
31602 }
31603 return resultobj;
31604 fail:
31605 return NULL;
31606 }
31607
31608
31609 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31610 PyObject *resultobj = 0;
31611 char *arg1 = (char *) 0 ;
31612 int res1 ;
31613 char *buf1 = 0 ;
31614 int alloc1 = 0 ;
31615 PyObject * obj0 = 0 ;
31616 char * kwnames[] = {
31617 (char *) "encoding", NULL
31618 };
31619
31620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31621 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31622 if (!SWIG_IsOK(res1)) {
31623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31624 }
31625 arg1 = buf1;
31626 {
31627 PyThreadState* __tstate = wxPyBeginAllowThreads();
31628 wxSetDefaultPyEncoding((char const *)arg1);
31629 wxPyEndAllowThreads(__tstate);
31630 if (PyErr_Occurred()) SWIG_fail;
31631 }
31632 resultobj = SWIG_Py_Void();
31633 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31634 return resultobj;
31635 fail:
31636 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31637 return NULL;
31638 }
31639
31640
31641 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31642 PyObject *resultobj = 0;
31643 char *result = 0 ;
31644
31645 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31646 {
31647 PyThreadState* __tstate = wxPyBeginAllowThreads();
31648 result = (char *)wxGetDefaultPyEncoding();
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 resultobj = SWIG_FromCharPtr(result);
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31660 PyObject *resultobj = 0;
31661 wxEventLoop *result = 0 ;
31662
31663 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 result = (wxEventLoop *)new wxEventLoop();
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31671 return resultobj;
31672 fail:
31673 return NULL;
31674 }
31675
31676
31677 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31678 PyObject *resultobj = 0;
31679 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31680 void *argp1 = 0 ;
31681 int res1 = 0 ;
31682 PyObject *swig_obj[1] ;
31683
31684 if (!args) SWIG_fail;
31685 swig_obj[0] = args;
31686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31687 if (!SWIG_IsOK(res1)) {
31688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31689 }
31690 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 delete arg1;
31694
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 resultobj = SWIG_Py_Void();
31699 return resultobj;
31700 fail:
31701 return NULL;
31702 }
31703
31704
31705 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31706 PyObject *resultobj = 0;
31707 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31708 int result;
31709 void *argp1 = 0 ;
31710 int res1 = 0 ;
31711 PyObject *swig_obj[1] ;
31712
31713 if (!args) SWIG_fail;
31714 swig_obj[0] = args;
31715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31716 if (!SWIG_IsOK(res1)) {
31717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31718 }
31719 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31720 {
31721 PyThreadState* __tstate = wxPyBeginAllowThreads();
31722 result = (int)(arg1)->Run();
31723 wxPyEndAllowThreads(__tstate);
31724 if (PyErr_Occurred()) SWIG_fail;
31725 }
31726 resultobj = SWIG_From_int(static_cast< int >(result));
31727 return resultobj;
31728 fail:
31729 return NULL;
31730 }
31731
31732
31733 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31734 PyObject *resultobj = 0;
31735 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31736 int arg2 = (int) 0 ;
31737 void *argp1 = 0 ;
31738 int res1 = 0 ;
31739 int val2 ;
31740 int ecode2 = 0 ;
31741 PyObject * obj0 = 0 ;
31742 PyObject * obj1 = 0 ;
31743 char * kwnames[] = {
31744 (char *) "self",(char *) "rc", NULL
31745 };
31746
31747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31749 if (!SWIG_IsOK(res1)) {
31750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31751 }
31752 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31753 if (obj1) {
31754 ecode2 = SWIG_AsVal_int(obj1, &val2);
31755 if (!SWIG_IsOK(ecode2)) {
31756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31757 }
31758 arg2 = static_cast< int >(val2);
31759 }
31760 {
31761 PyThreadState* __tstate = wxPyBeginAllowThreads();
31762 (arg1)->Exit(arg2);
31763 wxPyEndAllowThreads(__tstate);
31764 if (PyErr_Occurred()) SWIG_fail;
31765 }
31766 resultobj = SWIG_Py_Void();
31767 return resultobj;
31768 fail:
31769 return NULL;
31770 }
31771
31772
31773 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31774 PyObject *resultobj = 0;
31775 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31776 bool result;
31777 void *argp1 = 0 ;
31778 int res1 = 0 ;
31779 PyObject *swig_obj[1] ;
31780
31781 if (!args) SWIG_fail;
31782 swig_obj[0] = args;
31783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31784 if (!SWIG_IsOK(res1)) {
31785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31786 }
31787 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31788 {
31789 PyThreadState* __tstate = wxPyBeginAllowThreads();
31790 result = (bool)((wxEventLoop const *)arg1)->Pending();
31791 wxPyEndAllowThreads(__tstate);
31792 if (PyErr_Occurred()) SWIG_fail;
31793 }
31794 {
31795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31796 }
31797 return resultobj;
31798 fail:
31799 return NULL;
31800 }
31801
31802
31803 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31804 PyObject *resultobj = 0;
31805 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31806 bool result;
31807 void *argp1 = 0 ;
31808 int res1 = 0 ;
31809 PyObject *swig_obj[1] ;
31810
31811 if (!args) SWIG_fail;
31812 swig_obj[0] = args;
31813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31814 if (!SWIG_IsOK(res1)) {
31815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31816 }
31817 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31818 {
31819 PyThreadState* __tstate = wxPyBeginAllowThreads();
31820 result = (bool)(arg1)->Dispatch();
31821 wxPyEndAllowThreads(__tstate);
31822 if (PyErr_Occurred()) SWIG_fail;
31823 }
31824 {
31825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31826 }
31827 return resultobj;
31828 fail:
31829 return NULL;
31830 }
31831
31832
31833 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31834 PyObject *resultobj = 0;
31835 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31836 bool result;
31837 void *argp1 = 0 ;
31838 int res1 = 0 ;
31839 PyObject *swig_obj[1] ;
31840
31841 if (!args) SWIG_fail;
31842 swig_obj[0] = args;
31843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31844 if (!SWIG_IsOK(res1)) {
31845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31846 }
31847 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31848 {
31849 PyThreadState* __tstate = wxPyBeginAllowThreads();
31850 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 {
31855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31856 }
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31864 PyObject *resultobj = 0;
31865 wxEventLoop *result = 0 ;
31866
31867 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 result = (wxEventLoop *)wxEventLoop::GetActive();
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31875 return resultobj;
31876 fail:
31877 return NULL;
31878 }
31879
31880
31881 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31882 PyObject *resultobj = 0;
31883 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31884 void *argp1 = 0 ;
31885 int res1 = 0 ;
31886 PyObject * obj0 = 0 ;
31887 char * kwnames[] = {
31888 (char *) "loop", NULL
31889 };
31890
31891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31893 if (!SWIG_IsOK(res1)) {
31894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31895 }
31896 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 wxEventLoop::SetActive(arg1);
31900 wxPyEndAllowThreads(__tstate);
31901 if (PyErr_Occurred()) SWIG_fail;
31902 }
31903 resultobj = SWIG_Py_Void();
31904 return resultobj;
31905 fail:
31906 return NULL;
31907 }
31908
31909
31910 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31911 PyObject *obj;
31912 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31913 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31914 return SWIG_Py_Void();
31915 }
31916
31917 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31918 return SWIG_Python_InitShadowInstance(args);
31919 }
31920
31921 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31922 PyObject *resultobj = 0;
31923 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31924 wxEventLoopActivator *result = 0 ;
31925 void *argp1 = 0 ;
31926 int res1 = 0 ;
31927 PyObject * obj0 = 0 ;
31928 char * kwnames[] = {
31929 (char *) "evtLoop", NULL
31930 };
31931
31932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31934 if (!SWIG_IsOK(res1)) {
31935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31936 }
31937 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31938 {
31939 PyThreadState* __tstate = wxPyBeginAllowThreads();
31940 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31941 wxPyEndAllowThreads(__tstate);
31942 if (PyErr_Occurred()) SWIG_fail;
31943 }
31944 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31945 return resultobj;
31946 fail:
31947 return NULL;
31948 }
31949
31950
31951 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31952 PyObject *resultobj = 0;
31953 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31954 void *argp1 = 0 ;
31955 int res1 = 0 ;
31956 PyObject *swig_obj[1] ;
31957
31958 if (!args) SWIG_fail;
31959 swig_obj[0] = args;
31960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31961 if (!SWIG_IsOK(res1)) {
31962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31963 }
31964 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31965 {
31966 PyThreadState* __tstate = wxPyBeginAllowThreads();
31967 delete arg1;
31968
31969 wxPyEndAllowThreads(__tstate);
31970 if (PyErr_Occurred()) SWIG_fail;
31971 }
31972 resultobj = SWIG_Py_Void();
31973 return resultobj;
31974 fail:
31975 return NULL;
31976 }
31977
31978
31979 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31980 PyObject *obj;
31981 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31982 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31983 return SWIG_Py_Void();
31984 }
31985
31986 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31987 return SWIG_Python_InitShadowInstance(args);
31988 }
31989
31990 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31991 PyObject *resultobj = 0;
31992 int arg1 = (int) 0 ;
31993 int arg2 = (int) 0 ;
31994 int arg3 = (int) 0 ;
31995 wxAcceleratorEntry *result = 0 ;
31996 int val1 ;
31997 int ecode1 = 0 ;
31998 int val2 ;
31999 int ecode2 = 0 ;
32000 int val3 ;
32001 int ecode3 = 0 ;
32002 PyObject * obj0 = 0 ;
32003 PyObject * obj1 = 0 ;
32004 PyObject * obj2 = 0 ;
32005 char * kwnames[] = {
32006 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32007 };
32008
32009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32010 if (obj0) {
32011 ecode1 = SWIG_AsVal_int(obj0, &val1);
32012 if (!SWIG_IsOK(ecode1)) {
32013 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32014 }
32015 arg1 = static_cast< int >(val1);
32016 }
32017 if (obj1) {
32018 ecode2 = SWIG_AsVal_int(obj1, &val2);
32019 if (!SWIG_IsOK(ecode2)) {
32020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32021 }
32022 arg2 = static_cast< int >(val2);
32023 }
32024 if (obj2) {
32025 ecode3 = SWIG_AsVal_int(obj2, &val3);
32026 if (!SWIG_IsOK(ecode3)) {
32027 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32028 }
32029 arg3 = static_cast< int >(val3);
32030 }
32031 {
32032 PyThreadState* __tstate = wxPyBeginAllowThreads();
32033 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32034 wxPyEndAllowThreads(__tstate);
32035 if (PyErr_Occurred()) SWIG_fail;
32036 }
32037 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32038 return resultobj;
32039 fail:
32040 return NULL;
32041 }
32042
32043
32044 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32045 PyObject *resultobj = 0;
32046 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32047 void *argp1 = 0 ;
32048 int res1 = 0 ;
32049 PyObject *swig_obj[1] ;
32050
32051 if (!args) SWIG_fail;
32052 swig_obj[0] = args;
32053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32054 if (!SWIG_IsOK(res1)) {
32055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32056 }
32057 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32058 {
32059 PyThreadState* __tstate = wxPyBeginAllowThreads();
32060 delete arg1;
32061
32062 wxPyEndAllowThreads(__tstate);
32063 if (PyErr_Occurred()) SWIG_fail;
32064 }
32065 resultobj = SWIG_Py_Void();
32066 return resultobj;
32067 fail:
32068 return NULL;
32069 }
32070
32071
32072 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32073 PyObject *resultobj = 0;
32074 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32075 int arg2 ;
32076 int arg3 ;
32077 int arg4 ;
32078 void *argp1 = 0 ;
32079 int res1 = 0 ;
32080 int val2 ;
32081 int ecode2 = 0 ;
32082 int val3 ;
32083 int ecode3 = 0 ;
32084 int val4 ;
32085 int ecode4 = 0 ;
32086 PyObject * obj0 = 0 ;
32087 PyObject * obj1 = 0 ;
32088 PyObject * obj2 = 0 ;
32089 PyObject * obj3 = 0 ;
32090 char * kwnames[] = {
32091 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32092 };
32093
32094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32096 if (!SWIG_IsOK(res1)) {
32097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32098 }
32099 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32100 ecode2 = SWIG_AsVal_int(obj1, &val2);
32101 if (!SWIG_IsOK(ecode2)) {
32102 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32103 }
32104 arg2 = static_cast< int >(val2);
32105 ecode3 = SWIG_AsVal_int(obj2, &val3);
32106 if (!SWIG_IsOK(ecode3)) {
32107 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32108 }
32109 arg3 = static_cast< int >(val3);
32110 ecode4 = SWIG_AsVal_int(obj3, &val4);
32111 if (!SWIG_IsOK(ecode4)) {
32112 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32113 }
32114 arg4 = static_cast< int >(val4);
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 (arg1)->Set(arg2,arg3,arg4);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_Py_Void();
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32129 PyObject *resultobj = 0;
32130 wxString *arg1 = 0 ;
32131 wxAcceleratorEntry *result = 0 ;
32132 bool temp1 = false ;
32133 PyObject * obj0 = 0 ;
32134 char * kwnames[] = {
32135 (char *) "str", NULL
32136 };
32137
32138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32139 {
32140 arg1 = wxString_in_helper(obj0);
32141 if (arg1 == NULL) SWIG_fail;
32142 temp1 = true;
32143 }
32144 {
32145 PyThreadState* __tstate = wxPyBeginAllowThreads();
32146 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32147 wxPyEndAllowThreads(__tstate);
32148 if (PyErr_Occurred()) SWIG_fail;
32149 }
32150 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32151 {
32152 if (temp1)
32153 delete arg1;
32154 }
32155 return resultobj;
32156 fail:
32157 {
32158 if (temp1)
32159 delete arg1;
32160 }
32161 return NULL;
32162 }
32163
32164
32165 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32166 PyObject *resultobj = 0;
32167 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32168 int result;
32169 void *argp1 = 0 ;
32170 int res1 = 0 ;
32171 PyObject *swig_obj[1] ;
32172
32173 if (!args) SWIG_fail;
32174 swig_obj[0] = args;
32175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32176 if (!SWIG_IsOK(res1)) {
32177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32178 }
32179 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32180 {
32181 PyThreadState* __tstate = wxPyBeginAllowThreads();
32182 result = (int)(arg1)->GetFlags();
32183 wxPyEndAllowThreads(__tstate);
32184 if (PyErr_Occurred()) SWIG_fail;
32185 }
32186 resultobj = SWIG_From_int(static_cast< int >(result));
32187 return resultobj;
32188 fail:
32189 return NULL;
32190 }
32191
32192
32193 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32194 PyObject *resultobj = 0;
32195 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32196 int result;
32197 void *argp1 = 0 ;
32198 int res1 = 0 ;
32199 PyObject *swig_obj[1] ;
32200
32201 if (!args) SWIG_fail;
32202 swig_obj[0] = args;
32203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32204 if (!SWIG_IsOK(res1)) {
32205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32206 }
32207 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32208 {
32209 PyThreadState* __tstate = wxPyBeginAllowThreads();
32210 result = (int)(arg1)->GetKeyCode();
32211 wxPyEndAllowThreads(__tstate);
32212 if (PyErr_Occurred()) SWIG_fail;
32213 }
32214 resultobj = SWIG_From_int(static_cast< int >(result));
32215 return resultobj;
32216 fail:
32217 return NULL;
32218 }
32219
32220
32221 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32222 PyObject *resultobj = 0;
32223 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32224 int result;
32225 void *argp1 = 0 ;
32226 int res1 = 0 ;
32227 PyObject *swig_obj[1] ;
32228
32229 if (!args) SWIG_fail;
32230 swig_obj[0] = args;
32231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32232 if (!SWIG_IsOK(res1)) {
32233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32234 }
32235 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32236 {
32237 PyThreadState* __tstate = wxPyBeginAllowThreads();
32238 result = (int)(arg1)->GetCommand();
32239 wxPyEndAllowThreads(__tstate);
32240 if (PyErr_Occurred()) SWIG_fail;
32241 }
32242 resultobj = SWIG_From_int(static_cast< int >(result));
32243 return resultobj;
32244 fail:
32245 return NULL;
32246 }
32247
32248
32249 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32250 PyObject *resultobj = 0;
32251 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32252 bool result;
32253 void *argp1 = 0 ;
32254 int res1 = 0 ;
32255 PyObject *swig_obj[1] ;
32256
32257 if (!args) SWIG_fail;
32258 swig_obj[0] = args;
32259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32260 if (!SWIG_IsOK(res1)) {
32261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32262 }
32263 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32264 {
32265 PyThreadState* __tstate = wxPyBeginAllowThreads();
32266 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32267 wxPyEndAllowThreads(__tstate);
32268 if (PyErr_Occurred()) SWIG_fail;
32269 }
32270 {
32271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32272 }
32273 return resultobj;
32274 fail:
32275 return NULL;
32276 }
32277
32278
32279 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32280 PyObject *resultobj = 0;
32281 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32282 wxString result;
32283 void *argp1 = 0 ;
32284 int res1 = 0 ;
32285 PyObject *swig_obj[1] ;
32286
32287 if (!args) SWIG_fail;
32288 swig_obj[0] = args;
32289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32290 if (!SWIG_IsOK(res1)) {
32291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32292 }
32293 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32294 {
32295 PyThreadState* __tstate = wxPyBeginAllowThreads();
32296 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32297 wxPyEndAllowThreads(__tstate);
32298 if (PyErr_Occurred()) SWIG_fail;
32299 }
32300 {
32301 #if wxUSE_UNICODE
32302 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32303 #else
32304 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32305 #endif
32306 }
32307 return resultobj;
32308 fail:
32309 return NULL;
32310 }
32311
32312
32313 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32314 PyObject *resultobj = 0;
32315 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32316 wxString *arg2 = 0 ;
32317 bool result;
32318 void *argp1 = 0 ;
32319 int res1 = 0 ;
32320 bool temp2 = false ;
32321 PyObject * obj0 = 0 ;
32322 PyObject * obj1 = 0 ;
32323 char * kwnames[] = {
32324 (char *) "self",(char *) "str", NULL
32325 };
32326
32327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32329 if (!SWIG_IsOK(res1)) {
32330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32331 }
32332 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32333 {
32334 arg2 = wxString_in_helper(obj1);
32335 if (arg2 == NULL) SWIG_fail;
32336 temp2 = true;
32337 }
32338 {
32339 PyThreadState* __tstate = wxPyBeginAllowThreads();
32340 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32341 wxPyEndAllowThreads(__tstate);
32342 if (PyErr_Occurred()) SWIG_fail;
32343 }
32344 {
32345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32346 }
32347 {
32348 if (temp2)
32349 delete arg2;
32350 }
32351 return resultobj;
32352 fail:
32353 {
32354 if (temp2)
32355 delete arg2;
32356 }
32357 return NULL;
32358 }
32359
32360
32361 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32362 PyObject *obj;
32363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32364 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32365 return SWIG_Py_Void();
32366 }
32367
32368 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32369 return SWIG_Python_InitShadowInstance(args);
32370 }
32371
32372 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32373 PyObject *resultobj = 0;
32374 int arg1 ;
32375 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32376 wxAcceleratorTable *result = 0 ;
32377 PyObject * obj0 = 0 ;
32378 char * kwnames[] = {
32379 (char *) "n", NULL
32380 };
32381
32382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32383 {
32384 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32385 if (arg2) arg1 = PyList_Size(obj0);
32386 else arg1 = 0;
32387 }
32388 {
32389 PyThreadState* __tstate = wxPyBeginAllowThreads();
32390 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32391 wxPyEndAllowThreads(__tstate);
32392 if (PyErr_Occurred()) SWIG_fail;
32393 }
32394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32395 return resultobj;
32396 fail:
32397 return NULL;
32398 }
32399
32400
32401 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32402 PyObject *resultobj = 0;
32403 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32404 void *argp1 = 0 ;
32405 int res1 = 0 ;
32406 PyObject *swig_obj[1] ;
32407
32408 if (!args) SWIG_fail;
32409 swig_obj[0] = args;
32410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32411 if (!SWIG_IsOK(res1)) {
32412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32413 }
32414 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32415 {
32416 PyThreadState* __tstate = wxPyBeginAllowThreads();
32417 delete arg1;
32418
32419 wxPyEndAllowThreads(__tstate);
32420 if (PyErr_Occurred()) SWIG_fail;
32421 }
32422 resultobj = SWIG_Py_Void();
32423 return resultobj;
32424 fail:
32425 return NULL;
32426 }
32427
32428
32429 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32430 PyObject *resultobj = 0;
32431 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32432 bool result;
32433 void *argp1 = 0 ;
32434 int res1 = 0 ;
32435 PyObject *swig_obj[1] ;
32436
32437 if (!args) SWIG_fail;
32438 swig_obj[0] = args;
32439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32440 if (!SWIG_IsOK(res1)) {
32441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32442 }
32443 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32444 {
32445 PyThreadState* __tstate = wxPyBeginAllowThreads();
32446 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32447 wxPyEndAllowThreads(__tstate);
32448 if (PyErr_Occurred()) SWIG_fail;
32449 }
32450 {
32451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32452 }
32453 return resultobj;
32454 fail:
32455 return NULL;
32456 }
32457
32458
32459 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32460 PyObject *obj;
32461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32462 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32463 return SWIG_Py_Void();
32464 }
32465
32466 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32467 return SWIG_Python_InitShadowInstance(args);
32468 }
32469
32470 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32471 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32472 return 1;
32473 }
32474
32475
32476 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32477 PyObject *pyobj = 0;
32478
32479 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32480 return pyobj;
32481 }
32482
32483
32484 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32485 PyObject *resultobj = 0;
32486 wxString *arg1 = 0 ;
32487 wxAcceleratorEntry *result = 0 ;
32488 bool temp1 = false ;
32489 PyObject * obj0 = 0 ;
32490 char * kwnames[] = {
32491 (char *) "label", NULL
32492 };
32493
32494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32495 {
32496 arg1 = wxString_in_helper(obj0);
32497 if (arg1 == NULL) SWIG_fail;
32498 temp1 = true;
32499 }
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32503 wxPyEndAllowThreads(__tstate);
32504 if (PyErr_Occurred()) SWIG_fail;
32505 }
32506 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32507 {
32508 if (temp1)
32509 delete arg1;
32510 }
32511 return resultobj;
32512 fail:
32513 {
32514 if (temp1)
32515 delete arg1;
32516 }
32517 return NULL;
32518 }
32519
32520
32521 SWIGINTERN int PanelNameStr_set(PyObject *) {
32522 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32523 return 1;
32524 }
32525
32526
32527 SWIGINTERN PyObject *PanelNameStr_get(void) {
32528 PyObject *pyobj = 0;
32529
32530 {
32531 #if wxUSE_UNICODE
32532 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32533 #else
32534 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32535 #endif
32536 }
32537 return pyobj;
32538 }
32539
32540
32541 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32542 PyObject *resultobj = 0;
32543 wxVisualAttributes *result = 0 ;
32544
32545 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32546 {
32547 PyThreadState* __tstate = wxPyBeginAllowThreads();
32548 result = (wxVisualAttributes *)new_wxVisualAttributes();
32549 wxPyEndAllowThreads(__tstate);
32550 if (PyErr_Occurred()) SWIG_fail;
32551 }
32552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32553 return resultobj;
32554 fail:
32555 return NULL;
32556 }
32557
32558
32559 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32560 PyObject *resultobj = 0;
32561 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32562 void *argp1 = 0 ;
32563 int res1 = 0 ;
32564 PyObject *swig_obj[1] ;
32565
32566 if (!args) SWIG_fail;
32567 swig_obj[0] = args;
32568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32569 if (!SWIG_IsOK(res1)) {
32570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32571 }
32572 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32573 {
32574 PyThreadState* __tstate = wxPyBeginAllowThreads();
32575 delete_wxVisualAttributes(arg1);
32576
32577 wxPyEndAllowThreads(__tstate);
32578 if (PyErr_Occurred()) SWIG_fail;
32579 }
32580 resultobj = SWIG_Py_Void();
32581 return resultobj;
32582 fail:
32583 return NULL;
32584 }
32585
32586
32587 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32588 PyObject *resultobj = 0;
32589 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32590 wxFont *arg2 = (wxFont *) 0 ;
32591 void *argp1 = 0 ;
32592 int res1 = 0 ;
32593 void *argp2 = 0 ;
32594 int res2 = 0 ;
32595 PyObject *swig_obj[2] ;
32596
32597 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32599 if (!SWIG_IsOK(res1)) {
32600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32601 }
32602 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32603 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32604 if (!SWIG_IsOK(res2)) {
32605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32606 }
32607 arg2 = reinterpret_cast< wxFont * >(argp2);
32608 if (arg1) (arg1)->font = *arg2;
32609
32610 resultobj = SWIG_Py_Void();
32611 return resultobj;
32612 fail:
32613 return NULL;
32614 }
32615
32616
32617 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32618 PyObject *resultobj = 0;
32619 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32620 wxFont *result = 0 ;
32621 void *argp1 = 0 ;
32622 int res1 = 0 ;
32623 PyObject *swig_obj[1] ;
32624
32625 if (!args) SWIG_fail;
32626 swig_obj[0] = args;
32627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32628 if (!SWIG_IsOK(res1)) {
32629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32630 }
32631 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32632 result = (wxFont *)& ((arg1)->font);
32633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32634 return resultobj;
32635 fail:
32636 return NULL;
32637 }
32638
32639
32640 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32641 PyObject *resultobj = 0;
32642 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32643 wxColour *arg2 = (wxColour *) 0 ;
32644 void *argp1 = 0 ;
32645 int res1 = 0 ;
32646 void *argp2 = 0 ;
32647 int res2 = 0 ;
32648 PyObject *swig_obj[2] ;
32649
32650 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32652 if (!SWIG_IsOK(res1)) {
32653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32654 }
32655 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32656 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32657 if (!SWIG_IsOK(res2)) {
32658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32659 }
32660 arg2 = reinterpret_cast< wxColour * >(argp2);
32661 if (arg1) (arg1)->colFg = *arg2;
32662
32663 resultobj = SWIG_Py_Void();
32664 return resultobj;
32665 fail:
32666 return NULL;
32667 }
32668
32669
32670 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32671 PyObject *resultobj = 0;
32672 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32673 wxColour *result = 0 ;
32674 void *argp1 = 0 ;
32675 int res1 = 0 ;
32676 PyObject *swig_obj[1] ;
32677
32678 if (!args) SWIG_fail;
32679 swig_obj[0] = args;
32680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32681 if (!SWIG_IsOK(res1)) {
32682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32683 }
32684 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32685 result = (wxColour *)& ((arg1)->colFg);
32686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32687 return resultobj;
32688 fail:
32689 return NULL;
32690 }
32691
32692
32693 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32694 PyObject *resultobj = 0;
32695 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32696 wxColour *arg2 = (wxColour *) 0 ;
32697 void *argp1 = 0 ;
32698 int res1 = 0 ;
32699 void *argp2 = 0 ;
32700 int res2 = 0 ;
32701 PyObject *swig_obj[2] ;
32702
32703 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32705 if (!SWIG_IsOK(res1)) {
32706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32707 }
32708 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32709 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32710 if (!SWIG_IsOK(res2)) {
32711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32712 }
32713 arg2 = reinterpret_cast< wxColour * >(argp2);
32714 if (arg1) (arg1)->colBg = *arg2;
32715
32716 resultobj = SWIG_Py_Void();
32717 return resultobj;
32718 fail:
32719 return NULL;
32720 }
32721
32722
32723 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32724 PyObject *resultobj = 0;
32725 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32726 wxColour *result = 0 ;
32727 void *argp1 = 0 ;
32728 int res1 = 0 ;
32729 PyObject *swig_obj[1] ;
32730
32731 if (!args) SWIG_fail;
32732 swig_obj[0] = args;
32733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32734 if (!SWIG_IsOK(res1)) {
32735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32736 }
32737 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32738 result = (wxColour *)& ((arg1)->colBg);
32739 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32740 return resultobj;
32741 fail:
32742 return NULL;
32743 }
32744
32745
32746 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32747 PyObject *obj;
32748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32749 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32750 return SWIG_Py_Void();
32751 }
32752
32753 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32754 return SWIG_Python_InitShadowInstance(args);
32755 }
32756
32757 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32758 PyObject *resultobj = 0;
32759 wxWindow *arg1 = (wxWindow *) 0 ;
32760 int arg2 = (int) (int)-1 ;
32761 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32762 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32763 wxSize const &arg4_defvalue = wxDefaultSize ;
32764 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32765 long arg5 = (long) 0 ;
32766 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32767 wxString *arg6 = (wxString *) &arg6_defvalue ;
32768 wxWindow *result = 0 ;
32769 void *argp1 = 0 ;
32770 int res1 = 0 ;
32771 int val2 ;
32772 int ecode2 = 0 ;
32773 wxPoint temp3 ;
32774 wxSize temp4 ;
32775 long val5 ;
32776 int ecode5 = 0 ;
32777 bool temp6 = false ;
32778 PyObject * obj0 = 0 ;
32779 PyObject * obj1 = 0 ;
32780 PyObject * obj2 = 0 ;
32781 PyObject * obj3 = 0 ;
32782 PyObject * obj4 = 0 ;
32783 PyObject * obj5 = 0 ;
32784 char * kwnames[] = {
32785 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32786 };
32787
32788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32790 if (!SWIG_IsOK(res1)) {
32791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32792 }
32793 arg1 = reinterpret_cast< wxWindow * >(argp1);
32794 if (obj1) {
32795 ecode2 = SWIG_AsVal_int(obj1, &val2);
32796 if (!SWIG_IsOK(ecode2)) {
32797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32798 }
32799 arg2 = static_cast< int >(val2);
32800 }
32801 if (obj2) {
32802 {
32803 arg3 = &temp3;
32804 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32805 }
32806 }
32807 if (obj3) {
32808 {
32809 arg4 = &temp4;
32810 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32811 }
32812 }
32813 if (obj4) {
32814 ecode5 = SWIG_AsVal_long(obj4, &val5);
32815 if (!SWIG_IsOK(ecode5)) {
32816 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32817 }
32818 arg5 = static_cast< long >(val5);
32819 }
32820 if (obj5) {
32821 {
32822 arg6 = wxString_in_helper(obj5);
32823 if (arg6 == NULL) SWIG_fail;
32824 temp6 = true;
32825 }
32826 }
32827 {
32828 if (!wxPyCheckForApp()) SWIG_fail;
32829 PyThreadState* __tstate = wxPyBeginAllowThreads();
32830 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32831 wxPyEndAllowThreads(__tstate);
32832 if (PyErr_Occurred()) SWIG_fail;
32833 }
32834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32835 {
32836 if (temp6)
32837 delete arg6;
32838 }
32839 return resultobj;
32840 fail:
32841 {
32842 if (temp6)
32843 delete arg6;
32844 }
32845 return NULL;
32846 }
32847
32848
32849 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32850 PyObject *resultobj = 0;
32851 wxWindow *result = 0 ;
32852
32853 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32854 {
32855 if (!wxPyCheckForApp()) SWIG_fail;
32856 PyThreadState* __tstate = wxPyBeginAllowThreads();
32857 result = (wxWindow *)new wxWindow();
32858 wxPyEndAllowThreads(__tstate);
32859 if (PyErr_Occurred()) SWIG_fail;
32860 }
32861 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32862 return resultobj;
32863 fail:
32864 return NULL;
32865 }
32866
32867
32868 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32869 PyObject *resultobj = 0;
32870 wxWindow *arg1 = (wxWindow *) 0 ;
32871 wxWindow *arg2 = (wxWindow *) 0 ;
32872 int arg3 = (int) (int)-1 ;
32873 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32874 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32875 wxSize const &arg5_defvalue = wxDefaultSize ;
32876 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32877 long arg6 = (long) 0 ;
32878 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32879 wxString *arg7 = (wxString *) &arg7_defvalue ;
32880 bool result;
32881 void *argp1 = 0 ;
32882 int res1 = 0 ;
32883 void *argp2 = 0 ;
32884 int res2 = 0 ;
32885 int val3 ;
32886 int ecode3 = 0 ;
32887 wxPoint temp4 ;
32888 wxSize temp5 ;
32889 long val6 ;
32890 int ecode6 = 0 ;
32891 bool temp7 = false ;
32892 PyObject * obj0 = 0 ;
32893 PyObject * obj1 = 0 ;
32894 PyObject * obj2 = 0 ;
32895 PyObject * obj3 = 0 ;
32896 PyObject * obj4 = 0 ;
32897 PyObject * obj5 = 0 ;
32898 PyObject * obj6 = 0 ;
32899 char * kwnames[] = {
32900 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32901 };
32902
32903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32905 if (!SWIG_IsOK(res1)) {
32906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32907 }
32908 arg1 = reinterpret_cast< wxWindow * >(argp1);
32909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32910 if (!SWIG_IsOK(res2)) {
32911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32912 }
32913 arg2 = reinterpret_cast< wxWindow * >(argp2);
32914 if (obj2) {
32915 ecode3 = SWIG_AsVal_int(obj2, &val3);
32916 if (!SWIG_IsOK(ecode3)) {
32917 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32918 }
32919 arg3 = static_cast< int >(val3);
32920 }
32921 if (obj3) {
32922 {
32923 arg4 = &temp4;
32924 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32925 }
32926 }
32927 if (obj4) {
32928 {
32929 arg5 = &temp5;
32930 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32931 }
32932 }
32933 if (obj5) {
32934 ecode6 = SWIG_AsVal_long(obj5, &val6);
32935 if (!SWIG_IsOK(ecode6)) {
32936 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32937 }
32938 arg6 = static_cast< long >(val6);
32939 }
32940 if (obj6) {
32941 {
32942 arg7 = wxString_in_helper(obj6);
32943 if (arg7 == NULL) SWIG_fail;
32944 temp7 = true;
32945 }
32946 }
32947 {
32948 PyThreadState* __tstate = wxPyBeginAllowThreads();
32949 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32950 wxPyEndAllowThreads(__tstate);
32951 if (PyErr_Occurred()) SWIG_fail;
32952 }
32953 {
32954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32955 }
32956 {
32957 if (temp7)
32958 delete arg7;
32959 }
32960 return resultobj;
32961 fail:
32962 {
32963 if (temp7)
32964 delete arg7;
32965 }
32966 return NULL;
32967 }
32968
32969
32970 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32971 PyObject *resultobj = 0;
32972 wxWindow *arg1 = (wxWindow *) 0 ;
32973 bool arg2 = (bool) false ;
32974 bool result;
32975 void *argp1 = 0 ;
32976 int res1 = 0 ;
32977 bool val2 ;
32978 int ecode2 = 0 ;
32979 PyObject * obj0 = 0 ;
32980 PyObject * obj1 = 0 ;
32981 char * kwnames[] = {
32982 (char *) "self",(char *) "force", NULL
32983 };
32984
32985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32987 if (!SWIG_IsOK(res1)) {
32988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32989 }
32990 arg1 = reinterpret_cast< wxWindow * >(argp1);
32991 if (obj1) {
32992 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32993 if (!SWIG_IsOK(ecode2)) {
32994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32995 }
32996 arg2 = static_cast< bool >(val2);
32997 }
32998 {
32999 PyThreadState* __tstate = wxPyBeginAllowThreads();
33000 result = (bool)(arg1)->Close(arg2);
33001 wxPyEndAllowThreads(__tstate);
33002 if (PyErr_Occurred()) SWIG_fail;
33003 }
33004 {
33005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33006 }
33007 return resultobj;
33008 fail:
33009 return NULL;
33010 }
33011
33012
33013 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33014 PyObject *resultobj = 0;
33015 wxWindow *arg1 = (wxWindow *) 0 ;
33016 bool result;
33017 void *argp1 = 0 ;
33018 int res1 = 0 ;
33019 PyObject *swig_obj[1] ;
33020
33021 if (!args) SWIG_fail;
33022 swig_obj[0] = args;
33023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33024 if (!SWIG_IsOK(res1)) {
33025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33026 }
33027 arg1 = reinterpret_cast< wxWindow * >(argp1);
33028 {
33029 PyThreadState* __tstate = wxPyBeginAllowThreads();
33030 result = (bool)(arg1)->Destroy();
33031 wxPyEndAllowThreads(__tstate);
33032 if (PyErr_Occurred()) SWIG_fail;
33033 }
33034 {
33035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33036 }
33037 return resultobj;
33038 fail:
33039 return NULL;
33040 }
33041
33042
33043 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33044 PyObject *resultobj = 0;
33045 wxWindow *arg1 = (wxWindow *) 0 ;
33046 bool result;
33047 void *argp1 = 0 ;
33048 int res1 = 0 ;
33049 PyObject *swig_obj[1] ;
33050
33051 if (!args) SWIG_fail;
33052 swig_obj[0] = args;
33053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33054 if (!SWIG_IsOK(res1)) {
33055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33056 }
33057 arg1 = reinterpret_cast< wxWindow * >(argp1);
33058 {
33059 PyThreadState* __tstate = wxPyBeginAllowThreads();
33060 result = (bool)(arg1)->DestroyChildren();
33061 wxPyEndAllowThreads(__tstate);
33062 if (PyErr_Occurred()) SWIG_fail;
33063 }
33064 {
33065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33066 }
33067 return resultobj;
33068 fail:
33069 return NULL;
33070 }
33071
33072
33073 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33074 PyObject *resultobj = 0;
33075 wxWindow *arg1 = (wxWindow *) 0 ;
33076 bool result;
33077 void *argp1 = 0 ;
33078 int res1 = 0 ;
33079 PyObject *swig_obj[1] ;
33080
33081 if (!args) SWIG_fail;
33082 swig_obj[0] = args;
33083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33084 if (!SWIG_IsOK(res1)) {
33085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33086 }
33087 arg1 = reinterpret_cast< wxWindow * >(argp1);
33088 {
33089 PyThreadState* __tstate = wxPyBeginAllowThreads();
33090 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33091 wxPyEndAllowThreads(__tstate);
33092 if (PyErr_Occurred()) SWIG_fail;
33093 }
33094 {
33095 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33096 }
33097 return resultobj;
33098 fail:
33099 return NULL;
33100 }
33101
33102
33103 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33104 PyObject *resultobj = 0;
33105 wxWindow *arg1 = (wxWindow *) 0 ;
33106 wxString *arg2 = 0 ;
33107 void *argp1 = 0 ;
33108 int res1 = 0 ;
33109 bool temp2 = false ;
33110 PyObject * obj0 = 0 ;
33111 PyObject * obj1 = 0 ;
33112 char * kwnames[] = {
33113 (char *) "self",(char *) "label", NULL
33114 };
33115
33116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33118 if (!SWIG_IsOK(res1)) {
33119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33120 }
33121 arg1 = reinterpret_cast< wxWindow * >(argp1);
33122 {
33123 arg2 = wxString_in_helper(obj1);
33124 if (arg2 == NULL) SWIG_fail;
33125 temp2 = true;
33126 }
33127 {
33128 PyThreadState* __tstate = wxPyBeginAllowThreads();
33129 (arg1)->SetLabel((wxString const &)*arg2);
33130 wxPyEndAllowThreads(__tstate);
33131 if (PyErr_Occurred()) SWIG_fail;
33132 }
33133 resultobj = SWIG_Py_Void();
33134 {
33135 if (temp2)
33136 delete arg2;
33137 }
33138 return resultobj;
33139 fail:
33140 {
33141 if (temp2)
33142 delete arg2;
33143 }
33144 return NULL;
33145 }
33146
33147
33148 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33149 PyObject *resultobj = 0;
33150 wxWindow *arg1 = (wxWindow *) 0 ;
33151 wxString result;
33152 void *argp1 = 0 ;
33153 int res1 = 0 ;
33154 PyObject *swig_obj[1] ;
33155
33156 if (!args) SWIG_fail;
33157 swig_obj[0] = args;
33158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33159 if (!SWIG_IsOK(res1)) {
33160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33161 }
33162 arg1 = reinterpret_cast< wxWindow * >(argp1);
33163 {
33164 PyThreadState* __tstate = wxPyBeginAllowThreads();
33165 result = ((wxWindow const *)arg1)->GetLabel();
33166 wxPyEndAllowThreads(__tstate);
33167 if (PyErr_Occurred()) SWIG_fail;
33168 }
33169 {
33170 #if wxUSE_UNICODE
33171 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33172 #else
33173 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33174 #endif
33175 }
33176 return resultobj;
33177 fail:
33178 return NULL;
33179 }
33180
33181
33182 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33183 PyObject *resultobj = 0;
33184 wxWindow *arg1 = (wxWindow *) 0 ;
33185 wxString *arg2 = 0 ;
33186 void *argp1 = 0 ;
33187 int res1 = 0 ;
33188 bool temp2 = false ;
33189 PyObject * obj0 = 0 ;
33190 PyObject * obj1 = 0 ;
33191 char * kwnames[] = {
33192 (char *) "self",(char *) "name", NULL
33193 };
33194
33195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33197 if (!SWIG_IsOK(res1)) {
33198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33199 }
33200 arg1 = reinterpret_cast< wxWindow * >(argp1);
33201 {
33202 arg2 = wxString_in_helper(obj1);
33203 if (arg2 == NULL) SWIG_fail;
33204 temp2 = true;
33205 }
33206 {
33207 PyThreadState* __tstate = wxPyBeginAllowThreads();
33208 (arg1)->SetName((wxString const &)*arg2);
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 resultobj = SWIG_Py_Void();
33213 {
33214 if (temp2)
33215 delete arg2;
33216 }
33217 return resultobj;
33218 fail:
33219 {
33220 if (temp2)
33221 delete arg2;
33222 }
33223 return NULL;
33224 }
33225
33226
33227 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 wxString result;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 PyObject *swig_obj[1] ;
33234
33235 if (!args) SWIG_fail;
33236 swig_obj[0] = args;
33237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33238 if (!SWIG_IsOK(res1)) {
33239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33240 }
33241 arg1 = reinterpret_cast< wxWindow * >(argp1);
33242 {
33243 PyThreadState* __tstate = wxPyBeginAllowThreads();
33244 result = ((wxWindow const *)arg1)->GetName();
33245 wxPyEndAllowThreads(__tstate);
33246 if (PyErr_Occurred()) SWIG_fail;
33247 }
33248 {
33249 #if wxUSE_UNICODE
33250 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33251 #else
33252 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33253 #endif
33254 }
33255 return resultobj;
33256 fail:
33257 return NULL;
33258 }
33259
33260
33261 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33262 PyObject *resultobj = 0;
33263 wxWindow *arg1 = (wxWindow *) 0 ;
33264 wxWindowVariant arg2 ;
33265 void *argp1 = 0 ;
33266 int res1 = 0 ;
33267 int val2 ;
33268 int ecode2 = 0 ;
33269 PyObject * obj0 = 0 ;
33270 PyObject * obj1 = 0 ;
33271 char * kwnames[] = {
33272 (char *) "self",(char *) "variant", NULL
33273 };
33274
33275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33277 if (!SWIG_IsOK(res1)) {
33278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33279 }
33280 arg1 = reinterpret_cast< wxWindow * >(argp1);
33281 ecode2 = SWIG_AsVal_int(obj1, &val2);
33282 if (!SWIG_IsOK(ecode2)) {
33283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33284 }
33285 arg2 = static_cast< wxWindowVariant >(val2);
33286 {
33287 PyThreadState* __tstate = wxPyBeginAllowThreads();
33288 (arg1)->SetWindowVariant(arg2);
33289 wxPyEndAllowThreads(__tstate);
33290 if (PyErr_Occurred()) SWIG_fail;
33291 }
33292 resultobj = SWIG_Py_Void();
33293 return resultobj;
33294 fail:
33295 return NULL;
33296 }
33297
33298
33299 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33300 PyObject *resultobj = 0;
33301 wxWindow *arg1 = (wxWindow *) 0 ;
33302 wxWindowVariant result;
33303 void *argp1 = 0 ;
33304 int res1 = 0 ;
33305 PyObject *swig_obj[1] ;
33306
33307 if (!args) SWIG_fail;
33308 swig_obj[0] = args;
33309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33310 if (!SWIG_IsOK(res1)) {
33311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33312 }
33313 arg1 = reinterpret_cast< wxWindow * >(argp1);
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33317 wxPyEndAllowThreads(__tstate);
33318 if (PyErr_Occurred()) SWIG_fail;
33319 }
33320 resultobj = SWIG_From_int(static_cast< int >(result));
33321 return resultobj;
33322 fail:
33323 return NULL;
33324 }
33325
33326
33327 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33328 PyObject *resultobj = 0;
33329 wxWindow *arg1 = (wxWindow *) 0 ;
33330 int arg2 ;
33331 void *argp1 = 0 ;
33332 int res1 = 0 ;
33333 int val2 ;
33334 int ecode2 = 0 ;
33335 PyObject * obj0 = 0 ;
33336 PyObject * obj1 = 0 ;
33337 char * kwnames[] = {
33338 (char *) "self",(char *) "winid", NULL
33339 };
33340
33341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33343 if (!SWIG_IsOK(res1)) {
33344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33345 }
33346 arg1 = reinterpret_cast< wxWindow * >(argp1);
33347 ecode2 = SWIG_AsVal_int(obj1, &val2);
33348 if (!SWIG_IsOK(ecode2)) {
33349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33350 }
33351 arg2 = static_cast< int >(val2);
33352 {
33353 PyThreadState* __tstate = wxPyBeginAllowThreads();
33354 (arg1)->SetId(arg2);
33355 wxPyEndAllowThreads(__tstate);
33356 if (PyErr_Occurred()) SWIG_fail;
33357 }
33358 resultobj = SWIG_Py_Void();
33359 return resultobj;
33360 fail:
33361 return NULL;
33362 }
33363
33364
33365 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33366 PyObject *resultobj = 0;
33367 wxWindow *arg1 = (wxWindow *) 0 ;
33368 int result;
33369 void *argp1 = 0 ;
33370 int res1 = 0 ;
33371 PyObject *swig_obj[1] ;
33372
33373 if (!args) SWIG_fail;
33374 swig_obj[0] = args;
33375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33376 if (!SWIG_IsOK(res1)) {
33377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33378 }
33379 arg1 = reinterpret_cast< wxWindow * >(argp1);
33380 {
33381 PyThreadState* __tstate = wxPyBeginAllowThreads();
33382 result = (int)((wxWindow const *)arg1)->GetId();
33383 wxPyEndAllowThreads(__tstate);
33384 if (PyErr_Occurred()) SWIG_fail;
33385 }
33386 resultobj = SWIG_From_int(static_cast< int >(result));
33387 return resultobj;
33388 fail:
33389 return NULL;
33390 }
33391
33392
33393 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33394 PyObject *resultobj = 0;
33395 int result;
33396
33397 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33398 {
33399 PyThreadState* __tstate = wxPyBeginAllowThreads();
33400 result = (int)wxWindow::NewControlId();
33401 wxPyEndAllowThreads(__tstate);
33402 if (PyErr_Occurred()) SWIG_fail;
33403 }
33404 resultobj = SWIG_From_int(static_cast< int >(result));
33405 return resultobj;
33406 fail:
33407 return NULL;
33408 }
33409
33410
33411 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33412 PyObject *resultobj = 0;
33413 int arg1 ;
33414 int result;
33415 int val1 ;
33416 int ecode1 = 0 ;
33417 PyObject * obj0 = 0 ;
33418 char * kwnames[] = {
33419 (char *) "winid", NULL
33420 };
33421
33422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33423 ecode1 = SWIG_AsVal_int(obj0, &val1);
33424 if (!SWIG_IsOK(ecode1)) {
33425 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33426 }
33427 arg1 = static_cast< int >(val1);
33428 {
33429 PyThreadState* __tstate = wxPyBeginAllowThreads();
33430 result = (int)wxWindow::NextControlId(arg1);
33431 wxPyEndAllowThreads(__tstate);
33432 if (PyErr_Occurred()) SWIG_fail;
33433 }
33434 resultobj = SWIG_From_int(static_cast< int >(result));
33435 return resultobj;
33436 fail:
33437 return NULL;
33438 }
33439
33440
33441 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33442 PyObject *resultobj = 0;
33443 int arg1 ;
33444 int result;
33445 int val1 ;
33446 int ecode1 = 0 ;
33447 PyObject * obj0 = 0 ;
33448 char * kwnames[] = {
33449 (char *) "winid", NULL
33450 };
33451
33452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33453 ecode1 = SWIG_AsVal_int(obj0, &val1);
33454 if (!SWIG_IsOK(ecode1)) {
33455 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33456 }
33457 arg1 = static_cast< int >(val1);
33458 {
33459 PyThreadState* __tstate = wxPyBeginAllowThreads();
33460 result = (int)wxWindow::PrevControlId(arg1);
33461 wxPyEndAllowThreads(__tstate);
33462 if (PyErr_Occurred()) SWIG_fail;
33463 }
33464 resultobj = SWIG_From_int(static_cast< int >(result));
33465 return resultobj;
33466 fail:
33467 return NULL;
33468 }
33469
33470
33471 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33472 PyObject *resultobj = 0;
33473 wxWindow *arg1 = (wxWindow *) 0 ;
33474 wxLayoutDirection result;
33475 void *argp1 = 0 ;
33476 int res1 = 0 ;
33477 PyObject *swig_obj[1] ;
33478
33479 if (!args) SWIG_fail;
33480 swig_obj[0] = args;
33481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33482 if (!SWIG_IsOK(res1)) {
33483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33484 }
33485 arg1 = reinterpret_cast< wxWindow * >(argp1);
33486 {
33487 PyThreadState* __tstate = wxPyBeginAllowThreads();
33488 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33489 wxPyEndAllowThreads(__tstate);
33490 if (PyErr_Occurred()) SWIG_fail;
33491 }
33492 resultobj = SWIG_From_int(static_cast< int >(result));
33493 return resultobj;
33494 fail:
33495 return NULL;
33496 }
33497
33498
33499 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33500 PyObject *resultobj = 0;
33501 wxWindow *arg1 = (wxWindow *) 0 ;
33502 wxLayoutDirection arg2 ;
33503 void *argp1 = 0 ;
33504 int res1 = 0 ;
33505 int val2 ;
33506 int ecode2 = 0 ;
33507 PyObject * obj0 = 0 ;
33508 PyObject * obj1 = 0 ;
33509 char * kwnames[] = {
33510 (char *) "self",(char *) "dir", NULL
33511 };
33512
33513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33515 if (!SWIG_IsOK(res1)) {
33516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33517 }
33518 arg1 = reinterpret_cast< wxWindow * >(argp1);
33519 ecode2 = SWIG_AsVal_int(obj1, &val2);
33520 if (!SWIG_IsOK(ecode2)) {
33521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33522 }
33523 arg2 = static_cast< wxLayoutDirection >(val2);
33524 {
33525 PyThreadState* __tstate = wxPyBeginAllowThreads();
33526 (arg1)->SetLayoutDirection(arg2);
33527 wxPyEndAllowThreads(__tstate);
33528 if (PyErr_Occurred()) SWIG_fail;
33529 }
33530 resultobj = SWIG_Py_Void();
33531 return resultobj;
33532 fail:
33533 return NULL;
33534 }
33535
33536
33537 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33538 PyObject *resultobj = 0;
33539 wxWindow *arg1 = (wxWindow *) 0 ;
33540 int arg2 ;
33541 int arg3 ;
33542 int arg4 ;
33543 int result;
33544 void *argp1 = 0 ;
33545 int res1 = 0 ;
33546 int val2 ;
33547 int ecode2 = 0 ;
33548 int val3 ;
33549 int ecode3 = 0 ;
33550 int val4 ;
33551 int ecode4 = 0 ;
33552 PyObject * obj0 = 0 ;
33553 PyObject * obj1 = 0 ;
33554 PyObject * obj2 = 0 ;
33555 PyObject * obj3 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33562 if (!SWIG_IsOK(res1)) {
33563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33564 }
33565 arg1 = reinterpret_cast< wxWindow * >(argp1);
33566 ecode2 = SWIG_AsVal_int(obj1, &val2);
33567 if (!SWIG_IsOK(ecode2)) {
33568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33569 }
33570 arg2 = static_cast< int >(val2);
33571 ecode3 = SWIG_AsVal_int(obj2, &val3);
33572 if (!SWIG_IsOK(ecode3)) {
33573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33574 }
33575 arg3 = static_cast< int >(val3);
33576 ecode4 = SWIG_AsVal_int(obj3, &val4);
33577 if (!SWIG_IsOK(ecode4)) {
33578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33579 }
33580 arg4 = static_cast< int >(val4);
33581 {
33582 PyThreadState* __tstate = wxPyBeginAllowThreads();
33583 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33584 wxPyEndAllowThreads(__tstate);
33585 if (PyErr_Occurred()) SWIG_fail;
33586 }
33587 resultobj = SWIG_From_int(static_cast< int >(result));
33588 return resultobj;
33589 fail:
33590 return NULL;
33591 }
33592
33593
33594 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33595 PyObject *resultobj = 0;
33596 wxWindow *arg1 = (wxWindow *) 0 ;
33597 wxSize *arg2 = 0 ;
33598 void *argp1 = 0 ;
33599 int res1 = 0 ;
33600 wxSize temp2 ;
33601 PyObject * obj0 = 0 ;
33602 PyObject * obj1 = 0 ;
33603 char * kwnames[] = {
33604 (char *) "self",(char *) "size", NULL
33605 };
33606
33607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33609 if (!SWIG_IsOK(res1)) {
33610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33611 }
33612 arg1 = reinterpret_cast< wxWindow * >(argp1);
33613 {
33614 arg2 = &temp2;
33615 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33616 }
33617 {
33618 PyThreadState* __tstate = wxPyBeginAllowThreads();
33619 (arg1)->SetSize((wxSize const &)*arg2);
33620 wxPyEndAllowThreads(__tstate);
33621 if (PyErr_Occurred()) SWIG_fail;
33622 }
33623 resultobj = SWIG_Py_Void();
33624 return resultobj;
33625 fail:
33626 return NULL;
33627 }
33628
33629
33630 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33631 PyObject *resultobj = 0;
33632 wxWindow *arg1 = (wxWindow *) 0 ;
33633 int arg2 ;
33634 int arg3 ;
33635 int arg4 ;
33636 int arg5 ;
33637 int arg6 = (int) wxSIZE_AUTO ;
33638 void *argp1 = 0 ;
33639 int res1 = 0 ;
33640 int val2 ;
33641 int ecode2 = 0 ;
33642 int val3 ;
33643 int ecode3 = 0 ;
33644 int val4 ;
33645 int ecode4 = 0 ;
33646 int val5 ;
33647 int ecode5 = 0 ;
33648 int val6 ;
33649 int ecode6 = 0 ;
33650 PyObject * obj0 = 0 ;
33651 PyObject * obj1 = 0 ;
33652 PyObject * obj2 = 0 ;
33653 PyObject * obj3 = 0 ;
33654 PyObject * obj4 = 0 ;
33655 PyObject * obj5 = 0 ;
33656 char * kwnames[] = {
33657 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33658 };
33659
33660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33662 if (!SWIG_IsOK(res1)) {
33663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33664 }
33665 arg1 = reinterpret_cast< wxWindow * >(argp1);
33666 ecode2 = SWIG_AsVal_int(obj1, &val2);
33667 if (!SWIG_IsOK(ecode2)) {
33668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33669 }
33670 arg2 = static_cast< int >(val2);
33671 ecode3 = SWIG_AsVal_int(obj2, &val3);
33672 if (!SWIG_IsOK(ecode3)) {
33673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33674 }
33675 arg3 = static_cast< int >(val3);
33676 ecode4 = SWIG_AsVal_int(obj3, &val4);
33677 if (!SWIG_IsOK(ecode4)) {
33678 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33679 }
33680 arg4 = static_cast< int >(val4);
33681 ecode5 = SWIG_AsVal_int(obj4, &val5);
33682 if (!SWIG_IsOK(ecode5)) {
33683 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33684 }
33685 arg5 = static_cast< int >(val5);
33686 if (obj5) {
33687 ecode6 = SWIG_AsVal_int(obj5, &val6);
33688 if (!SWIG_IsOK(ecode6)) {
33689 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33690 }
33691 arg6 = static_cast< int >(val6);
33692 }
33693 {
33694 PyThreadState* __tstate = wxPyBeginAllowThreads();
33695 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33696 wxPyEndAllowThreads(__tstate);
33697 if (PyErr_Occurred()) SWIG_fail;
33698 }
33699 resultobj = SWIG_Py_Void();
33700 return resultobj;
33701 fail:
33702 return NULL;
33703 }
33704
33705
33706 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33707 PyObject *resultobj = 0;
33708 wxWindow *arg1 = (wxWindow *) 0 ;
33709 wxRect *arg2 = 0 ;
33710 int arg3 = (int) wxSIZE_AUTO ;
33711 void *argp1 = 0 ;
33712 int res1 = 0 ;
33713 wxRect temp2 ;
33714 int val3 ;
33715 int ecode3 = 0 ;
33716 PyObject * obj0 = 0 ;
33717 PyObject * obj1 = 0 ;
33718 PyObject * obj2 = 0 ;
33719 char * kwnames[] = {
33720 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33721 };
33722
33723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33725 if (!SWIG_IsOK(res1)) {
33726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33727 }
33728 arg1 = reinterpret_cast< wxWindow * >(argp1);
33729 {
33730 arg2 = &temp2;
33731 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33732 }
33733 if (obj2) {
33734 ecode3 = SWIG_AsVal_int(obj2, &val3);
33735 if (!SWIG_IsOK(ecode3)) {
33736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33737 }
33738 arg3 = static_cast< int >(val3);
33739 }
33740 {
33741 PyThreadState* __tstate = wxPyBeginAllowThreads();
33742 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33743 wxPyEndAllowThreads(__tstate);
33744 if (PyErr_Occurred()) SWIG_fail;
33745 }
33746 resultobj = SWIG_Py_Void();
33747 return resultobj;
33748 fail:
33749 return NULL;
33750 }
33751
33752
33753 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33754 PyObject *resultobj = 0;
33755 wxWindow *arg1 = (wxWindow *) 0 ;
33756 int arg2 ;
33757 int arg3 ;
33758 void *argp1 = 0 ;
33759 int res1 = 0 ;
33760 int val2 ;
33761 int ecode2 = 0 ;
33762 int val3 ;
33763 int ecode3 = 0 ;
33764 PyObject * obj0 = 0 ;
33765 PyObject * obj1 = 0 ;
33766 PyObject * obj2 = 0 ;
33767 char * kwnames[] = {
33768 (char *) "self",(char *) "width",(char *) "height", NULL
33769 };
33770
33771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33773 if (!SWIG_IsOK(res1)) {
33774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33775 }
33776 arg1 = reinterpret_cast< wxWindow * >(argp1);
33777 ecode2 = SWIG_AsVal_int(obj1, &val2);
33778 if (!SWIG_IsOK(ecode2)) {
33779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33780 }
33781 arg2 = static_cast< int >(val2);
33782 ecode3 = SWIG_AsVal_int(obj2, &val3);
33783 if (!SWIG_IsOK(ecode3)) {
33784 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33785 }
33786 arg3 = static_cast< int >(val3);
33787 {
33788 PyThreadState* __tstate = wxPyBeginAllowThreads();
33789 (arg1)->SetSize(arg2,arg3);
33790 wxPyEndAllowThreads(__tstate);
33791 if (PyErr_Occurred()) SWIG_fail;
33792 }
33793 resultobj = SWIG_Py_Void();
33794 return resultobj;
33795 fail:
33796 return NULL;
33797 }
33798
33799
33800 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33801 PyObject *resultobj = 0;
33802 wxWindow *arg1 = (wxWindow *) 0 ;
33803 wxPoint *arg2 = 0 ;
33804 int arg3 = (int) wxSIZE_USE_EXISTING ;
33805 void *argp1 = 0 ;
33806 int res1 = 0 ;
33807 wxPoint temp2 ;
33808 int val3 ;
33809 int ecode3 = 0 ;
33810 PyObject * obj0 = 0 ;
33811 PyObject * obj1 = 0 ;
33812 PyObject * obj2 = 0 ;
33813 char * kwnames[] = {
33814 (char *) "self",(char *) "pt",(char *) "flags", NULL
33815 };
33816
33817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33819 if (!SWIG_IsOK(res1)) {
33820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33821 }
33822 arg1 = reinterpret_cast< wxWindow * >(argp1);
33823 {
33824 arg2 = &temp2;
33825 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33826 }
33827 if (obj2) {
33828 ecode3 = SWIG_AsVal_int(obj2, &val3);
33829 if (!SWIG_IsOK(ecode3)) {
33830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33831 }
33832 arg3 = static_cast< int >(val3);
33833 }
33834 {
33835 PyThreadState* __tstate = wxPyBeginAllowThreads();
33836 (arg1)->Move((wxPoint const &)*arg2,arg3);
33837 wxPyEndAllowThreads(__tstate);
33838 if (PyErr_Occurred()) SWIG_fail;
33839 }
33840 resultobj = SWIG_Py_Void();
33841 return resultobj;
33842 fail:
33843 return NULL;
33844 }
33845
33846
33847 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33848 PyObject *resultobj = 0;
33849 wxWindow *arg1 = (wxWindow *) 0 ;
33850 int arg2 ;
33851 int arg3 ;
33852 int arg4 = (int) wxSIZE_USE_EXISTING ;
33853 void *argp1 = 0 ;
33854 int res1 = 0 ;
33855 int val2 ;
33856 int ecode2 = 0 ;
33857 int val3 ;
33858 int ecode3 = 0 ;
33859 int val4 ;
33860 int ecode4 = 0 ;
33861 PyObject * obj0 = 0 ;
33862 PyObject * obj1 = 0 ;
33863 PyObject * obj2 = 0 ;
33864 PyObject * obj3 = 0 ;
33865 char * kwnames[] = {
33866 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33867 };
33868
33869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33871 if (!SWIG_IsOK(res1)) {
33872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33873 }
33874 arg1 = reinterpret_cast< wxWindow * >(argp1);
33875 ecode2 = SWIG_AsVal_int(obj1, &val2);
33876 if (!SWIG_IsOK(ecode2)) {
33877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33878 }
33879 arg2 = static_cast< int >(val2);
33880 ecode3 = SWIG_AsVal_int(obj2, &val3);
33881 if (!SWIG_IsOK(ecode3)) {
33882 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33883 }
33884 arg3 = static_cast< int >(val3);
33885 if (obj3) {
33886 ecode4 = SWIG_AsVal_int(obj3, &val4);
33887 if (!SWIG_IsOK(ecode4)) {
33888 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33889 }
33890 arg4 = static_cast< int >(val4);
33891 }
33892 {
33893 PyThreadState* __tstate = wxPyBeginAllowThreads();
33894 (arg1)->Move(arg2,arg3,arg4);
33895 wxPyEndAllowThreads(__tstate);
33896 if (PyErr_Occurred()) SWIG_fail;
33897 }
33898 resultobj = SWIG_Py_Void();
33899 return resultobj;
33900 fail:
33901 return NULL;
33902 }
33903
33904
33905 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33906 PyObject *resultobj = 0;
33907 wxWindow *arg1 = (wxWindow *) 0 ;
33908 wxSize const &arg2_defvalue = wxDefaultSize ;
33909 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33910 void *argp1 = 0 ;
33911 int res1 = 0 ;
33912 wxSize temp2 ;
33913 PyObject * obj0 = 0 ;
33914 PyObject * obj1 = 0 ;
33915 char * kwnames[] = {
33916 (char *) "self",(char *) "size", NULL
33917 };
33918
33919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33921 if (!SWIG_IsOK(res1)) {
33922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33923 }
33924 arg1 = reinterpret_cast< wxWindow * >(argp1);
33925 if (obj1) {
33926 {
33927 arg2 = &temp2;
33928 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33929 }
33930 }
33931 {
33932 PyThreadState* __tstate = wxPyBeginAllowThreads();
33933 (arg1)->SetInitialSize((wxSize const &)*arg2);
33934 wxPyEndAllowThreads(__tstate);
33935 if (PyErr_Occurred()) SWIG_fail;
33936 }
33937 resultobj = SWIG_Py_Void();
33938 return resultobj;
33939 fail:
33940 return NULL;
33941 }
33942
33943
33944 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33945 PyObject *resultobj = 0;
33946 wxWindow *arg1 = (wxWindow *) 0 ;
33947 void *argp1 = 0 ;
33948 int res1 = 0 ;
33949 PyObject *swig_obj[1] ;
33950
33951 if (!args) SWIG_fail;
33952 swig_obj[0] = args;
33953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33954 if (!SWIG_IsOK(res1)) {
33955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33956 }
33957 arg1 = reinterpret_cast< wxWindow * >(argp1);
33958 {
33959 PyThreadState* __tstate = wxPyBeginAllowThreads();
33960 (arg1)->Raise();
33961 wxPyEndAllowThreads(__tstate);
33962 if (PyErr_Occurred()) SWIG_fail;
33963 }
33964 resultobj = SWIG_Py_Void();
33965 return resultobj;
33966 fail:
33967 return NULL;
33968 }
33969
33970
33971 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33972 PyObject *resultobj = 0;
33973 wxWindow *arg1 = (wxWindow *) 0 ;
33974 void *argp1 = 0 ;
33975 int res1 = 0 ;
33976 PyObject *swig_obj[1] ;
33977
33978 if (!args) SWIG_fail;
33979 swig_obj[0] = args;
33980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33981 if (!SWIG_IsOK(res1)) {
33982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33983 }
33984 arg1 = reinterpret_cast< wxWindow * >(argp1);
33985 {
33986 PyThreadState* __tstate = wxPyBeginAllowThreads();
33987 (arg1)->Lower();
33988 wxPyEndAllowThreads(__tstate);
33989 if (PyErr_Occurred()) SWIG_fail;
33990 }
33991 resultobj = SWIG_Py_Void();
33992 return resultobj;
33993 fail:
33994 return NULL;
33995 }
33996
33997
33998 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33999 PyObject *resultobj = 0;
34000 wxWindow *arg1 = (wxWindow *) 0 ;
34001 wxSize *arg2 = 0 ;
34002 void *argp1 = 0 ;
34003 int res1 = 0 ;
34004 wxSize temp2 ;
34005 PyObject * obj0 = 0 ;
34006 PyObject * obj1 = 0 ;
34007 char * kwnames[] = {
34008 (char *) "self",(char *) "size", NULL
34009 };
34010
34011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34013 if (!SWIG_IsOK(res1)) {
34014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34015 }
34016 arg1 = reinterpret_cast< wxWindow * >(argp1);
34017 {
34018 arg2 = &temp2;
34019 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34020 }
34021 {
34022 PyThreadState* __tstate = wxPyBeginAllowThreads();
34023 (arg1)->SetClientSize((wxSize const &)*arg2);
34024 wxPyEndAllowThreads(__tstate);
34025 if (PyErr_Occurred()) SWIG_fail;
34026 }
34027 resultobj = SWIG_Py_Void();
34028 return resultobj;
34029 fail:
34030 return NULL;
34031 }
34032
34033
34034 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34035 PyObject *resultobj = 0;
34036 wxWindow *arg1 = (wxWindow *) 0 ;
34037 int arg2 ;
34038 int arg3 ;
34039 void *argp1 = 0 ;
34040 int res1 = 0 ;
34041 int val2 ;
34042 int ecode2 = 0 ;
34043 int val3 ;
34044 int ecode3 = 0 ;
34045 PyObject * obj0 = 0 ;
34046 PyObject * obj1 = 0 ;
34047 PyObject * obj2 = 0 ;
34048 char * kwnames[] = {
34049 (char *) "self",(char *) "width",(char *) "height", NULL
34050 };
34051
34052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34054 if (!SWIG_IsOK(res1)) {
34055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34056 }
34057 arg1 = reinterpret_cast< wxWindow * >(argp1);
34058 ecode2 = SWIG_AsVal_int(obj1, &val2);
34059 if (!SWIG_IsOK(ecode2)) {
34060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34061 }
34062 arg2 = static_cast< int >(val2);
34063 ecode3 = SWIG_AsVal_int(obj2, &val3);
34064 if (!SWIG_IsOK(ecode3)) {
34065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34066 }
34067 arg3 = static_cast< int >(val3);
34068 {
34069 PyThreadState* __tstate = wxPyBeginAllowThreads();
34070 (arg1)->SetClientSize(arg2,arg3);
34071 wxPyEndAllowThreads(__tstate);
34072 if (PyErr_Occurred()) SWIG_fail;
34073 }
34074 resultobj = SWIG_Py_Void();
34075 return resultobj;
34076 fail:
34077 return NULL;
34078 }
34079
34080
34081 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34082 PyObject *resultobj = 0;
34083 wxWindow *arg1 = (wxWindow *) 0 ;
34084 wxRect *arg2 = 0 ;
34085 void *argp1 = 0 ;
34086 int res1 = 0 ;
34087 wxRect temp2 ;
34088 PyObject * obj0 = 0 ;
34089 PyObject * obj1 = 0 ;
34090 char * kwnames[] = {
34091 (char *) "self",(char *) "rect", NULL
34092 };
34093
34094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34096 if (!SWIG_IsOK(res1)) {
34097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34098 }
34099 arg1 = reinterpret_cast< wxWindow * >(argp1);
34100 {
34101 arg2 = &temp2;
34102 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34103 }
34104 {
34105 PyThreadState* __tstate = wxPyBeginAllowThreads();
34106 (arg1)->SetClientSize((wxRect const &)*arg2);
34107 wxPyEndAllowThreads(__tstate);
34108 if (PyErr_Occurred()) SWIG_fail;
34109 }
34110 resultobj = SWIG_Py_Void();
34111 return resultobj;
34112 fail:
34113 return NULL;
34114 }
34115
34116
34117 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34118 PyObject *resultobj = 0;
34119 wxWindow *arg1 = (wxWindow *) 0 ;
34120 wxPoint result;
34121 void *argp1 = 0 ;
34122 int res1 = 0 ;
34123 PyObject *swig_obj[1] ;
34124
34125 if (!args) SWIG_fail;
34126 swig_obj[0] = args;
34127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34128 if (!SWIG_IsOK(res1)) {
34129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34130 }
34131 arg1 = reinterpret_cast< wxWindow * >(argp1);
34132 {
34133 PyThreadState* __tstate = wxPyBeginAllowThreads();
34134 result = ((wxWindow const *)arg1)->GetPosition();
34135 wxPyEndAllowThreads(__tstate);
34136 if (PyErr_Occurred()) SWIG_fail;
34137 }
34138 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34139 return resultobj;
34140 fail:
34141 return NULL;
34142 }
34143
34144
34145 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34146 PyObject *resultobj = 0;
34147 wxWindow *arg1 = (wxWindow *) 0 ;
34148 int *arg2 = (int *) 0 ;
34149 int *arg3 = (int *) 0 ;
34150 void *argp1 = 0 ;
34151 int res1 = 0 ;
34152 int temp2 ;
34153 int res2 = SWIG_TMPOBJ ;
34154 int temp3 ;
34155 int res3 = SWIG_TMPOBJ ;
34156 PyObject *swig_obj[1] ;
34157
34158 arg2 = &temp2;
34159 arg3 = &temp3;
34160 if (!args) SWIG_fail;
34161 swig_obj[0] = args;
34162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34163 if (!SWIG_IsOK(res1)) {
34164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34165 }
34166 arg1 = reinterpret_cast< wxWindow * >(argp1);
34167 {
34168 PyThreadState* __tstate = wxPyBeginAllowThreads();
34169 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34170 wxPyEndAllowThreads(__tstate);
34171 if (PyErr_Occurred()) SWIG_fail;
34172 }
34173 resultobj = SWIG_Py_Void();
34174 if (SWIG_IsTmpObj(res2)) {
34175 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34176 } else {
34177 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34178 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34179 }
34180 if (SWIG_IsTmpObj(res3)) {
34181 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34182 } else {
34183 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34184 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34185 }
34186 return resultobj;
34187 fail:
34188 return NULL;
34189 }
34190
34191
34192 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34193 PyObject *resultobj = 0;
34194 wxWindow *arg1 = (wxWindow *) 0 ;
34195 wxPoint result;
34196 void *argp1 = 0 ;
34197 int res1 = 0 ;
34198 PyObject *swig_obj[1] ;
34199
34200 if (!args) SWIG_fail;
34201 swig_obj[0] = args;
34202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34203 if (!SWIG_IsOK(res1)) {
34204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34205 }
34206 arg1 = reinterpret_cast< wxWindow * >(argp1);
34207 {
34208 PyThreadState* __tstate = wxPyBeginAllowThreads();
34209 result = ((wxWindow const *)arg1)->GetScreenPosition();
34210 wxPyEndAllowThreads(__tstate);
34211 if (PyErr_Occurred()) SWIG_fail;
34212 }
34213 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34214 return resultobj;
34215 fail:
34216 return NULL;
34217 }
34218
34219
34220 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34221 PyObject *resultobj = 0;
34222 wxWindow *arg1 = (wxWindow *) 0 ;
34223 int *arg2 = (int *) 0 ;
34224 int *arg3 = (int *) 0 ;
34225 void *argp1 = 0 ;
34226 int res1 = 0 ;
34227 int temp2 ;
34228 int res2 = SWIG_TMPOBJ ;
34229 int temp3 ;
34230 int res3 = SWIG_TMPOBJ ;
34231 PyObject *swig_obj[1] ;
34232
34233 arg2 = &temp2;
34234 arg3 = &temp3;
34235 if (!args) SWIG_fail;
34236 swig_obj[0] = args;
34237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34238 if (!SWIG_IsOK(res1)) {
34239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34240 }
34241 arg1 = reinterpret_cast< wxWindow * >(argp1);
34242 {
34243 PyThreadState* __tstate = wxPyBeginAllowThreads();
34244 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34245 wxPyEndAllowThreads(__tstate);
34246 if (PyErr_Occurred()) SWIG_fail;
34247 }
34248 resultobj = SWIG_Py_Void();
34249 if (SWIG_IsTmpObj(res2)) {
34250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34251 } else {
34252 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34254 }
34255 if (SWIG_IsTmpObj(res3)) {
34256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34257 } else {
34258 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34260 }
34261 return resultobj;
34262 fail:
34263 return NULL;
34264 }
34265
34266
34267 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34268 PyObject *resultobj = 0;
34269 wxWindow *arg1 = (wxWindow *) 0 ;
34270 wxRect result;
34271 void *argp1 = 0 ;
34272 int res1 = 0 ;
34273 PyObject *swig_obj[1] ;
34274
34275 if (!args) SWIG_fail;
34276 swig_obj[0] = args;
34277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34278 if (!SWIG_IsOK(res1)) {
34279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34280 }
34281 arg1 = reinterpret_cast< wxWindow * >(argp1);
34282 {
34283 PyThreadState* __tstate = wxPyBeginAllowThreads();
34284 result = ((wxWindow const *)arg1)->GetScreenRect();
34285 wxPyEndAllowThreads(__tstate);
34286 if (PyErr_Occurred()) SWIG_fail;
34287 }
34288 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34289 return resultobj;
34290 fail:
34291 return NULL;
34292 }
34293
34294
34295 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34296 PyObject *resultobj = 0;
34297 wxWindow *arg1 = (wxWindow *) 0 ;
34298 wxSize result;
34299 void *argp1 = 0 ;
34300 int res1 = 0 ;
34301 PyObject *swig_obj[1] ;
34302
34303 if (!args) SWIG_fail;
34304 swig_obj[0] = args;
34305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34306 if (!SWIG_IsOK(res1)) {
34307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34308 }
34309 arg1 = reinterpret_cast< wxWindow * >(argp1);
34310 {
34311 PyThreadState* __tstate = wxPyBeginAllowThreads();
34312 result = ((wxWindow const *)arg1)->GetSize();
34313 wxPyEndAllowThreads(__tstate);
34314 if (PyErr_Occurred()) SWIG_fail;
34315 }
34316 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34317 return resultobj;
34318 fail:
34319 return NULL;
34320 }
34321
34322
34323 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34324 PyObject *resultobj = 0;
34325 wxWindow *arg1 = (wxWindow *) 0 ;
34326 int *arg2 = (int *) 0 ;
34327 int *arg3 = (int *) 0 ;
34328 void *argp1 = 0 ;
34329 int res1 = 0 ;
34330 int temp2 ;
34331 int res2 = SWIG_TMPOBJ ;
34332 int temp3 ;
34333 int res3 = SWIG_TMPOBJ ;
34334 PyObject *swig_obj[1] ;
34335
34336 arg2 = &temp2;
34337 arg3 = &temp3;
34338 if (!args) SWIG_fail;
34339 swig_obj[0] = args;
34340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34341 if (!SWIG_IsOK(res1)) {
34342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34343 }
34344 arg1 = reinterpret_cast< wxWindow * >(argp1);
34345 {
34346 PyThreadState* __tstate = wxPyBeginAllowThreads();
34347 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34348 wxPyEndAllowThreads(__tstate);
34349 if (PyErr_Occurred()) SWIG_fail;
34350 }
34351 resultobj = SWIG_Py_Void();
34352 if (SWIG_IsTmpObj(res2)) {
34353 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34354 } else {
34355 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34357 }
34358 if (SWIG_IsTmpObj(res3)) {
34359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34360 } else {
34361 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34363 }
34364 return resultobj;
34365 fail:
34366 return NULL;
34367 }
34368
34369
34370 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34371 PyObject *resultobj = 0;
34372 wxWindow *arg1 = (wxWindow *) 0 ;
34373 wxRect result;
34374 void *argp1 = 0 ;
34375 int res1 = 0 ;
34376 PyObject *swig_obj[1] ;
34377
34378 if (!args) SWIG_fail;
34379 swig_obj[0] = args;
34380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34381 if (!SWIG_IsOK(res1)) {
34382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34383 }
34384 arg1 = reinterpret_cast< wxWindow * >(argp1);
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 result = ((wxWindow const *)arg1)->GetRect();
34388 wxPyEndAllowThreads(__tstate);
34389 if (PyErr_Occurred()) SWIG_fail;
34390 }
34391 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34392 return resultobj;
34393 fail:
34394 return NULL;
34395 }
34396
34397
34398 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34399 PyObject *resultobj = 0;
34400 wxWindow *arg1 = (wxWindow *) 0 ;
34401 wxSize result;
34402 void *argp1 = 0 ;
34403 int res1 = 0 ;
34404 PyObject *swig_obj[1] ;
34405
34406 if (!args) SWIG_fail;
34407 swig_obj[0] = args;
34408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34409 if (!SWIG_IsOK(res1)) {
34410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34411 }
34412 arg1 = reinterpret_cast< wxWindow * >(argp1);
34413 {
34414 PyThreadState* __tstate = wxPyBeginAllowThreads();
34415 result = ((wxWindow const *)arg1)->GetClientSize();
34416 wxPyEndAllowThreads(__tstate);
34417 if (PyErr_Occurred()) SWIG_fail;
34418 }
34419 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34420 return resultobj;
34421 fail:
34422 return NULL;
34423 }
34424
34425
34426 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34427 PyObject *resultobj = 0;
34428 wxWindow *arg1 = (wxWindow *) 0 ;
34429 int *arg2 = (int *) 0 ;
34430 int *arg3 = (int *) 0 ;
34431 void *argp1 = 0 ;
34432 int res1 = 0 ;
34433 int temp2 ;
34434 int res2 = SWIG_TMPOBJ ;
34435 int temp3 ;
34436 int res3 = SWIG_TMPOBJ ;
34437 PyObject *swig_obj[1] ;
34438
34439 arg2 = &temp2;
34440 arg3 = &temp3;
34441 if (!args) SWIG_fail;
34442 swig_obj[0] = args;
34443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34444 if (!SWIG_IsOK(res1)) {
34445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34446 }
34447 arg1 = reinterpret_cast< wxWindow * >(argp1);
34448 {
34449 PyThreadState* __tstate = wxPyBeginAllowThreads();
34450 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 resultobj = SWIG_Py_Void();
34455 if (SWIG_IsTmpObj(res2)) {
34456 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34457 } else {
34458 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34459 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34460 }
34461 if (SWIG_IsTmpObj(res3)) {
34462 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34463 } else {
34464 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34465 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34466 }
34467 return resultobj;
34468 fail:
34469 return NULL;
34470 }
34471
34472
34473 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34474 PyObject *resultobj = 0;
34475 wxWindow *arg1 = (wxWindow *) 0 ;
34476 wxPoint result;
34477 void *argp1 = 0 ;
34478 int res1 = 0 ;
34479 PyObject *swig_obj[1] ;
34480
34481 if (!args) SWIG_fail;
34482 swig_obj[0] = args;
34483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34484 if (!SWIG_IsOK(res1)) {
34485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34486 }
34487 arg1 = reinterpret_cast< wxWindow * >(argp1);
34488 {
34489 PyThreadState* __tstate = wxPyBeginAllowThreads();
34490 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34491 wxPyEndAllowThreads(__tstate);
34492 if (PyErr_Occurred()) SWIG_fail;
34493 }
34494 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34495 return resultobj;
34496 fail:
34497 return NULL;
34498 }
34499
34500
34501 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34502 PyObject *resultobj = 0;
34503 wxWindow *arg1 = (wxWindow *) 0 ;
34504 wxRect result;
34505 void *argp1 = 0 ;
34506 int res1 = 0 ;
34507 PyObject *swig_obj[1] ;
34508
34509 if (!args) SWIG_fail;
34510 swig_obj[0] = args;
34511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34512 if (!SWIG_IsOK(res1)) {
34513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34514 }
34515 arg1 = reinterpret_cast< wxWindow * >(argp1);
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 result = ((wxWindow const *)arg1)->GetClientRect();
34519 wxPyEndAllowThreads(__tstate);
34520 if (PyErr_Occurred()) SWIG_fail;
34521 }
34522 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34523 return resultobj;
34524 fail:
34525 return NULL;
34526 }
34527
34528
34529 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34530 PyObject *resultobj = 0;
34531 wxWindow *arg1 = (wxWindow *) 0 ;
34532 wxSize result;
34533 void *argp1 = 0 ;
34534 int res1 = 0 ;
34535 PyObject *swig_obj[1] ;
34536
34537 if (!args) SWIG_fail;
34538 swig_obj[0] = args;
34539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34540 if (!SWIG_IsOK(res1)) {
34541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34542 }
34543 arg1 = reinterpret_cast< wxWindow * >(argp1);
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = ((wxWindow const *)arg1)->GetBestSize();
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34551 return resultobj;
34552 fail:
34553 return NULL;
34554 }
34555
34556
34557 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34558 PyObject *resultobj = 0;
34559 wxWindow *arg1 = (wxWindow *) 0 ;
34560 int *arg2 = (int *) 0 ;
34561 int *arg3 = (int *) 0 ;
34562 void *argp1 = 0 ;
34563 int res1 = 0 ;
34564 int temp2 ;
34565 int res2 = SWIG_TMPOBJ ;
34566 int temp3 ;
34567 int res3 = SWIG_TMPOBJ ;
34568 PyObject *swig_obj[1] ;
34569
34570 arg2 = &temp2;
34571 arg3 = &temp3;
34572 if (!args) SWIG_fail;
34573 swig_obj[0] = args;
34574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34575 if (!SWIG_IsOK(res1)) {
34576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34577 }
34578 arg1 = reinterpret_cast< wxWindow * >(argp1);
34579 {
34580 PyThreadState* __tstate = wxPyBeginAllowThreads();
34581 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34582 wxPyEndAllowThreads(__tstate);
34583 if (PyErr_Occurred()) SWIG_fail;
34584 }
34585 resultobj = SWIG_Py_Void();
34586 if (SWIG_IsTmpObj(res2)) {
34587 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34588 } else {
34589 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34590 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34591 }
34592 if (SWIG_IsTmpObj(res3)) {
34593 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34594 } else {
34595 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34596 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34597 }
34598 return resultobj;
34599 fail:
34600 return NULL;
34601 }
34602
34603
34604 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34605 PyObject *resultobj = 0;
34606 wxWindow *arg1 = (wxWindow *) 0 ;
34607 void *argp1 = 0 ;
34608 int res1 = 0 ;
34609 PyObject *swig_obj[1] ;
34610
34611 if (!args) SWIG_fail;
34612 swig_obj[0] = args;
34613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34614 if (!SWIG_IsOK(res1)) {
34615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34616 }
34617 arg1 = reinterpret_cast< wxWindow * >(argp1);
34618 {
34619 PyThreadState* __tstate = wxPyBeginAllowThreads();
34620 (arg1)->InvalidateBestSize();
34621 wxPyEndAllowThreads(__tstate);
34622 if (PyErr_Occurred()) SWIG_fail;
34623 }
34624 resultobj = SWIG_Py_Void();
34625 return resultobj;
34626 fail:
34627 return NULL;
34628 }
34629
34630
34631 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34632 PyObject *resultobj = 0;
34633 wxWindow *arg1 = (wxWindow *) 0 ;
34634 wxSize *arg2 = 0 ;
34635 void *argp1 = 0 ;
34636 int res1 = 0 ;
34637 wxSize temp2 ;
34638 PyObject * obj0 = 0 ;
34639 PyObject * obj1 = 0 ;
34640 char * kwnames[] = {
34641 (char *) "self",(char *) "size", NULL
34642 };
34643
34644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34646 if (!SWIG_IsOK(res1)) {
34647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34648 }
34649 arg1 = reinterpret_cast< wxWindow * >(argp1);
34650 {
34651 arg2 = &temp2;
34652 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34653 }
34654 {
34655 PyThreadState* __tstate = wxPyBeginAllowThreads();
34656 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34657 wxPyEndAllowThreads(__tstate);
34658 if (PyErr_Occurred()) SWIG_fail;
34659 }
34660 resultobj = SWIG_Py_Void();
34661 return resultobj;
34662 fail:
34663 return NULL;
34664 }
34665
34666
34667 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34668 PyObject *resultobj = 0;
34669 wxWindow *arg1 = (wxWindow *) 0 ;
34670 wxSize result;
34671 void *argp1 = 0 ;
34672 int res1 = 0 ;
34673 PyObject *swig_obj[1] ;
34674
34675 if (!args) SWIG_fail;
34676 swig_obj[0] = args;
34677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34678 if (!SWIG_IsOK(res1)) {
34679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34680 }
34681 arg1 = reinterpret_cast< wxWindow * >(argp1);
34682 {
34683 PyThreadState* __tstate = wxPyBeginAllowThreads();
34684 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34685 wxPyEndAllowThreads(__tstate);
34686 if (PyErr_Occurred()) SWIG_fail;
34687 }
34688 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34689 return resultobj;
34690 fail:
34691 return NULL;
34692 }
34693
34694
34695 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34696 PyObject *resultobj = 0;
34697 wxWindow *arg1 = (wxWindow *) 0 ;
34698 int arg2 = (int) wxBOTH ;
34699 void *argp1 = 0 ;
34700 int res1 = 0 ;
34701 int val2 ;
34702 int ecode2 = 0 ;
34703 PyObject * obj0 = 0 ;
34704 PyObject * obj1 = 0 ;
34705 char * kwnames[] = {
34706 (char *) "self",(char *) "direction", NULL
34707 };
34708
34709 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34710 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34711 if (!SWIG_IsOK(res1)) {
34712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34713 }
34714 arg1 = reinterpret_cast< wxWindow * >(argp1);
34715 if (obj1) {
34716 ecode2 = SWIG_AsVal_int(obj1, &val2);
34717 if (!SWIG_IsOK(ecode2)) {
34718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34719 }
34720 arg2 = static_cast< int >(val2);
34721 }
34722 {
34723 PyThreadState* __tstate = wxPyBeginAllowThreads();
34724 (arg1)->Center(arg2);
34725 wxPyEndAllowThreads(__tstate);
34726 if (PyErr_Occurred()) SWIG_fail;
34727 }
34728 resultobj = SWIG_Py_Void();
34729 return resultobj;
34730 fail:
34731 return NULL;
34732 }
34733
34734
34735 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34736 PyObject *resultobj = 0;
34737 wxWindow *arg1 = (wxWindow *) 0 ;
34738 int arg2 = (int) wxBOTH ;
34739 void *argp1 = 0 ;
34740 int res1 = 0 ;
34741 int val2 ;
34742 int ecode2 = 0 ;
34743 PyObject * obj0 = 0 ;
34744 PyObject * obj1 = 0 ;
34745 char * kwnames[] = {
34746 (char *) "self",(char *) "dir", NULL
34747 };
34748
34749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34751 if (!SWIG_IsOK(res1)) {
34752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34753 }
34754 arg1 = reinterpret_cast< wxWindow * >(argp1);
34755 if (obj1) {
34756 ecode2 = SWIG_AsVal_int(obj1, &val2);
34757 if (!SWIG_IsOK(ecode2)) {
34758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34759 }
34760 arg2 = static_cast< int >(val2);
34761 }
34762 {
34763 PyThreadState* __tstate = wxPyBeginAllowThreads();
34764 (arg1)->CenterOnParent(arg2);
34765 wxPyEndAllowThreads(__tstate);
34766 if (PyErr_Occurred()) SWIG_fail;
34767 }
34768 resultobj = SWIG_Py_Void();
34769 return resultobj;
34770 fail:
34771 return NULL;
34772 }
34773
34774
34775 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34776 PyObject *resultobj = 0;
34777 wxWindow *arg1 = (wxWindow *) 0 ;
34778 void *argp1 = 0 ;
34779 int res1 = 0 ;
34780 PyObject *swig_obj[1] ;
34781
34782 if (!args) SWIG_fail;
34783 swig_obj[0] = args;
34784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34785 if (!SWIG_IsOK(res1)) {
34786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34787 }
34788 arg1 = reinterpret_cast< wxWindow * >(argp1);
34789 {
34790 PyThreadState* __tstate = wxPyBeginAllowThreads();
34791 (arg1)->Fit();
34792 wxPyEndAllowThreads(__tstate);
34793 if (PyErr_Occurred()) SWIG_fail;
34794 }
34795 resultobj = SWIG_Py_Void();
34796 return resultobj;
34797 fail:
34798 return NULL;
34799 }
34800
34801
34802 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34803 PyObject *resultobj = 0;
34804 wxWindow *arg1 = (wxWindow *) 0 ;
34805 void *argp1 = 0 ;
34806 int res1 = 0 ;
34807 PyObject *swig_obj[1] ;
34808
34809 if (!args) SWIG_fail;
34810 swig_obj[0] = args;
34811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34812 if (!SWIG_IsOK(res1)) {
34813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34814 }
34815 arg1 = reinterpret_cast< wxWindow * >(argp1);
34816 {
34817 PyThreadState* __tstate = wxPyBeginAllowThreads();
34818 (arg1)->FitInside();
34819 wxPyEndAllowThreads(__tstate);
34820 if (PyErr_Occurred()) SWIG_fail;
34821 }
34822 resultobj = SWIG_Py_Void();
34823 return resultobj;
34824 fail:
34825 return NULL;
34826 }
34827
34828
34829 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34830 PyObject *resultobj = 0;
34831 wxWindow *arg1 = (wxWindow *) 0 ;
34832 int arg2 ;
34833 int arg3 ;
34834 int arg4 = (int) -1 ;
34835 int arg5 = (int) -1 ;
34836 int arg6 = (int) -1 ;
34837 int arg7 = (int) -1 ;
34838 void *argp1 = 0 ;
34839 int res1 = 0 ;
34840 int val2 ;
34841 int ecode2 = 0 ;
34842 int val3 ;
34843 int ecode3 = 0 ;
34844 int val4 ;
34845 int ecode4 = 0 ;
34846 int val5 ;
34847 int ecode5 = 0 ;
34848 int val6 ;
34849 int ecode6 = 0 ;
34850 int val7 ;
34851 int ecode7 = 0 ;
34852 PyObject * obj0 = 0 ;
34853 PyObject * obj1 = 0 ;
34854 PyObject * obj2 = 0 ;
34855 PyObject * obj3 = 0 ;
34856 PyObject * obj4 = 0 ;
34857 PyObject * obj5 = 0 ;
34858 PyObject * obj6 = 0 ;
34859 char * kwnames[] = {
34860 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34861 };
34862
34863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34865 if (!SWIG_IsOK(res1)) {
34866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34867 }
34868 arg1 = reinterpret_cast< wxWindow * >(argp1);
34869 ecode2 = SWIG_AsVal_int(obj1, &val2);
34870 if (!SWIG_IsOK(ecode2)) {
34871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34872 }
34873 arg2 = static_cast< int >(val2);
34874 ecode3 = SWIG_AsVal_int(obj2, &val3);
34875 if (!SWIG_IsOK(ecode3)) {
34876 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34877 }
34878 arg3 = static_cast< int >(val3);
34879 if (obj3) {
34880 ecode4 = SWIG_AsVal_int(obj3, &val4);
34881 if (!SWIG_IsOK(ecode4)) {
34882 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34883 }
34884 arg4 = static_cast< int >(val4);
34885 }
34886 if (obj4) {
34887 ecode5 = SWIG_AsVal_int(obj4, &val5);
34888 if (!SWIG_IsOK(ecode5)) {
34889 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34890 }
34891 arg5 = static_cast< int >(val5);
34892 }
34893 if (obj5) {
34894 ecode6 = SWIG_AsVal_int(obj5, &val6);
34895 if (!SWIG_IsOK(ecode6)) {
34896 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34897 }
34898 arg6 = static_cast< int >(val6);
34899 }
34900 if (obj6) {
34901 ecode7 = SWIG_AsVal_int(obj6, &val7);
34902 if (!SWIG_IsOK(ecode7)) {
34903 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34904 }
34905 arg7 = static_cast< int >(val7);
34906 }
34907 {
34908 PyThreadState* __tstate = wxPyBeginAllowThreads();
34909 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34910 wxPyEndAllowThreads(__tstate);
34911 if (PyErr_Occurred()) SWIG_fail;
34912 }
34913 resultobj = SWIG_Py_Void();
34914 return resultobj;
34915 fail:
34916 return NULL;
34917 }
34918
34919
34920 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34921 PyObject *resultobj = 0;
34922 wxWindow *arg1 = (wxWindow *) 0 ;
34923 wxSize *arg2 = 0 ;
34924 wxSize const &arg3_defvalue = wxDefaultSize ;
34925 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34926 wxSize const &arg4_defvalue = wxDefaultSize ;
34927 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34928 void *argp1 = 0 ;
34929 int res1 = 0 ;
34930 wxSize temp2 ;
34931 wxSize temp3 ;
34932 wxSize temp4 ;
34933 PyObject * obj0 = 0 ;
34934 PyObject * obj1 = 0 ;
34935 PyObject * obj2 = 0 ;
34936 PyObject * obj3 = 0 ;
34937 char * kwnames[] = {
34938 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34939 };
34940
34941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34943 if (!SWIG_IsOK(res1)) {
34944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34945 }
34946 arg1 = reinterpret_cast< wxWindow * >(argp1);
34947 {
34948 arg2 = &temp2;
34949 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34950 }
34951 if (obj2) {
34952 {
34953 arg3 = &temp3;
34954 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34955 }
34956 }
34957 if (obj3) {
34958 {
34959 arg4 = &temp4;
34960 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34961 }
34962 }
34963 {
34964 PyThreadState* __tstate = wxPyBeginAllowThreads();
34965 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34966 wxPyEndAllowThreads(__tstate);
34967 if (PyErr_Occurred()) SWIG_fail;
34968 }
34969 resultobj = SWIG_Py_Void();
34970 return resultobj;
34971 fail:
34972 return NULL;
34973 }
34974
34975
34976 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34977 PyObject *resultobj = 0;
34978 wxWindow *arg1 = (wxWindow *) 0 ;
34979 int arg2 ;
34980 int arg3 ;
34981 int arg4 = (int) -1 ;
34982 int arg5 = (int) -1 ;
34983 void *argp1 = 0 ;
34984 int res1 = 0 ;
34985 int val2 ;
34986 int ecode2 = 0 ;
34987 int val3 ;
34988 int ecode3 = 0 ;
34989 int val4 ;
34990 int ecode4 = 0 ;
34991 int val5 ;
34992 int ecode5 = 0 ;
34993 PyObject * obj0 = 0 ;
34994 PyObject * obj1 = 0 ;
34995 PyObject * obj2 = 0 ;
34996 PyObject * obj3 = 0 ;
34997 PyObject * obj4 = 0 ;
34998 char * kwnames[] = {
34999 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35000 };
35001
35002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35004 if (!SWIG_IsOK(res1)) {
35005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35006 }
35007 arg1 = reinterpret_cast< wxWindow * >(argp1);
35008 ecode2 = SWIG_AsVal_int(obj1, &val2);
35009 if (!SWIG_IsOK(ecode2)) {
35010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35011 }
35012 arg2 = static_cast< int >(val2);
35013 ecode3 = SWIG_AsVal_int(obj2, &val3);
35014 if (!SWIG_IsOK(ecode3)) {
35015 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35016 }
35017 arg3 = static_cast< int >(val3);
35018 if (obj3) {
35019 ecode4 = SWIG_AsVal_int(obj3, &val4);
35020 if (!SWIG_IsOK(ecode4)) {
35021 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35022 }
35023 arg4 = static_cast< int >(val4);
35024 }
35025 if (obj4) {
35026 ecode5 = SWIG_AsVal_int(obj4, &val5);
35027 if (!SWIG_IsOK(ecode5)) {
35028 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35029 }
35030 arg5 = static_cast< int >(val5);
35031 }
35032 {
35033 PyThreadState* __tstate = wxPyBeginAllowThreads();
35034 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35035 wxPyEndAllowThreads(__tstate);
35036 if (PyErr_Occurred()) SWIG_fail;
35037 }
35038 resultobj = SWIG_Py_Void();
35039 return resultobj;
35040 fail:
35041 return NULL;
35042 }
35043
35044
35045 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35046 PyObject *resultobj = 0;
35047 wxWindow *arg1 = (wxWindow *) 0 ;
35048 wxSize *arg2 = 0 ;
35049 wxSize const &arg3_defvalue = wxDefaultSize ;
35050 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35051 void *argp1 = 0 ;
35052 int res1 = 0 ;
35053 wxSize temp2 ;
35054 wxSize temp3 ;
35055 PyObject * obj0 = 0 ;
35056 PyObject * obj1 = 0 ;
35057 PyObject * obj2 = 0 ;
35058 char * kwnames[] = {
35059 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35060 };
35061
35062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35064 if (!SWIG_IsOK(res1)) {
35065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35066 }
35067 arg1 = reinterpret_cast< wxWindow * >(argp1);
35068 {
35069 arg2 = &temp2;
35070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35071 }
35072 if (obj2) {
35073 {
35074 arg3 = &temp3;
35075 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35076 }
35077 }
35078 {
35079 PyThreadState* __tstate = wxPyBeginAllowThreads();
35080 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35081 wxPyEndAllowThreads(__tstate);
35082 if (PyErr_Occurred()) SWIG_fail;
35083 }
35084 resultobj = SWIG_Py_Void();
35085 return resultobj;
35086 fail:
35087 return NULL;
35088 }
35089
35090
35091 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35092 PyObject *resultobj = 0;
35093 wxWindow *arg1 = (wxWindow *) 0 ;
35094 wxSize result;
35095 void *argp1 = 0 ;
35096 int res1 = 0 ;
35097 PyObject *swig_obj[1] ;
35098
35099 if (!args) SWIG_fail;
35100 swig_obj[0] = args;
35101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35102 if (!SWIG_IsOK(res1)) {
35103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35104 }
35105 arg1 = reinterpret_cast< wxWindow * >(argp1);
35106 {
35107 PyThreadState* __tstate = wxPyBeginAllowThreads();
35108 result = ((wxWindow const *)arg1)->GetMaxSize();
35109 wxPyEndAllowThreads(__tstate);
35110 if (PyErr_Occurred()) SWIG_fail;
35111 }
35112 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35113 return resultobj;
35114 fail:
35115 return NULL;
35116 }
35117
35118
35119 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35120 PyObject *resultobj = 0;
35121 wxWindow *arg1 = (wxWindow *) 0 ;
35122 wxSize result;
35123 void *argp1 = 0 ;
35124 int res1 = 0 ;
35125 PyObject *swig_obj[1] ;
35126
35127 if (!args) SWIG_fail;
35128 swig_obj[0] = args;
35129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35130 if (!SWIG_IsOK(res1)) {
35131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 result = ((wxWindow const *)arg1)->GetMinSize();
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35141 return resultobj;
35142 fail:
35143 return NULL;
35144 }
35145
35146
35147 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35148 PyObject *resultobj = 0;
35149 wxWindow *arg1 = (wxWindow *) 0 ;
35150 wxSize *arg2 = 0 ;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 wxSize temp2 ;
35154 PyObject * obj0 = 0 ;
35155 PyObject * obj1 = 0 ;
35156 char * kwnames[] = {
35157 (char *) "self",(char *) "minSize", NULL
35158 };
35159
35160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35162 if (!SWIG_IsOK(res1)) {
35163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35164 }
35165 arg1 = reinterpret_cast< wxWindow * >(argp1);
35166 {
35167 arg2 = &temp2;
35168 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35169 }
35170 {
35171 PyThreadState* __tstate = wxPyBeginAllowThreads();
35172 (arg1)->SetMinSize((wxSize const &)*arg2);
35173 wxPyEndAllowThreads(__tstate);
35174 if (PyErr_Occurred()) SWIG_fail;
35175 }
35176 resultobj = SWIG_Py_Void();
35177 return resultobj;
35178 fail:
35179 return NULL;
35180 }
35181
35182
35183 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35184 PyObject *resultobj = 0;
35185 wxWindow *arg1 = (wxWindow *) 0 ;
35186 wxSize *arg2 = 0 ;
35187 void *argp1 = 0 ;
35188 int res1 = 0 ;
35189 wxSize temp2 ;
35190 PyObject * obj0 = 0 ;
35191 PyObject * obj1 = 0 ;
35192 char * kwnames[] = {
35193 (char *) "self",(char *) "maxSize", NULL
35194 };
35195
35196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35198 if (!SWIG_IsOK(res1)) {
35199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35200 }
35201 arg1 = reinterpret_cast< wxWindow * >(argp1);
35202 {
35203 arg2 = &temp2;
35204 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35205 }
35206 {
35207 PyThreadState* __tstate = wxPyBeginAllowThreads();
35208 (arg1)->SetMaxSize((wxSize const &)*arg2);
35209 wxPyEndAllowThreads(__tstate);
35210 if (PyErr_Occurred()) SWIG_fail;
35211 }
35212 resultobj = SWIG_Py_Void();
35213 return resultobj;
35214 fail:
35215 return NULL;
35216 }
35217
35218
35219 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35220 PyObject *resultobj = 0;
35221 wxWindow *arg1 = (wxWindow *) 0 ;
35222 int result;
35223 void *argp1 = 0 ;
35224 int res1 = 0 ;
35225 PyObject *swig_obj[1] ;
35226
35227 if (!args) SWIG_fail;
35228 swig_obj[0] = args;
35229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35230 if (!SWIG_IsOK(res1)) {
35231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35232 }
35233 arg1 = reinterpret_cast< wxWindow * >(argp1);
35234 {
35235 PyThreadState* __tstate = wxPyBeginAllowThreads();
35236 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35237 wxPyEndAllowThreads(__tstate);
35238 if (PyErr_Occurred()) SWIG_fail;
35239 }
35240 resultobj = SWIG_From_int(static_cast< int >(result));
35241 return resultobj;
35242 fail:
35243 return NULL;
35244 }
35245
35246
35247 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35248 PyObject *resultobj = 0;
35249 wxWindow *arg1 = (wxWindow *) 0 ;
35250 int result;
35251 void *argp1 = 0 ;
35252 int res1 = 0 ;
35253 PyObject *swig_obj[1] ;
35254
35255 if (!args) SWIG_fail;
35256 swig_obj[0] = args;
35257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35258 if (!SWIG_IsOK(res1)) {
35259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35260 }
35261 arg1 = reinterpret_cast< wxWindow * >(argp1);
35262 {
35263 PyThreadState* __tstate = wxPyBeginAllowThreads();
35264 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35265 wxPyEndAllowThreads(__tstate);
35266 if (PyErr_Occurred()) SWIG_fail;
35267 }
35268 resultobj = SWIG_From_int(static_cast< int >(result));
35269 return resultobj;
35270 fail:
35271 return NULL;
35272 }
35273
35274
35275 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35276 PyObject *resultobj = 0;
35277 wxWindow *arg1 = (wxWindow *) 0 ;
35278 int result;
35279 void *argp1 = 0 ;
35280 int res1 = 0 ;
35281 PyObject *swig_obj[1] ;
35282
35283 if (!args) SWIG_fail;
35284 swig_obj[0] = args;
35285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35286 if (!SWIG_IsOK(res1)) {
35287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35288 }
35289 arg1 = reinterpret_cast< wxWindow * >(argp1);
35290 {
35291 PyThreadState* __tstate = wxPyBeginAllowThreads();
35292 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35293 wxPyEndAllowThreads(__tstate);
35294 if (PyErr_Occurred()) SWIG_fail;
35295 }
35296 resultobj = SWIG_From_int(static_cast< int >(result));
35297 return resultobj;
35298 fail:
35299 return NULL;
35300 }
35301
35302
35303 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35304 PyObject *resultobj = 0;
35305 wxWindow *arg1 = (wxWindow *) 0 ;
35306 int result;
35307 void *argp1 = 0 ;
35308 int res1 = 0 ;
35309 PyObject *swig_obj[1] ;
35310
35311 if (!args) SWIG_fail;
35312 swig_obj[0] = args;
35313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35314 if (!SWIG_IsOK(res1)) {
35315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35316 }
35317 arg1 = reinterpret_cast< wxWindow * >(argp1);
35318 {
35319 PyThreadState* __tstate = wxPyBeginAllowThreads();
35320 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35321 wxPyEndAllowThreads(__tstate);
35322 if (PyErr_Occurred()) SWIG_fail;
35323 }
35324 resultobj = SWIG_From_int(static_cast< int >(result));
35325 return resultobj;
35326 fail:
35327 return NULL;
35328 }
35329
35330
35331 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35332 PyObject *resultobj = 0;
35333 wxWindow *arg1 = (wxWindow *) 0 ;
35334 wxSize *arg2 = 0 ;
35335 void *argp1 = 0 ;
35336 int res1 = 0 ;
35337 wxSize temp2 ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 char * kwnames[] = {
35341 (char *) "self",(char *) "size", NULL
35342 };
35343
35344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35346 if (!SWIG_IsOK(res1)) {
35347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35348 }
35349 arg1 = reinterpret_cast< wxWindow * >(argp1);
35350 {
35351 arg2 = &temp2;
35352 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35353 }
35354 {
35355 PyThreadState* __tstate = wxPyBeginAllowThreads();
35356 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35357 wxPyEndAllowThreads(__tstate);
35358 if (PyErr_Occurred()) SWIG_fail;
35359 }
35360 resultobj = SWIG_Py_Void();
35361 return resultobj;
35362 fail:
35363 return NULL;
35364 }
35365
35366
35367 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35368 PyObject *resultobj = 0;
35369 wxWindow *arg1 = (wxWindow *) 0 ;
35370 int arg2 ;
35371 int arg3 ;
35372 void *argp1 = 0 ;
35373 int res1 = 0 ;
35374 int val2 ;
35375 int ecode2 = 0 ;
35376 int val3 ;
35377 int ecode3 = 0 ;
35378 PyObject * obj0 = 0 ;
35379 PyObject * obj1 = 0 ;
35380 PyObject * obj2 = 0 ;
35381 char * kwnames[] = {
35382 (char *) "self",(char *) "w",(char *) "h", NULL
35383 };
35384
35385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35387 if (!SWIG_IsOK(res1)) {
35388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35389 }
35390 arg1 = reinterpret_cast< wxWindow * >(argp1);
35391 ecode2 = SWIG_AsVal_int(obj1, &val2);
35392 if (!SWIG_IsOK(ecode2)) {
35393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35394 }
35395 arg2 = static_cast< int >(val2);
35396 ecode3 = SWIG_AsVal_int(obj2, &val3);
35397 if (!SWIG_IsOK(ecode3)) {
35398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35399 }
35400 arg3 = static_cast< int >(val3);
35401 {
35402 PyThreadState* __tstate = wxPyBeginAllowThreads();
35403 (arg1)->SetVirtualSize(arg2,arg3);
35404 wxPyEndAllowThreads(__tstate);
35405 if (PyErr_Occurred()) SWIG_fail;
35406 }
35407 resultobj = SWIG_Py_Void();
35408 return resultobj;
35409 fail:
35410 return NULL;
35411 }
35412
35413
35414 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35415 PyObject *resultobj = 0;
35416 wxWindow *arg1 = (wxWindow *) 0 ;
35417 wxSize result;
35418 void *argp1 = 0 ;
35419 int res1 = 0 ;
35420 PyObject *swig_obj[1] ;
35421
35422 if (!args) SWIG_fail;
35423 swig_obj[0] = args;
35424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35425 if (!SWIG_IsOK(res1)) {
35426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35427 }
35428 arg1 = reinterpret_cast< wxWindow * >(argp1);
35429 {
35430 PyThreadState* __tstate = wxPyBeginAllowThreads();
35431 result = ((wxWindow const *)arg1)->GetVirtualSize();
35432 wxPyEndAllowThreads(__tstate);
35433 if (PyErr_Occurred()) SWIG_fail;
35434 }
35435 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35436 return resultobj;
35437 fail:
35438 return NULL;
35439 }
35440
35441
35442 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35443 PyObject *resultobj = 0;
35444 wxWindow *arg1 = (wxWindow *) 0 ;
35445 int *arg2 = (int *) 0 ;
35446 int *arg3 = (int *) 0 ;
35447 void *argp1 = 0 ;
35448 int res1 = 0 ;
35449 int temp2 ;
35450 int res2 = SWIG_TMPOBJ ;
35451 int temp3 ;
35452 int res3 = SWIG_TMPOBJ ;
35453 PyObject *swig_obj[1] ;
35454
35455 arg2 = &temp2;
35456 arg3 = &temp3;
35457 if (!args) SWIG_fail;
35458 swig_obj[0] = args;
35459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35460 if (!SWIG_IsOK(res1)) {
35461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35462 }
35463 arg1 = reinterpret_cast< wxWindow * >(argp1);
35464 {
35465 PyThreadState* __tstate = wxPyBeginAllowThreads();
35466 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 resultobj = SWIG_Py_Void();
35471 if (SWIG_IsTmpObj(res2)) {
35472 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35473 } else {
35474 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35476 }
35477 if (SWIG_IsTmpObj(res3)) {
35478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35479 } else {
35480 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35482 }
35483 return resultobj;
35484 fail:
35485 return NULL;
35486 }
35487
35488
35489 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35490 PyObject *resultobj = 0;
35491 wxWindow *arg1 = (wxWindow *) 0 ;
35492 wxSize result;
35493 void *argp1 = 0 ;
35494 int res1 = 0 ;
35495 PyObject *swig_obj[1] ;
35496
35497 if (!args) SWIG_fail;
35498 swig_obj[0] = args;
35499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35500 if (!SWIG_IsOK(res1)) {
35501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35502 }
35503 arg1 = reinterpret_cast< wxWindow * >(argp1);
35504 {
35505 PyThreadState* __tstate = wxPyBeginAllowThreads();
35506 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35511 return resultobj;
35512 fail:
35513 return NULL;
35514 }
35515
35516
35517 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35518 PyObject *resultobj = 0;
35519 wxWindow *arg1 = (wxWindow *) 0 ;
35520 bool arg2 = (bool) true ;
35521 bool result;
35522 void *argp1 = 0 ;
35523 int res1 = 0 ;
35524 bool val2 ;
35525 int ecode2 = 0 ;
35526 PyObject * obj0 = 0 ;
35527 PyObject * obj1 = 0 ;
35528 char * kwnames[] = {
35529 (char *) "self",(char *) "show", NULL
35530 };
35531
35532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35534 if (!SWIG_IsOK(res1)) {
35535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35536 }
35537 arg1 = reinterpret_cast< wxWindow * >(argp1);
35538 if (obj1) {
35539 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35540 if (!SWIG_IsOK(ecode2)) {
35541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35542 }
35543 arg2 = static_cast< bool >(val2);
35544 }
35545 {
35546 PyThreadState* __tstate = wxPyBeginAllowThreads();
35547 result = (bool)(arg1)->Show(arg2);
35548 wxPyEndAllowThreads(__tstate);
35549 if (PyErr_Occurred()) SWIG_fail;
35550 }
35551 {
35552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35553 }
35554 return resultobj;
35555 fail:
35556 return NULL;
35557 }
35558
35559
35560 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35561 PyObject *resultobj = 0;
35562 wxWindow *arg1 = (wxWindow *) 0 ;
35563 bool result;
35564 void *argp1 = 0 ;
35565 int res1 = 0 ;
35566 PyObject *swig_obj[1] ;
35567
35568 if (!args) SWIG_fail;
35569 swig_obj[0] = args;
35570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35571 if (!SWIG_IsOK(res1)) {
35572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35573 }
35574 arg1 = reinterpret_cast< wxWindow * >(argp1);
35575 {
35576 PyThreadState* __tstate = wxPyBeginAllowThreads();
35577 result = (bool)(arg1)->Hide();
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 {
35582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35583 }
35584 return resultobj;
35585 fail:
35586 return NULL;
35587 }
35588
35589
35590 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35591 PyObject *resultobj = 0;
35592 wxWindow *arg1 = (wxWindow *) 0 ;
35593 bool arg2 = (bool) true ;
35594 bool result;
35595 void *argp1 = 0 ;
35596 int res1 = 0 ;
35597 bool val2 ;
35598 int ecode2 = 0 ;
35599 PyObject * obj0 = 0 ;
35600 PyObject * obj1 = 0 ;
35601 char * kwnames[] = {
35602 (char *) "self",(char *) "enable", NULL
35603 };
35604
35605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35606 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35607 if (!SWIG_IsOK(res1)) {
35608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35609 }
35610 arg1 = reinterpret_cast< wxWindow * >(argp1);
35611 if (obj1) {
35612 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35613 if (!SWIG_IsOK(ecode2)) {
35614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35615 }
35616 arg2 = static_cast< bool >(val2);
35617 }
35618 {
35619 PyThreadState* __tstate = wxPyBeginAllowThreads();
35620 result = (bool)(arg1)->Enable(arg2);
35621 wxPyEndAllowThreads(__tstate);
35622 if (PyErr_Occurred()) SWIG_fail;
35623 }
35624 {
35625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35626 }
35627 return resultobj;
35628 fail:
35629 return NULL;
35630 }
35631
35632
35633 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35634 PyObject *resultobj = 0;
35635 wxWindow *arg1 = (wxWindow *) 0 ;
35636 bool result;
35637 void *argp1 = 0 ;
35638 int res1 = 0 ;
35639 PyObject *swig_obj[1] ;
35640
35641 if (!args) SWIG_fail;
35642 swig_obj[0] = args;
35643 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35644 if (!SWIG_IsOK(res1)) {
35645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35646 }
35647 arg1 = reinterpret_cast< wxWindow * >(argp1);
35648 {
35649 PyThreadState* __tstate = wxPyBeginAllowThreads();
35650 result = (bool)(arg1)->Disable();
35651 wxPyEndAllowThreads(__tstate);
35652 if (PyErr_Occurred()) SWIG_fail;
35653 }
35654 {
35655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35656 }
35657 return resultobj;
35658 fail:
35659 return NULL;
35660 }
35661
35662
35663 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35664 PyObject *resultobj = 0;
35665 wxWindow *arg1 = (wxWindow *) 0 ;
35666 bool result;
35667 void *argp1 = 0 ;
35668 int res1 = 0 ;
35669 PyObject *swig_obj[1] ;
35670
35671 if (!args) SWIG_fail;
35672 swig_obj[0] = args;
35673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35674 if (!SWIG_IsOK(res1)) {
35675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35676 }
35677 arg1 = reinterpret_cast< wxWindow * >(argp1);
35678 {
35679 PyThreadState* __tstate = wxPyBeginAllowThreads();
35680 result = (bool)((wxWindow const *)arg1)->IsShown();
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 {
35685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35686 }
35687 return resultobj;
35688 fail:
35689 return NULL;
35690 }
35691
35692
35693 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35694 PyObject *resultobj = 0;
35695 wxWindow *arg1 = (wxWindow *) 0 ;
35696 bool result;
35697 void *argp1 = 0 ;
35698 int res1 = 0 ;
35699 PyObject *swig_obj[1] ;
35700
35701 if (!args) SWIG_fail;
35702 swig_obj[0] = args;
35703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35704 if (!SWIG_IsOK(res1)) {
35705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35706 }
35707 arg1 = reinterpret_cast< wxWindow * >(argp1);
35708 {
35709 PyThreadState* __tstate = wxPyBeginAllowThreads();
35710 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35711 wxPyEndAllowThreads(__tstate);
35712 if (PyErr_Occurred()) SWIG_fail;
35713 }
35714 {
35715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35716 }
35717 return resultobj;
35718 fail:
35719 return NULL;
35720 }
35721
35722
35723 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35724 PyObject *resultobj = 0;
35725 wxWindow *arg1 = (wxWindow *) 0 ;
35726 bool result;
35727 void *argp1 = 0 ;
35728 int res1 = 0 ;
35729 PyObject *swig_obj[1] ;
35730
35731 if (!args) SWIG_fail;
35732 swig_obj[0] = args;
35733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35734 if (!SWIG_IsOK(res1)) {
35735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35736 }
35737 arg1 = reinterpret_cast< wxWindow * >(argp1);
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 {
35745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35746 }
35747 return resultobj;
35748 fail:
35749 return NULL;
35750 }
35751
35752
35753 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35754 PyObject *resultobj = 0;
35755 wxWindow *arg1 = (wxWindow *) 0 ;
35756 long arg2 ;
35757 void *argp1 = 0 ;
35758 int res1 = 0 ;
35759 long val2 ;
35760 int ecode2 = 0 ;
35761 PyObject * obj0 = 0 ;
35762 PyObject * obj1 = 0 ;
35763 char * kwnames[] = {
35764 (char *) "self",(char *) "style", NULL
35765 };
35766
35767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",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_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35771 }
35772 arg1 = reinterpret_cast< wxWindow * >(argp1);
35773 ecode2 = SWIG_AsVal_long(obj1, &val2);
35774 if (!SWIG_IsOK(ecode2)) {
35775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35776 }
35777 arg2 = static_cast< long >(val2);
35778 {
35779 PyThreadState* __tstate = wxPyBeginAllowThreads();
35780 (arg1)->SetWindowStyleFlag(arg2);
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 resultobj = SWIG_Py_Void();
35785 return resultobj;
35786 fail:
35787 return NULL;
35788 }
35789
35790
35791 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35792 PyObject *resultobj = 0;
35793 wxWindow *arg1 = (wxWindow *) 0 ;
35794 long result;
35795 void *argp1 = 0 ;
35796 int res1 = 0 ;
35797 PyObject *swig_obj[1] ;
35798
35799 if (!args) SWIG_fail;
35800 swig_obj[0] = args;
35801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35802 if (!SWIG_IsOK(res1)) {
35803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35804 }
35805 arg1 = reinterpret_cast< wxWindow * >(argp1);
35806 {
35807 PyThreadState* __tstate = wxPyBeginAllowThreads();
35808 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35809 wxPyEndAllowThreads(__tstate);
35810 if (PyErr_Occurred()) SWIG_fail;
35811 }
35812 resultobj = SWIG_From_long(static_cast< long >(result));
35813 return resultobj;
35814 fail:
35815 return NULL;
35816 }
35817
35818
35819 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35820 PyObject *resultobj = 0;
35821 wxWindow *arg1 = (wxWindow *) 0 ;
35822 int arg2 ;
35823 bool result;
35824 void *argp1 = 0 ;
35825 int res1 = 0 ;
35826 int val2 ;
35827 int ecode2 = 0 ;
35828 PyObject * obj0 = 0 ;
35829 PyObject * obj1 = 0 ;
35830 char * kwnames[] = {
35831 (char *) "self",(char *) "flag", NULL
35832 };
35833
35834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35836 if (!SWIG_IsOK(res1)) {
35837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35838 }
35839 arg1 = reinterpret_cast< wxWindow * >(argp1);
35840 ecode2 = SWIG_AsVal_int(obj1, &val2);
35841 if (!SWIG_IsOK(ecode2)) {
35842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35843 }
35844 arg2 = static_cast< int >(val2);
35845 {
35846 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35848 wxPyEndAllowThreads(__tstate);
35849 if (PyErr_Occurred()) SWIG_fail;
35850 }
35851 {
35852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35853 }
35854 return resultobj;
35855 fail:
35856 return NULL;
35857 }
35858
35859
35860 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35861 PyObject *resultobj = 0;
35862 wxWindow *arg1 = (wxWindow *) 0 ;
35863 bool result;
35864 void *argp1 = 0 ;
35865 int res1 = 0 ;
35866 PyObject *swig_obj[1] ;
35867
35868 if (!args) SWIG_fail;
35869 swig_obj[0] = args;
35870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 {
35876 PyThreadState* __tstate = wxPyBeginAllowThreads();
35877 result = (bool)((wxWindow const *)arg1)->IsRetained();
35878 wxPyEndAllowThreads(__tstate);
35879 if (PyErr_Occurred()) SWIG_fail;
35880 }
35881 {
35882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35883 }
35884 return resultobj;
35885 fail:
35886 return NULL;
35887 }
35888
35889
35890 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35891 PyObject *resultobj = 0;
35892 wxWindow *arg1 = (wxWindow *) 0 ;
35893 long arg2 ;
35894 void *argp1 = 0 ;
35895 int res1 = 0 ;
35896 long val2 ;
35897 int ecode2 = 0 ;
35898 PyObject * obj0 = 0 ;
35899 PyObject * obj1 = 0 ;
35900 char * kwnames[] = {
35901 (char *) "self",(char *) "exStyle", NULL
35902 };
35903
35904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35906 if (!SWIG_IsOK(res1)) {
35907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35908 }
35909 arg1 = reinterpret_cast< wxWindow * >(argp1);
35910 ecode2 = SWIG_AsVal_long(obj1, &val2);
35911 if (!SWIG_IsOK(ecode2)) {
35912 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35913 }
35914 arg2 = static_cast< long >(val2);
35915 {
35916 PyThreadState* __tstate = wxPyBeginAllowThreads();
35917 (arg1)->SetExtraStyle(arg2);
35918 wxPyEndAllowThreads(__tstate);
35919 if (PyErr_Occurred()) SWIG_fail;
35920 }
35921 resultobj = SWIG_Py_Void();
35922 return resultobj;
35923 fail:
35924 return NULL;
35925 }
35926
35927
35928 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35929 PyObject *resultobj = 0;
35930 wxWindow *arg1 = (wxWindow *) 0 ;
35931 long result;
35932 void *argp1 = 0 ;
35933 int res1 = 0 ;
35934 PyObject *swig_obj[1] ;
35935
35936 if (!args) SWIG_fail;
35937 swig_obj[0] = args;
35938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35939 if (!SWIG_IsOK(res1)) {
35940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35941 }
35942 arg1 = reinterpret_cast< wxWindow * >(argp1);
35943 {
35944 PyThreadState* __tstate = wxPyBeginAllowThreads();
35945 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35946 wxPyEndAllowThreads(__tstate);
35947 if (PyErr_Occurred()) SWIG_fail;
35948 }
35949 resultobj = SWIG_From_long(static_cast< long >(result));
35950 return resultobj;
35951 fail:
35952 return NULL;
35953 }
35954
35955
35956 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35957 PyObject *resultobj = 0;
35958 wxWindow *arg1 = (wxWindow *) 0 ;
35959 bool arg2 = (bool) true ;
35960 void *argp1 = 0 ;
35961 int res1 = 0 ;
35962 bool val2 ;
35963 int ecode2 = 0 ;
35964 PyObject * obj0 = 0 ;
35965 PyObject * obj1 = 0 ;
35966 char * kwnames[] = {
35967 (char *) "self",(char *) "modal", NULL
35968 };
35969
35970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35972 if (!SWIG_IsOK(res1)) {
35973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35974 }
35975 arg1 = reinterpret_cast< wxWindow * >(argp1);
35976 if (obj1) {
35977 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35978 if (!SWIG_IsOK(ecode2)) {
35979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35980 }
35981 arg2 = static_cast< bool >(val2);
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 (arg1)->MakeModal(arg2);
35986 wxPyEndAllowThreads(__tstate);
35987 if (PyErr_Occurred()) SWIG_fail;
35988 }
35989 resultobj = SWIG_Py_Void();
35990 return resultobj;
35991 fail:
35992 return NULL;
35993 }
35994
35995
35996 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35997 PyObject *resultobj = 0;
35998 wxWindow *arg1 = (wxWindow *) 0 ;
35999 bool arg2 ;
36000 void *argp1 = 0 ;
36001 int res1 = 0 ;
36002 bool val2 ;
36003 int ecode2 = 0 ;
36004 PyObject * obj0 = 0 ;
36005 PyObject * obj1 = 0 ;
36006 char * kwnames[] = {
36007 (char *) "self",(char *) "enableTheme", NULL
36008 };
36009
36010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36012 if (!SWIG_IsOK(res1)) {
36013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36014 }
36015 arg1 = reinterpret_cast< wxWindow * >(argp1);
36016 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36017 if (!SWIG_IsOK(ecode2)) {
36018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36019 }
36020 arg2 = static_cast< bool >(val2);
36021 {
36022 PyThreadState* __tstate = wxPyBeginAllowThreads();
36023 (arg1)->SetThemeEnabled(arg2);
36024 wxPyEndAllowThreads(__tstate);
36025 if (PyErr_Occurred()) SWIG_fail;
36026 }
36027 resultobj = SWIG_Py_Void();
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36035 PyObject *resultobj = 0;
36036 wxWindow *arg1 = (wxWindow *) 0 ;
36037 bool result;
36038 void *argp1 = 0 ;
36039 int res1 = 0 ;
36040 PyObject *swig_obj[1] ;
36041
36042 if (!args) SWIG_fail;
36043 swig_obj[0] = args;
36044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36045 if (!SWIG_IsOK(res1)) {
36046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36047 }
36048 arg1 = reinterpret_cast< wxWindow * >(argp1);
36049 {
36050 PyThreadState* __tstate = wxPyBeginAllowThreads();
36051 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36052 wxPyEndAllowThreads(__tstate);
36053 if (PyErr_Occurred()) SWIG_fail;
36054 }
36055 {
36056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36057 }
36058 return resultobj;
36059 fail:
36060 return NULL;
36061 }
36062
36063
36064 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36065 PyObject *resultobj = 0;
36066 wxWindow *arg1 = (wxWindow *) 0 ;
36067 void *argp1 = 0 ;
36068 int res1 = 0 ;
36069 PyObject *swig_obj[1] ;
36070
36071 if (!args) SWIG_fail;
36072 swig_obj[0] = args;
36073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36074 if (!SWIG_IsOK(res1)) {
36075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36076 }
36077 arg1 = reinterpret_cast< wxWindow * >(argp1);
36078 {
36079 PyThreadState* __tstate = wxPyBeginAllowThreads();
36080 (arg1)->SetFocus();
36081 wxPyEndAllowThreads(__tstate);
36082 if (PyErr_Occurred()) SWIG_fail;
36083 }
36084 resultobj = SWIG_Py_Void();
36085 return resultobj;
36086 fail:
36087 return NULL;
36088 }
36089
36090
36091 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36092 PyObject *resultobj = 0;
36093 wxWindow *arg1 = (wxWindow *) 0 ;
36094 void *argp1 = 0 ;
36095 int res1 = 0 ;
36096 PyObject *swig_obj[1] ;
36097
36098 if (!args) SWIG_fail;
36099 swig_obj[0] = args;
36100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36101 if (!SWIG_IsOK(res1)) {
36102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36103 }
36104 arg1 = reinterpret_cast< wxWindow * >(argp1);
36105 {
36106 PyThreadState* __tstate = wxPyBeginAllowThreads();
36107 (arg1)->SetFocusFromKbd();
36108 wxPyEndAllowThreads(__tstate);
36109 if (PyErr_Occurred()) SWIG_fail;
36110 }
36111 resultobj = SWIG_Py_Void();
36112 return resultobj;
36113 fail:
36114 return NULL;
36115 }
36116
36117
36118 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36119 PyObject *resultobj = 0;
36120 wxWindow *result = 0 ;
36121
36122 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36123 {
36124 if (!wxPyCheckForApp()) SWIG_fail;
36125 PyThreadState* __tstate = wxPyBeginAllowThreads();
36126 result = (wxWindow *)wxWindow::FindFocus();
36127 wxPyEndAllowThreads(__tstate);
36128 if (PyErr_Occurred()) SWIG_fail;
36129 }
36130 {
36131 resultobj = wxPyMake_wxObject(result, 0);
36132 }
36133 return resultobj;
36134 fail:
36135 return NULL;
36136 }
36137
36138
36139 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36140 PyObject *resultobj = 0;
36141 wxWindow *arg1 = (wxWindow *) 0 ;
36142 bool result;
36143 void *argp1 = 0 ;
36144 int res1 = 0 ;
36145 PyObject *swig_obj[1] ;
36146
36147 if (!args) SWIG_fail;
36148 swig_obj[0] = args;
36149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36150 if (!SWIG_IsOK(res1)) {
36151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36152 }
36153 arg1 = reinterpret_cast< wxWindow * >(argp1);
36154 {
36155 PyThreadState* __tstate = wxPyBeginAllowThreads();
36156 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36157 wxPyEndAllowThreads(__tstate);
36158 if (PyErr_Occurred()) SWIG_fail;
36159 }
36160 {
36161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36162 }
36163 return resultobj;
36164 fail:
36165 return NULL;
36166 }
36167
36168
36169 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36170 PyObject *resultobj = 0;
36171 wxWindow *arg1 = (wxWindow *) 0 ;
36172 bool result;
36173 void *argp1 = 0 ;
36174 int res1 = 0 ;
36175 PyObject *swig_obj[1] ;
36176
36177 if (!args) SWIG_fail;
36178 swig_obj[0] = args;
36179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 {
36185 PyThreadState* __tstate = wxPyBeginAllowThreads();
36186 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36187 wxPyEndAllowThreads(__tstate);
36188 if (PyErr_Occurred()) SWIG_fail;
36189 }
36190 {
36191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36192 }
36193 return resultobj;
36194 fail:
36195 return NULL;
36196 }
36197
36198
36199 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36200 PyObject *resultobj = 0;
36201 wxWindow *arg1 = (wxWindow *) 0 ;
36202 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36203 bool result;
36204 void *argp1 = 0 ;
36205 int res1 = 0 ;
36206 int val2 ;
36207 int ecode2 = 0 ;
36208 PyObject * obj0 = 0 ;
36209 PyObject * obj1 = 0 ;
36210 char * kwnames[] = {
36211 (char *) "self",(char *) "flags", NULL
36212 };
36213
36214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36216 if (!SWIG_IsOK(res1)) {
36217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36218 }
36219 arg1 = reinterpret_cast< wxWindow * >(argp1);
36220 if (obj1) {
36221 ecode2 = SWIG_AsVal_int(obj1, &val2);
36222 if (!SWIG_IsOK(ecode2)) {
36223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36224 }
36225 arg2 = static_cast< int >(val2);
36226 }
36227 {
36228 PyThreadState* __tstate = wxPyBeginAllowThreads();
36229 result = (bool)(arg1)->Navigate(arg2);
36230 wxPyEndAllowThreads(__tstate);
36231 if (PyErr_Occurred()) SWIG_fail;
36232 }
36233 {
36234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36235 }
36236 return resultobj;
36237 fail:
36238 return NULL;
36239 }
36240
36241
36242 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36243 PyObject *resultobj = 0;
36244 wxWindow *arg1 = (wxWindow *) 0 ;
36245 wxWindow *arg2 = (wxWindow *) 0 ;
36246 void *argp1 = 0 ;
36247 int res1 = 0 ;
36248 void *argp2 = 0 ;
36249 int res2 = 0 ;
36250 PyObject * obj0 = 0 ;
36251 PyObject * obj1 = 0 ;
36252 char * kwnames[] = {
36253 (char *) "self",(char *) "win", NULL
36254 };
36255
36256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36258 if (!SWIG_IsOK(res1)) {
36259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36260 }
36261 arg1 = reinterpret_cast< wxWindow * >(argp1);
36262 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36263 if (!SWIG_IsOK(res2)) {
36264 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36265 }
36266 arg2 = reinterpret_cast< wxWindow * >(argp2);
36267 {
36268 PyThreadState* __tstate = wxPyBeginAllowThreads();
36269 (arg1)->MoveAfterInTabOrder(arg2);
36270 wxPyEndAllowThreads(__tstate);
36271 if (PyErr_Occurred()) SWIG_fail;
36272 }
36273 resultobj = SWIG_Py_Void();
36274 return resultobj;
36275 fail:
36276 return NULL;
36277 }
36278
36279
36280 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36281 PyObject *resultobj = 0;
36282 wxWindow *arg1 = (wxWindow *) 0 ;
36283 wxWindow *arg2 = (wxWindow *) 0 ;
36284 void *argp1 = 0 ;
36285 int res1 = 0 ;
36286 void *argp2 = 0 ;
36287 int res2 = 0 ;
36288 PyObject * obj0 = 0 ;
36289 PyObject * obj1 = 0 ;
36290 char * kwnames[] = {
36291 (char *) "self",(char *) "win", NULL
36292 };
36293
36294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36296 if (!SWIG_IsOK(res1)) {
36297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36298 }
36299 arg1 = reinterpret_cast< wxWindow * >(argp1);
36300 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36301 if (!SWIG_IsOK(res2)) {
36302 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36303 }
36304 arg2 = reinterpret_cast< wxWindow * >(argp2);
36305 {
36306 PyThreadState* __tstate = wxPyBeginAllowThreads();
36307 (arg1)->MoveBeforeInTabOrder(arg2);
36308 wxPyEndAllowThreads(__tstate);
36309 if (PyErr_Occurred()) SWIG_fail;
36310 }
36311 resultobj = SWIG_Py_Void();
36312 return resultobj;
36313 fail:
36314 return NULL;
36315 }
36316
36317
36318 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36319 PyObject *resultobj = 0;
36320 wxWindow *arg1 = (wxWindow *) 0 ;
36321 PyObject *result = 0 ;
36322 void *argp1 = 0 ;
36323 int res1 = 0 ;
36324 PyObject *swig_obj[1] ;
36325
36326 if (!args) SWIG_fail;
36327 swig_obj[0] = args;
36328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36329 if (!SWIG_IsOK(res1)) {
36330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36331 }
36332 arg1 = reinterpret_cast< wxWindow * >(argp1);
36333 {
36334 PyThreadState* __tstate = wxPyBeginAllowThreads();
36335 result = (PyObject *)wxWindow_GetChildren(arg1);
36336 wxPyEndAllowThreads(__tstate);
36337 if (PyErr_Occurred()) SWIG_fail;
36338 }
36339 resultobj = result;
36340 return resultobj;
36341 fail:
36342 return NULL;
36343 }
36344
36345
36346 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36347 PyObject *resultobj = 0;
36348 wxWindow *arg1 = (wxWindow *) 0 ;
36349 wxWindow *result = 0 ;
36350 void *argp1 = 0 ;
36351 int res1 = 0 ;
36352 PyObject *swig_obj[1] ;
36353
36354 if (!args) SWIG_fail;
36355 swig_obj[0] = args;
36356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 {
36362 PyThreadState* __tstate = wxPyBeginAllowThreads();
36363 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36364 wxPyEndAllowThreads(__tstate);
36365 if (PyErr_Occurred()) SWIG_fail;
36366 }
36367 {
36368 resultobj = wxPyMake_wxObject(result, 0);
36369 }
36370 return resultobj;
36371 fail:
36372 return NULL;
36373 }
36374
36375
36376 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36377 PyObject *resultobj = 0;
36378 wxWindow *arg1 = (wxWindow *) 0 ;
36379 wxWindow *result = 0 ;
36380 void *argp1 = 0 ;
36381 int res1 = 0 ;
36382 PyObject *swig_obj[1] ;
36383
36384 if (!args) SWIG_fail;
36385 swig_obj[0] = args;
36386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36387 if (!SWIG_IsOK(res1)) {
36388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36389 }
36390 arg1 = reinterpret_cast< wxWindow * >(argp1);
36391 {
36392 PyThreadState* __tstate = wxPyBeginAllowThreads();
36393 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 {
36398 resultobj = wxPyMake_wxObject(result, 0);
36399 }
36400 return resultobj;
36401 fail:
36402 return NULL;
36403 }
36404
36405
36406 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36407 PyObject *resultobj = 0;
36408 wxWindow *arg1 = (wxWindow *) 0 ;
36409 bool result;
36410 void *argp1 = 0 ;
36411 int res1 = 0 ;
36412 PyObject *swig_obj[1] ;
36413
36414 if (!args) SWIG_fail;
36415 swig_obj[0] = args;
36416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36417 if (!SWIG_IsOK(res1)) {
36418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36419 }
36420 arg1 = reinterpret_cast< wxWindow * >(argp1);
36421 {
36422 PyThreadState* __tstate = wxPyBeginAllowThreads();
36423 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36424 wxPyEndAllowThreads(__tstate);
36425 if (PyErr_Occurred()) SWIG_fail;
36426 }
36427 {
36428 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36429 }
36430 return resultobj;
36431 fail:
36432 return NULL;
36433 }
36434
36435
36436 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36437 PyObject *resultobj = 0;
36438 wxWindow *arg1 = (wxWindow *) 0 ;
36439 wxWindow *arg2 = (wxWindow *) 0 ;
36440 bool result;
36441 void *argp1 = 0 ;
36442 int res1 = 0 ;
36443 void *argp2 = 0 ;
36444 int res2 = 0 ;
36445 PyObject * obj0 = 0 ;
36446 PyObject * obj1 = 0 ;
36447 char * kwnames[] = {
36448 (char *) "self",(char *) "newParent", NULL
36449 };
36450
36451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36453 if (!SWIG_IsOK(res1)) {
36454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36455 }
36456 arg1 = reinterpret_cast< wxWindow * >(argp1);
36457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36458 if (!SWIG_IsOK(res2)) {
36459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36460 }
36461 arg2 = reinterpret_cast< wxWindow * >(argp2);
36462 {
36463 PyThreadState* __tstate = wxPyBeginAllowThreads();
36464 result = (bool)(arg1)->Reparent(arg2);
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 {
36469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36470 }
36471 return resultobj;
36472 fail:
36473 return NULL;
36474 }
36475
36476
36477 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36478 PyObject *resultobj = 0;
36479 wxWindow *arg1 = (wxWindow *) 0 ;
36480 wxWindow *arg2 = (wxWindow *) 0 ;
36481 void *argp1 = 0 ;
36482 int res1 = 0 ;
36483 void *argp2 = 0 ;
36484 int res2 = 0 ;
36485 PyObject * obj0 = 0 ;
36486 PyObject * obj1 = 0 ;
36487 char * kwnames[] = {
36488 (char *) "self",(char *) "child", NULL
36489 };
36490
36491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36493 if (!SWIG_IsOK(res1)) {
36494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36495 }
36496 arg1 = reinterpret_cast< wxWindow * >(argp1);
36497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36498 if (!SWIG_IsOK(res2)) {
36499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36500 }
36501 arg2 = reinterpret_cast< wxWindow * >(argp2);
36502 {
36503 PyThreadState* __tstate = wxPyBeginAllowThreads();
36504 (arg1)->AddChild(arg2);
36505 wxPyEndAllowThreads(__tstate);
36506 if (PyErr_Occurred()) SWIG_fail;
36507 }
36508 resultobj = SWIG_Py_Void();
36509 return resultobj;
36510 fail:
36511 return NULL;
36512 }
36513
36514
36515 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36516 PyObject *resultobj = 0;
36517 wxWindow *arg1 = (wxWindow *) 0 ;
36518 wxWindow *arg2 = (wxWindow *) 0 ;
36519 void *argp1 = 0 ;
36520 int res1 = 0 ;
36521 void *argp2 = 0 ;
36522 int res2 = 0 ;
36523 PyObject * obj0 = 0 ;
36524 PyObject * obj1 = 0 ;
36525 char * kwnames[] = {
36526 (char *) "self",(char *) "child", NULL
36527 };
36528
36529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36531 if (!SWIG_IsOK(res1)) {
36532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36533 }
36534 arg1 = reinterpret_cast< wxWindow * >(argp1);
36535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36536 if (!SWIG_IsOK(res2)) {
36537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36538 }
36539 arg2 = reinterpret_cast< wxWindow * >(argp2);
36540 {
36541 PyThreadState* __tstate = wxPyBeginAllowThreads();
36542 (arg1)->RemoveChild(arg2);
36543 wxPyEndAllowThreads(__tstate);
36544 if (PyErr_Occurred()) SWIG_fail;
36545 }
36546 resultobj = SWIG_Py_Void();
36547 return resultobj;
36548 fail:
36549 return NULL;
36550 }
36551
36552
36553 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36554 PyObject *resultobj = 0;
36555 wxWindow *arg1 = (wxWindow *) 0 ;
36556 bool arg2 ;
36557 void *argp1 = 0 ;
36558 int res1 = 0 ;
36559 bool val2 ;
36560 int ecode2 = 0 ;
36561 PyObject * obj0 = 0 ;
36562 PyObject * obj1 = 0 ;
36563 char * kwnames[] = {
36564 (char *) "self",(char *) "on", NULL
36565 };
36566
36567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36569 if (!SWIG_IsOK(res1)) {
36570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36571 }
36572 arg1 = reinterpret_cast< wxWindow * >(argp1);
36573 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36574 if (!SWIG_IsOK(ecode2)) {
36575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36576 }
36577 arg2 = static_cast< bool >(val2);
36578 {
36579 PyThreadState* __tstate = wxPyBeginAllowThreads();
36580 wxWindow_SetDoubleBuffered(arg1,arg2);
36581 wxPyEndAllowThreads(__tstate);
36582 if (PyErr_Occurred()) SWIG_fail;
36583 }
36584 resultobj = SWIG_Py_Void();
36585 return resultobj;
36586 fail:
36587 return NULL;
36588 }
36589
36590
36591 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36592 PyObject *resultobj = 0;
36593 wxWindow *arg1 = (wxWindow *) 0 ;
36594 long arg2 ;
36595 wxWindow *result = 0 ;
36596 void *argp1 = 0 ;
36597 int res1 = 0 ;
36598 long val2 ;
36599 int ecode2 = 0 ;
36600 PyObject * obj0 = 0 ;
36601 PyObject * obj1 = 0 ;
36602 char * kwnames[] = {
36603 (char *) "self",(char *) "winid", NULL
36604 };
36605
36606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36608 if (!SWIG_IsOK(res1)) {
36609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36610 }
36611 arg1 = reinterpret_cast< wxWindow * >(argp1);
36612 ecode2 = SWIG_AsVal_long(obj1, &val2);
36613 if (!SWIG_IsOK(ecode2)) {
36614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36615 }
36616 arg2 = static_cast< long >(val2);
36617 {
36618 PyThreadState* __tstate = wxPyBeginAllowThreads();
36619 result = (wxWindow *)(arg1)->FindWindow(arg2);
36620 wxPyEndAllowThreads(__tstate);
36621 if (PyErr_Occurred()) SWIG_fail;
36622 }
36623 {
36624 resultobj = wxPyMake_wxObject(result, 0);
36625 }
36626 return resultobj;
36627 fail:
36628 return NULL;
36629 }
36630
36631
36632 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36633 PyObject *resultobj = 0;
36634 wxWindow *arg1 = (wxWindow *) 0 ;
36635 wxString *arg2 = 0 ;
36636 wxWindow *result = 0 ;
36637 void *argp1 = 0 ;
36638 int res1 = 0 ;
36639 bool temp2 = false ;
36640 PyObject * obj0 = 0 ;
36641 PyObject * obj1 = 0 ;
36642 char * kwnames[] = {
36643 (char *) "self",(char *) "name", NULL
36644 };
36645
36646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36648 if (!SWIG_IsOK(res1)) {
36649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36650 }
36651 arg1 = reinterpret_cast< wxWindow * >(argp1);
36652 {
36653 arg2 = wxString_in_helper(obj1);
36654 if (arg2 == NULL) SWIG_fail;
36655 temp2 = true;
36656 }
36657 {
36658 PyThreadState* __tstate = wxPyBeginAllowThreads();
36659 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36660 wxPyEndAllowThreads(__tstate);
36661 if (PyErr_Occurred()) SWIG_fail;
36662 }
36663 {
36664 resultobj = wxPyMake_wxObject(result, 0);
36665 }
36666 {
36667 if (temp2)
36668 delete arg2;
36669 }
36670 return resultobj;
36671 fail:
36672 {
36673 if (temp2)
36674 delete arg2;
36675 }
36676 return NULL;
36677 }
36678
36679
36680 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36681 PyObject *resultobj = 0;
36682 wxWindow *arg1 = (wxWindow *) 0 ;
36683 wxEvtHandler *result = 0 ;
36684 void *argp1 = 0 ;
36685 int res1 = 0 ;
36686 PyObject *swig_obj[1] ;
36687
36688 if (!args) SWIG_fail;
36689 swig_obj[0] = args;
36690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36691 if (!SWIG_IsOK(res1)) {
36692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36693 }
36694 arg1 = reinterpret_cast< wxWindow * >(argp1);
36695 {
36696 PyThreadState* __tstate = wxPyBeginAllowThreads();
36697 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36698 wxPyEndAllowThreads(__tstate);
36699 if (PyErr_Occurred()) SWIG_fail;
36700 }
36701 {
36702 resultobj = wxPyMake_wxObject(result, 0);
36703 }
36704 return resultobj;
36705 fail:
36706 return NULL;
36707 }
36708
36709
36710 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36711 PyObject *resultobj = 0;
36712 wxWindow *arg1 = (wxWindow *) 0 ;
36713 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36714 void *argp1 = 0 ;
36715 int res1 = 0 ;
36716 void *argp2 = 0 ;
36717 int res2 = 0 ;
36718 PyObject * obj0 = 0 ;
36719 PyObject * obj1 = 0 ;
36720 char * kwnames[] = {
36721 (char *) "self",(char *) "handler", NULL
36722 };
36723
36724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36726 if (!SWIG_IsOK(res1)) {
36727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36728 }
36729 arg1 = reinterpret_cast< wxWindow * >(argp1);
36730 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36731 if (!SWIG_IsOK(res2)) {
36732 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36733 }
36734 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36735 {
36736 PyThreadState* __tstate = wxPyBeginAllowThreads();
36737 (arg1)->SetEventHandler(arg2);
36738 wxPyEndAllowThreads(__tstate);
36739 if (PyErr_Occurred()) SWIG_fail;
36740 }
36741 resultobj = SWIG_Py_Void();
36742 return resultobj;
36743 fail:
36744 return NULL;
36745 }
36746
36747
36748 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36749 PyObject *resultobj = 0;
36750 wxWindow *arg1 = (wxWindow *) 0 ;
36751 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36752 void *argp1 = 0 ;
36753 int res1 = 0 ;
36754 void *argp2 = 0 ;
36755 int res2 = 0 ;
36756 PyObject * obj0 = 0 ;
36757 PyObject * obj1 = 0 ;
36758 char * kwnames[] = {
36759 (char *) "self",(char *) "handler", NULL
36760 };
36761
36762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36764 if (!SWIG_IsOK(res1)) {
36765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36766 }
36767 arg1 = reinterpret_cast< wxWindow * >(argp1);
36768 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36769 if (!SWIG_IsOK(res2)) {
36770 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36771 }
36772 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36773 {
36774 PyThreadState* __tstate = wxPyBeginAllowThreads();
36775 (arg1)->PushEventHandler(arg2);
36776 wxPyEndAllowThreads(__tstate);
36777 if (PyErr_Occurred()) SWIG_fail;
36778 }
36779 resultobj = SWIG_Py_Void();
36780 return resultobj;
36781 fail:
36782 return NULL;
36783 }
36784
36785
36786 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36787 PyObject *resultobj = 0;
36788 wxWindow *arg1 = (wxWindow *) 0 ;
36789 bool arg2 = (bool) false ;
36790 wxEvtHandler *result = 0 ;
36791 void *argp1 = 0 ;
36792 int res1 = 0 ;
36793 bool val2 ;
36794 int ecode2 = 0 ;
36795 PyObject * obj0 = 0 ;
36796 PyObject * obj1 = 0 ;
36797 char * kwnames[] = {
36798 (char *) "self",(char *) "deleteHandler", NULL
36799 };
36800
36801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36803 if (!SWIG_IsOK(res1)) {
36804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36805 }
36806 arg1 = reinterpret_cast< wxWindow * >(argp1);
36807 if (obj1) {
36808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36809 if (!SWIG_IsOK(ecode2)) {
36810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36811 }
36812 arg2 = static_cast< bool >(val2);
36813 }
36814 {
36815 PyThreadState* __tstate = wxPyBeginAllowThreads();
36816 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36817 wxPyEndAllowThreads(__tstate);
36818 if (PyErr_Occurred()) SWIG_fail;
36819 }
36820 {
36821 resultobj = wxPyMake_wxObject(result, 0);
36822 }
36823 return resultobj;
36824 fail:
36825 return NULL;
36826 }
36827
36828
36829 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36830 PyObject *resultobj = 0;
36831 wxWindow *arg1 = (wxWindow *) 0 ;
36832 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36833 bool result;
36834 void *argp1 = 0 ;
36835 int res1 = 0 ;
36836 void *argp2 = 0 ;
36837 int res2 = 0 ;
36838 PyObject * obj0 = 0 ;
36839 PyObject * obj1 = 0 ;
36840 char * kwnames[] = {
36841 (char *) "self",(char *) "handler", NULL
36842 };
36843
36844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36846 if (!SWIG_IsOK(res1)) {
36847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36848 }
36849 arg1 = reinterpret_cast< wxWindow * >(argp1);
36850 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36851 if (!SWIG_IsOK(res2)) {
36852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36853 }
36854 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36855 {
36856 PyThreadState* __tstate = wxPyBeginAllowThreads();
36857 result = (bool)(arg1)->RemoveEventHandler(arg2);
36858 wxPyEndAllowThreads(__tstate);
36859 if (PyErr_Occurred()) SWIG_fail;
36860 }
36861 {
36862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36863 }
36864 return resultobj;
36865 fail:
36866 return NULL;
36867 }
36868
36869
36870 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36871 PyObject *resultobj = 0;
36872 wxWindow *arg1 = (wxWindow *) 0 ;
36873 wxValidator *arg2 = 0 ;
36874 void *argp1 = 0 ;
36875 int res1 = 0 ;
36876 void *argp2 = 0 ;
36877 int res2 = 0 ;
36878 PyObject * obj0 = 0 ;
36879 PyObject * obj1 = 0 ;
36880 char * kwnames[] = {
36881 (char *) "self",(char *) "validator", NULL
36882 };
36883
36884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36886 if (!SWIG_IsOK(res1)) {
36887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36888 }
36889 arg1 = reinterpret_cast< wxWindow * >(argp1);
36890 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36891 if (!SWIG_IsOK(res2)) {
36892 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36893 }
36894 if (!argp2) {
36895 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36896 }
36897 arg2 = reinterpret_cast< wxValidator * >(argp2);
36898 {
36899 PyThreadState* __tstate = wxPyBeginAllowThreads();
36900 (arg1)->SetValidator((wxValidator const &)*arg2);
36901 wxPyEndAllowThreads(__tstate);
36902 if (PyErr_Occurred()) SWIG_fail;
36903 }
36904 resultobj = SWIG_Py_Void();
36905 return resultobj;
36906 fail:
36907 return NULL;
36908 }
36909
36910
36911 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36912 PyObject *resultobj = 0;
36913 wxWindow *arg1 = (wxWindow *) 0 ;
36914 wxValidator *result = 0 ;
36915 void *argp1 = 0 ;
36916 int res1 = 0 ;
36917 PyObject *swig_obj[1] ;
36918
36919 if (!args) SWIG_fail;
36920 swig_obj[0] = args;
36921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36922 if (!SWIG_IsOK(res1)) {
36923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36924 }
36925 arg1 = reinterpret_cast< wxWindow * >(argp1);
36926 {
36927 PyThreadState* __tstate = wxPyBeginAllowThreads();
36928 result = (wxValidator *)(arg1)->GetValidator();
36929 wxPyEndAllowThreads(__tstate);
36930 if (PyErr_Occurred()) SWIG_fail;
36931 }
36932 {
36933 resultobj = wxPyMake_wxObject(result, (bool)0);
36934 }
36935 return resultobj;
36936 fail:
36937 return NULL;
36938 }
36939
36940
36941 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36942 PyObject *resultobj = 0;
36943 wxWindow *arg1 = (wxWindow *) 0 ;
36944 bool result;
36945 void *argp1 = 0 ;
36946 int res1 = 0 ;
36947 PyObject *swig_obj[1] ;
36948
36949 if (!args) SWIG_fail;
36950 swig_obj[0] = args;
36951 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36952 if (!SWIG_IsOK(res1)) {
36953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36954 }
36955 arg1 = reinterpret_cast< wxWindow * >(argp1);
36956 {
36957 PyThreadState* __tstate = wxPyBeginAllowThreads();
36958 result = (bool)(arg1)->Validate();
36959 wxPyEndAllowThreads(__tstate);
36960 if (PyErr_Occurred()) SWIG_fail;
36961 }
36962 {
36963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36964 }
36965 return resultobj;
36966 fail:
36967 return NULL;
36968 }
36969
36970
36971 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36972 PyObject *resultobj = 0;
36973 wxWindow *arg1 = (wxWindow *) 0 ;
36974 bool result;
36975 void *argp1 = 0 ;
36976 int res1 = 0 ;
36977 PyObject *swig_obj[1] ;
36978
36979 if (!args) SWIG_fail;
36980 swig_obj[0] = args;
36981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36982 if (!SWIG_IsOK(res1)) {
36983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36984 }
36985 arg1 = reinterpret_cast< wxWindow * >(argp1);
36986 {
36987 PyThreadState* __tstate = wxPyBeginAllowThreads();
36988 result = (bool)(arg1)->TransferDataToWindow();
36989 wxPyEndAllowThreads(__tstate);
36990 if (PyErr_Occurred()) SWIG_fail;
36991 }
36992 {
36993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36994 }
36995 return resultobj;
36996 fail:
36997 return NULL;
36998 }
36999
37000
37001 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37002 PyObject *resultobj = 0;
37003 wxWindow *arg1 = (wxWindow *) 0 ;
37004 bool result;
37005 void *argp1 = 0 ;
37006 int res1 = 0 ;
37007 PyObject *swig_obj[1] ;
37008
37009 if (!args) SWIG_fail;
37010 swig_obj[0] = args;
37011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37012 if (!SWIG_IsOK(res1)) {
37013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37014 }
37015 arg1 = reinterpret_cast< wxWindow * >(argp1);
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 result = (bool)(arg1)->TransferDataFromWindow();
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 {
37023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37024 }
37025 return resultobj;
37026 fail:
37027 return NULL;
37028 }
37029
37030
37031 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37032 PyObject *resultobj = 0;
37033 wxWindow *arg1 = (wxWindow *) 0 ;
37034 void *argp1 = 0 ;
37035 int res1 = 0 ;
37036 PyObject *swig_obj[1] ;
37037
37038 if (!args) SWIG_fail;
37039 swig_obj[0] = args;
37040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37041 if (!SWIG_IsOK(res1)) {
37042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37043 }
37044 arg1 = reinterpret_cast< wxWindow * >(argp1);
37045 {
37046 PyThreadState* __tstate = wxPyBeginAllowThreads();
37047 (arg1)->InitDialog();
37048 wxPyEndAllowThreads(__tstate);
37049 if (PyErr_Occurred()) SWIG_fail;
37050 }
37051 resultobj = SWIG_Py_Void();
37052 return resultobj;
37053 fail:
37054 return NULL;
37055 }
37056
37057
37058 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37059 PyObject *resultobj = 0;
37060 wxWindow *arg1 = (wxWindow *) 0 ;
37061 wxAcceleratorTable *arg2 = 0 ;
37062 void *argp1 = 0 ;
37063 int res1 = 0 ;
37064 void *argp2 = 0 ;
37065 int res2 = 0 ;
37066 PyObject * obj0 = 0 ;
37067 PyObject * obj1 = 0 ;
37068 char * kwnames[] = {
37069 (char *) "self",(char *) "accel", NULL
37070 };
37071
37072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37074 if (!SWIG_IsOK(res1)) {
37075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37076 }
37077 arg1 = reinterpret_cast< wxWindow * >(argp1);
37078 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37079 if (!SWIG_IsOK(res2)) {
37080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37081 }
37082 if (!argp2) {
37083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37084 }
37085 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37086 {
37087 PyThreadState* __tstate = wxPyBeginAllowThreads();
37088 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37089 wxPyEndAllowThreads(__tstate);
37090 if (PyErr_Occurred()) SWIG_fail;
37091 }
37092 resultobj = SWIG_Py_Void();
37093 return resultobj;
37094 fail:
37095 return NULL;
37096 }
37097
37098
37099 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37100 PyObject *resultobj = 0;
37101 wxWindow *arg1 = (wxWindow *) 0 ;
37102 wxAcceleratorTable *result = 0 ;
37103 void *argp1 = 0 ;
37104 int res1 = 0 ;
37105 PyObject *swig_obj[1] ;
37106
37107 if (!args) SWIG_fail;
37108 swig_obj[0] = args;
37109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37110 if (!SWIG_IsOK(res1)) {
37111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37112 }
37113 arg1 = reinterpret_cast< wxWindow * >(argp1);
37114 {
37115 PyThreadState* __tstate = wxPyBeginAllowThreads();
37116 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37117 wxPyEndAllowThreads(__tstate);
37118 if (PyErr_Occurred()) SWIG_fail;
37119 }
37120 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37121 return resultobj;
37122 fail:
37123 return NULL;
37124 }
37125
37126
37127 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37128 PyObject *resultobj = 0;
37129 wxWindow *arg1 = (wxWindow *) 0 ;
37130 int arg2 ;
37131 int arg3 ;
37132 int arg4 ;
37133 bool result;
37134 void *argp1 = 0 ;
37135 int res1 = 0 ;
37136 int val2 ;
37137 int ecode2 = 0 ;
37138 int val3 ;
37139 int ecode3 = 0 ;
37140 int val4 ;
37141 int ecode4 = 0 ;
37142 PyObject * obj0 = 0 ;
37143 PyObject * obj1 = 0 ;
37144 PyObject * obj2 = 0 ;
37145 PyObject * obj3 = 0 ;
37146 char * kwnames[] = {
37147 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37148 };
37149
37150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37152 if (!SWIG_IsOK(res1)) {
37153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37154 }
37155 arg1 = reinterpret_cast< wxWindow * >(argp1);
37156 ecode2 = SWIG_AsVal_int(obj1, &val2);
37157 if (!SWIG_IsOK(ecode2)) {
37158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37159 }
37160 arg2 = static_cast< int >(val2);
37161 ecode3 = SWIG_AsVal_int(obj2, &val3);
37162 if (!SWIG_IsOK(ecode3)) {
37163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37164 }
37165 arg3 = static_cast< int >(val3);
37166 ecode4 = SWIG_AsVal_int(obj3, &val4);
37167 if (!SWIG_IsOK(ecode4)) {
37168 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37169 }
37170 arg4 = static_cast< int >(val4);
37171 {
37172 PyThreadState* __tstate = wxPyBeginAllowThreads();
37173 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37174 wxPyEndAllowThreads(__tstate);
37175 if (PyErr_Occurred()) SWIG_fail;
37176 }
37177 {
37178 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37179 }
37180 return resultobj;
37181 fail:
37182 return NULL;
37183 }
37184
37185
37186 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37187 PyObject *resultobj = 0;
37188 wxWindow *arg1 = (wxWindow *) 0 ;
37189 int arg2 ;
37190 bool result;
37191 void *argp1 = 0 ;
37192 int res1 = 0 ;
37193 int val2 ;
37194 int ecode2 = 0 ;
37195 PyObject * obj0 = 0 ;
37196 PyObject * obj1 = 0 ;
37197 char * kwnames[] = {
37198 (char *) "self",(char *) "hotkeyId", NULL
37199 };
37200
37201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37203 if (!SWIG_IsOK(res1)) {
37204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37205 }
37206 arg1 = reinterpret_cast< wxWindow * >(argp1);
37207 ecode2 = SWIG_AsVal_int(obj1, &val2);
37208 if (!SWIG_IsOK(ecode2)) {
37209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37210 }
37211 arg2 = static_cast< int >(val2);
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 {
37219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37220 }
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37228 PyObject *resultobj = 0;
37229 wxWindow *arg1 = (wxWindow *) 0 ;
37230 wxPoint *arg2 = 0 ;
37231 wxPoint result;
37232 void *argp1 = 0 ;
37233 int res1 = 0 ;
37234 wxPoint temp2 ;
37235 PyObject * obj0 = 0 ;
37236 PyObject * obj1 = 0 ;
37237 char * kwnames[] = {
37238 (char *) "self",(char *) "pt", NULL
37239 };
37240
37241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37243 if (!SWIG_IsOK(res1)) {
37244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37245 }
37246 arg1 = reinterpret_cast< wxWindow * >(argp1);
37247 {
37248 arg2 = &temp2;
37249 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37250 }
37251 {
37252 PyThreadState* __tstate = wxPyBeginAllowThreads();
37253 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37254 wxPyEndAllowThreads(__tstate);
37255 if (PyErr_Occurred()) SWIG_fail;
37256 }
37257 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37258 return resultobj;
37259 fail:
37260 return NULL;
37261 }
37262
37263
37264 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37265 PyObject *resultobj = 0;
37266 wxWindow *arg1 = (wxWindow *) 0 ;
37267 wxSize *arg2 = 0 ;
37268 wxSize result;
37269 void *argp1 = 0 ;
37270 int res1 = 0 ;
37271 wxSize temp2 ;
37272 PyObject * obj0 = 0 ;
37273 PyObject * obj1 = 0 ;
37274 char * kwnames[] = {
37275 (char *) "self",(char *) "sz", NULL
37276 };
37277
37278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37280 if (!SWIG_IsOK(res1)) {
37281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37282 }
37283 arg1 = reinterpret_cast< wxWindow * >(argp1);
37284 {
37285 arg2 = &temp2;
37286 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37287 }
37288 {
37289 PyThreadState* __tstate = wxPyBeginAllowThreads();
37290 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37291 wxPyEndAllowThreads(__tstate);
37292 if (PyErr_Occurred()) SWIG_fail;
37293 }
37294 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 wxPoint *arg2 = 0 ;
37305 wxPoint result;
37306 void *argp1 = 0 ;
37307 int res1 = 0 ;
37308 wxPoint temp2 ;
37309 PyObject * obj0 = 0 ;
37310 PyObject * obj1 = 0 ;
37311 char * kwnames[] = {
37312 (char *) "self",(char *) "pt", NULL
37313 };
37314
37315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37317 if (!SWIG_IsOK(res1)) {
37318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37319 }
37320 arg1 = reinterpret_cast< wxWindow * >(argp1);
37321 {
37322 arg2 = &temp2;
37323 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37324 }
37325 {
37326 PyThreadState* __tstate = wxPyBeginAllowThreads();
37327 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37328 wxPyEndAllowThreads(__tstate);
37329 if (PyErr_Occurred()) SWIG_fail;
37330 }
37331 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37332 return resultobj;
37333 fail:
37334 return NULL;
37335 }
37336
37337
37338 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37339 PyObject *resultobj = 0;
37340 wxWindow *arg1 = (wxWindow *) 0 ;
37341 wxSize *arg2 = 0 ;
37342 wxSize result;
37343 void *argp1 = 0 ;
37344 int res1 = 0 ;
37345 wxSize temp2 ;
37346 PyObject * obj0 = 0 ;
37347 PyObject * obj1 = 0 ;
37348 char * kwnames[] = {
37349 (char *) "self",(char *) "sz", NULL
37350 };
37351
37352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37354 if (!SWIG_IsOK(res1)) {
37355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37356 }
37357 arg1 = reinterpret_cast< wxWindow * >(argp1);
37358 {
37359 arg2 = &temp2;
37360 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37361 }
37362 {
37363 PyThreadState* __tstate = wxPyBeginAllowThreads();
37364 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37365 wxPyEndAllowThreads(__tstate);
37366 if (PyErr_Occurred()) SWIG_fail;
37367 }
37368 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37369 return resultobj;
37370 fail:
37371 return NULL;
37372 }
37373
37374
37375 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37376 PyObject *resultobj = 0;
37377 wxWindow *arg1 = (wxWindow *) 0 ;
37378 wxPoint *arg2 = 0 ;
37379 wxPoint result;
37380 void *argp1 = 0 ;
37381 int res1 = 0 ;
37382 wxPoint temp2 ;
37383 PyObject * obj0 = 0 ;
37384 PyObject * obj1 = 0 ;
37385 char * kwnames[] = {
37386 (char *) "self",(char *) "pt", NULL
37387 };
37388
37389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37391 if (!SWIG_IsOK(res1)) {
37392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37393 }
37394 arg1 = reinterpret_cast< wxWindow * >(argp1);
37395 {
37396 arg2 = &temp2;
37397 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37398 }
37399 {
37400 PyThreadState* __tstate = wxPyBeginAllowThreads();
37401 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37406 return resultobj;
37407 fail:
37408 return NULL;
37409 }
37410
37411
37412 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37413 PyObject *resultobj = 0;
37414 wxWindow *arg1 = (wxWindow *) 0 ;
37415 wxSize *arg2 = 0 ;
37416 wxSize result;
37417 void *argp1 = 0 ;
37418 int res1 = 0 ;
37419 wxSize temp2 ;
37420 PyObject * obj0 = 0 ;
37421 PyObject * obj1 = 0 ;
37422 char * kwnames[] = {
37423 (char *) "self",(char *) "sz", NULL
37424 };
37425
37426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37428 if (!SWIG_IsOK(res1)) {
37429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37430 }
37431 arg1 = reinterpret_cast< wxWindow * >(argp1);
37432 {
37433 arg2 = &temp2;
37434 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37435 }
37436 {
37437 PyThreadState* __tstate = wxPyBeginAllowThreads();
37438 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37443 return resultobj;
37444 fail:
37445 return NULL;
37446 }
37447
37448
37449 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37450 PyObject *resultobj = 0;
37451 wxWindow *arg1 = (wxWindow *) 0 ;
37452 int arg2 ;
37453 int arg3 ;
37454 void *argp1 = 0 ;
37455 int res1 = 0 ;
37456 int val2 ;
37457 int ecode2 = 0 ;
37458 int val3 ;
37459 int ecode3 = 0 ;
37460 PyObject * obj0 = 0 ;
37461 PyObject * obj1 = 0 ;
37462 PyObject * obj2 = 0 ;
37463 char * kwnames[] = {
37464 (char *) "self",(char *) "x",(char *) "y", NULL
37465 };
37466
37467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37469 if (!SWIG_IsOK(res1)) {
37470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37471 }
37472 arg1 = reinterpret_cast< wxWindow * >(argp1);
37473 ecode2 = SWIG_AsVal_int(obj1, &val2);
37474 if (!SWIG_IsOK(ecode2)) {
37475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37476 }
37477 arg2 = static_cast< int >(val2);
37478 ecode3 = SWIG_AsVal_int(obj2, &val3);
37479 if (!SWIG_IsOK(ecode3)) {
37480 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37481 }
37482 arg3 = static_cast< int >(val3);
37483 {
37484 PyThreadState* __tstate = wxPyBeginAllowThreads();
37485 (arg1)->WarpPointer(arg2,arg3);
37486 wxPyEndAllowThreads(__tstate);
37487 if (PyErr_Occurred()) SWIG_fail;
37488 }
37489 resultobj = SWIG_Py_Void();
37490 return resultobj;
37491 fail:
37492 return NULL;
37493 }
37494
37495
37496 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37497 PyObject *resultobj = 0;
37498 wxWindow *arg1 = (wxWindow *) 0 ;
37499 void *argp1 = 0 ;
37500 int res1 = 0 ;
37501 PyObject *swig_obj[1] ;
37502
37503 if (!args) SWIG_fail;
37504 swig_obj[0] = args;
37505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37506 if (!SWIG_IsOK(res1)) {
37507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37508 }
37509 arg1 = reinterpret_cast< wxWindow * >(argp1);
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 (arg1)->CaptureMouse();
37513 wxPyEndAllowThreads(__tstate);
37514 if (PyErr_Occurred()) SWIG_fail;
37515 }
37516 resultobj = SWIG_Py_Void();
37517 return resultobj;
37518 fail:
37519 return NULL;
37520 }
37521
37522
37523 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37524 PyObject *resultobj = 0;
37525 wxWindow *arg1 = (wxWindow *) 0 ;
37526 void *argp1 = 0 ;
37527 int res1 = 0 ;
37528 PyObject *swig_obj[1] ;
37529
37530 if (!args) SWIG_fail;
37531 swig_obj[0] = args;
37532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37533 if (!SWIG_IsOK(res1)) {
37534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37535 }
37536 arg1 = reinterpret_cast< wxWindow * >(argp1);
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 (arg1)->ReleaseMouse();
37540 wxPyEndAllowThreads(__tstate);
37541 if (PyErr_Occurred()) SWIG_fail;
37542 }
37543 resultobj = SWIG_Py_Void();
37544 return resultobj;
37545 fail:
37546 return NULL;
37547 }
37548
37549
37550 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37551 PyObject *resultobj = 0;
37552 wxWindow *result = 0 ;
37553
37554 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37555 {
37556 if (!wxPyCheckForApp()) SWIG_fail;
37557 PyThreadState* __tstate = wxPyBeginAllowThreads();
37558 result = (wxWindow *)wxWindow::GetCapture();
37559 wxPyEndAllowThreads(__tstate);
37560 if (PyErr_Occurred()) SWIG_fail;
37561 }
37562 {
37563 resultobj = wxPyMake_wxObject(result, 0);
37564 }
37565 return resultobj;
37566 fail:
37567 return NULL;
37568 }
37569
37570
37571 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37572 PyObject *resultobj = 0;
37573 wxWindow *arg1 = (wxWindow *) 0 ;
37574 bool result;
37575 void *argp1 = 0 ;
37576 int res1 = 0 ;
37577 PyObject *swig_obj[1] ;
37578
37579 if (!args) SWIG_fail;
37580 swig_obj[0] = args;
37581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37582 if (!SWIG_IsOK(res1)) {
37583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37584 }
37585 arg1 = reinterpret_cast< wxWindow * >(argp1);
37586 {
37587 PyThreadState* __tstate = wxPyBeginAllowThreads();
37588 result = (bool)((wxWindow const *)arg1)->HasCapture();
37589 wxPyEndAllowThreads(__tstate);
37590 if (PyErr_Occurred()) SWIG_fail;
37591 }
37592 {
37593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37594 }
37595 return resultobj;
37596 fail:
37597 return NULL;
37598 }
37599
37600
37601 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37602 PyObject *resultobj = 0;
37603 wxWindow *arg1 = (wxWindow *) 0 ;
37604 bool arg2 = (bool) true ;
37605 wxRect *arg3 = (wxRect *) NULL ;
37606 void *argp1 = 0 ;
37607 int res1 = 0 ;
37608 bool val2 ;
37609 int ecode2 = 0 ;
37610 void *argp3 = 0 ;
37611 int res3 = 0 ;
37612 PyObject * obj0 = 0 ;
37613 PyObject * obj1 = 0 ;
37614 PyObject * obj2 = 0 ;
37615 char * kwnames[] = {
37616 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37617 };
37618
37619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37621 if (!SWIG_IsOK(res1)) {
37622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37623 }
37624 arg1 = reinterpret_cast< wxWindow * >(argp1);
37625 if (obj1) {
37626 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37627 if (!SWIG_IsOK(ecode2)) {
37628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37629 }
37630 arg2 = static_cast< bool >(val2);
37631 }
37632 if (obj2) {
37633 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37634 if (!SWIG_IsOK(res3)) {
37635 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37636 }
37637 arg3 = reinterpret_cast< wxRect * >(argp3);
37638 }
37639 {
37640 PyThreadState* __tstate = wxPyBeginAllowThreads();
37641 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37642 wxPyEndAllowThreads(__tstate);
37643 if (PyErr_Occurred()) SWIG_fail;
37644 }
37645 resultobj = SWIG_Py_Void();
37646 return resultobj;
37647 fail:
37648 return NULL;
37649 }
37650
37651
37652 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37653 PyObject *resultobj = 0;
37654 wxWindow *arg1 = (wxWindow *) 0 ;
37655 wxRect *arg2 = 0 ;
37656 bool arg3 = (bool) true ;
37657 void *argp1 = 0 ;
37658 int res1 = 0 ;
37659 wxRect temp2 ;
37660 bool val3 ;
37661 int ecode3 = 0 ;
37662 PyObject * obj0 = 0 ;
37663 PyObject * obj1 = 0 ;
37664 PyObject * obj2 = 0 ;
37665 char * kwnames[] = {
37666 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37667 };
37668
37669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37671 if (!SWIG_IsOK(res1)) {
37672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37673 }
37674 arg1 = reinterpret_cast< wxWindow * >(argp1);
37675 {
37676 arg2 = &temp2;
37677 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37678 }
37679 if (obj2) {
37680 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37681 if (!SWIG_IsOK(ecode3)) {
37682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37683 }
37684 arg3 = static_cast< bool >(val3);
37685 }
37686 {
37687 PyThreadState* __tstate = wxPyBeginAllowThreads();
37688 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37689 wxPyEndAllowThreads(__tstate);
37690 if (PyErr_Occurred()) SWIG_fail;
37691 }
37692 resultobj = SWIG_Py_Void();
37693 return resultobj;
37694 fail:
37695 return NULL;
37696 }
37697
37698
37699 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37700 PyObject *resultobj = 0;
37701 wxWindow *arg1 = (wxWindow *) 0 ;
37702 void *argp1 = 0 ;
37703 int res1 = 0 ;
37704 PyObject *swig_obj[1] ;
37705
37706 if (!args) SWIG_fail;
37707 swig_obj[0] = args;
37708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37709 if (!SWIG_IsOK(res1)) {
37710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37711 }
37712 arg1 = reinterpret_cast< wxWindow * >(argp1);
37713 {
37714 PyThreadState* __tstate = wxPyBeginAllowThreads();
37715 (arg1)->Update();
37716 wxPyEndAllowThreads(__tstate);
37717 if (PyErr_Occurred()) SWIG_fail;
37718 }
37719 resultobj = SWIG_Py_Void();
37720 return resultobj;
37721 fail:
37722 return NULL;
37723 }
37724
37725
37726 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37727 PyObject *resultobj = 0;
37728 wxWindow *arg1 = (wxWindow *) 0 ;
37729 void *argp1 = 0 ;
37730 int res1 = 0 ;
37731 PyObject *swig_obj[1] ;
37732
37733 if (!args) SWIG_fail;
37734 swig_obj[0] = args;
37735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37736 if (!SWIG_IsOK(res1)) {
37737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37738 }
37739 arg1 = reinterpret_cast< wxWindow * >(argp1);
37740 {
37741 PyThreadState* __tstate = wxPyBeginAllowThreads();
37742 (arg1)->ClearBackground();
37743 wxPyEndAllowThreads(__tstate);
37744 if (PyErr_Occurred()) SWIG_fail;
37745 }
37746 resultobj = SWIG_Py_Void();
37747 return resultobj;
37748 fail:
37749 return NULL;
37750 }
37751
37752
37753 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37754 PyObject *resultobj = 0;
37755 wxWindow *arg1 = (wxWindow *) 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_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37765 }
37766 arg1 = reinterpret_cast< wxWindow * >(argp1);
37767 {
37768 PyThreadState* __tstate = wxPyBeginAllowThreads();
37769 (arg1)->Freeze();
37770 wxPyEndAllowThreads(__tstate);
37771 if (PyErr_Occurred()) SWIG_fail;
37772 }
37773 resultobj = SWIG_Py_Void();
37774 return resultobj;
37775 fail:
37776 return NULL;
37777 }
37778
37779
37780 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37781 PyObject *resultobj = 0;
37782 wxWindow *arg1 = (wxWindow *) 0 ;
37783 bool result;
37784 void *argp1 = 0 ;
37785 int res1 = 0 ;
37786 PyObject *swig_obj[1] ;
37787
37788 if (!args) SWIG_fail;
37789 swig_obj[0] = args;
37790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37791 if (!SWIG_IsOK(res1)) {
37792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37793 }
37794 arg1 = reinterpret_cast< wxWindow * >(argp1);
37795 {
37796 PyThreadState* __tstate = wxPyBeginAllowThreads();
37797 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37798 wxPyEndAllowThreads(__tstate);
37799 if (PyErr_Occurred()) SWIG_fail;
37800 }
37801 {
37802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37803 }
37804 return resultobj;
37805 fail:
37806 return NULL;
37807 }
37808
37809
37810 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37811 PyObject *resultobj = 0;
37812 wxWindow *arg1 = (wxWindow *) 0 ;
37813 void *argp1 = 0 ;
37814 int res1 = 0 ;
37815 PyObject *swig_obj[1] ;
37816
37817 if (!args) SWIG_fail;
37818 swig_obj[0] = args;
37819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37820 if (!SWIG_IsOK(res1)) {
37821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37822 }
37823 arg1 = reinterpret_cast< wxWindow * >(argp1);
37824 {
37825 PyThreadState* __tstate = wxPyBeginAllowThreads();
37826 (arg1)->Thaw();
37827 wxPyEndAllowThreads(__tstate);
37828 if (PyErr_Occurred()) SWIG_fail;
37829 }
37830 resultobj = SWIG_Py_Void();
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37838 PyObject *resultobj = 0;
37839 wxWindow *arg1 = (wxWindow *) 0 ;
37840 wxDC *arg2 = 0 ;
37841 void *argp1 = 0 ;
37842 int res1 = 0 ;
37843 void *argp2 = 0 ;
37844 int res2 = 0 ;
37845 PyObject * obj0 = 0 ;
37846 PyObject * obj1 = 0 ;
37847 char * kwnames[] = {
37848 (char *) "self",(char *) "dc", NULL
37849 };
37850
37851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37853 if (!SWIG_IsOK(res1)) {
37854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37855 }
37856 arg1 = reinterpret_cast< wxWindow * >(argp1);
37857 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37858 if (!SWIG_IsOK(res2)) {
37859 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37860 }
37861 if (!argp2) {
37862 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37863 }
37864 arg2 = reinterpret_cast< wxDC * >(argp2);
37865 {
37866 PyThreadState* __tstate = wxPyBeginAllowThreads();
37867 (arg1)->PrepareDC(*arg2);
37868 wxPyEndAllowThreads(__tstate);
37869 if (PyErr_Occurred()) SWIG_fail;
37870 }
37871 resultobj = SWIG_Py_Void();
37872 return resultobj;
37873 fail:
37874 return NULL;
37875 }
37876
37877
37878 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37879 PyObject *resultobj = 0;
37880 wxWindow *arg1 = (wxWindow *) 0 ;
37881 bool result;
37882 void *argp1 = 0 ;
37883 int res1 = 0 ;
37884 PyObject *swig_obj[1] ;
37885
37886 if (!args) SWIG_fail;
37887 swig_obj[0] = args;
37888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37889 if (!SWIG_IsOK(res1)) {
37890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37891 }
37892 arg1 = reinterpret_cast< wxWindow * >(argp1);
37893 {
37894 PyThreadState* __tstate = wxPyBeginAllowThreads();
37895 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 {
37900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37901 }
37902 return resultobj;
37903 fail:
37904 return NULL;
37905 }
37906
37907
37908 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37909 PyObject *resultobj = 0;
37910 wxWindow *arg1 = (wxWindow *) 0 ;
37911 wxRegion *result = 0 ;
37912 void *argp1 = 0 ;
37913 int res1 = 0 ;
37914 PyObject *swig_obj[1] ;
37915
37916 if (!args) SWIG_fail;
37917 swig_obj[0] = args;
37918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37919 if (!SWIG_IsOK(res1)) {
37920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37921 }
37922 arg1 = reinterpret_cast< wxWindow * >(argp1);
37923 {
37924 PyThreadState* __tstate = wxPyBeginAllowThreads();
37925 {
37926 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37927 result = (wxRegion *) &_result_ref;
37928 }
37929 wxPyEndAllowThreads(__tstate);
37930 if (PyErr_Occurred()) SWIG_fail;
37931 }
37932 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37940 PyObject *resultobj = 0;
37941 wxWindow *arg1 = (wxWindow *) 0 ;
37942 wxRect result;
37943 void *argp1 = 0 ;
37944 int res1 = 0 ;
37945 PyObject *swig_obj[1] ;
37946
37947 if (!args) SWIG_fail;
37948 swig_obj[0] = args;
37949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37950 if (!SWIG_IsOK(res1)) {
37951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37952 }
37953 arg1 = reinterpret_cast< wxWindow * >(argp1);
37954 {
37955 PyThreadState* __tstate = wxPyBeginAllowThreads();
37956 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37957 wxPyEndAllowThreads(__tstate);
37958 if (PyErr_Occurred()) SWIG_fail;
37959 }
37960 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37961 return resultobj;
37962 fail:
37963 return NULL;
37964 }
37965
37966
37967 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37968 PyObject *resultobj = 0;
37969 wxWindow *arg1 = (wxWindow *) 0 ;
37970 int arg2 ;
37971 int arg3 ;
37972 int arg4 = (int) 1 ;
37973 int arg5 = (int) 1 ;
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 int val5 ;
37984 int ecode5 = 0 ;
37985 PyObject * obj0 = 0 ;
37986 PyObject * obj1 = 0 ;
37987 PyObject * obj2 = 0 ;
37988 PyObject * obj3 = 0 ;
37989 PyObject * obj4 = 0 ;
37990 char * kwnames[] = {
37991 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37992 };
37993
37994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37996 if (!SWIG_IsOK(res1)) {
37997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37998 }
37999 arg1 = reinterpret_cast< wxWindow * >(argp1);
38000 ecode2 = SWIG_AsVal_int(obj1, &val2);
38001 if (!SWIG_IsOK(ecode2)) {
38002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38003 }
38004 arg2 = static_cast< int >(val2);
38005 ecode3 = SWIG_AsVal_int(obj2, &val3);
38006 if (!SWIG_IsOK(ecode3)) {
38007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38008 }
38009 arg3 = static_cast< int >(val3);
38010 if (obj3) {
38011 ecode4 = SWIG_AsVal_int(obj3, &val4);
38012 if (!SWIG_IsOK(ecode4)) {
38013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38014 }
38015 arg4 = static_cast< int >(val4);
38016 }
38017 if (obj4) {
38018 ecode5 = SWIG_AsVal_int(obj4, &val5);
38019 if (!SWIG_IsOK(ecode5)) {
38020 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38021 }
38022 arg5 = static_cast< int >(val5);
38023 }
38024 {
38025 PyThreadState* __tstate = wxPyBeginAllowThreads();
38026 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 {
38031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38032 }
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38040 PyObject *resultobj = 0;
38041 wxWindow *arg1 = (wxWindow *) 0 ;
38042 wxPoint *arg2 = 0 ;
38043 bool result;
38044 void *argp1 = 0 ;
38045 int res1 = 0 ;
38046 wxPoint temp2 ;
38047 PyObject * obj0 = 0 ;
38048 PyObject * obj1 = 0 ;
38049 char * kwnames[] = {
38050 (char *) "self",(char *) "pt", NULL
38051 };
38052
38053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38055 if (!SWIG_IsOK(res1)) {
38056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38057 }
38058 arg1 = reinterpret_cast< wxWindow * >(argp1);
38059 {
38060 arg2 = &temp2;
38061 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38062 }
38063 {
38064 PyThreadState* __tstate = wxPyBeginAllowThreads();
38065 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38066 wxPyEndAllowThreads(__tstate);
38067 if (PyErr_Occurred()) SWIG_fail;
38068 }
38069 {
38070 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38071 }
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38079 PyObject *resultobj = 0;
38080 wxWindow *arg1 = (wxWindow *) 0 ;
38081 wxRect *arg2 = 0 ;
38082 bool result;
38083 void *argp1 = 0 ;
38084 int res1 = 0 ;
38085 wxRect temp2 ;
38086 PyObject * obj0 = 0 ;
38087 PyObject * obj1 = 0 ;
38088 char * kwnames[] = {
38089 (char *) "self",(char *) "rect", NULL
38090 };
38091
38092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38094 if (!SWIG_IsOK(res1)) {
38095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38096 }
38097 arg1 = reinterpret_cast< wxWindow * >(argp1);
38098 {
38099 arg2 = &temp2;
38100 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38101 }
38102 {
38103 PyThreadState* __tstate = wxPyBeginAllowThreads();
38104 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38105 wxPyEndAllowThreads(__tstate);
38106 if (PyErr_Occurred()) SWIG_fail;
38107 }
38108 {
38109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38110 }
38111 return resultobj;
38112 fail:
38113 return NULL;
38114 }
38115
38116
38117 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38118 PyObject *resultobj = 0;
38119 wxWindow *arg1 = (wxWindow *) 0 ;
38120 SwigValueWrapper<wxVisualAttributes > result;
38121 void *argp1 = 0 ;
38122 int res1 = 0 ;
38123 PyObject *swig_obj[1] ;
38124
38125 if (!args) SWIG_fail;
38126 swig_obj[0] = args;
38127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38128 if (!SWIG_IsOK(res1)) {
38129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38130 }
38131 arg1 = reinterpret_cast< wxWindow * >(argp1);
38132 {
38133 PyThreadState* __tstate = wxPyBeginAllowThreads();
38134 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38135 wxPyEndAllowThreads(__tstate);
38136 if (PyErr_Occurred()) SWIG_fail;
38137 }
38138 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38139 return resultobj;
38140 fail:
38141 return NULL;
38142 }
38143
38144
38145 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38146 PyObject *resultobj = 0;
38147 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38148 SwigValueWrapper<wxVisualAttributes > result;
38149 int val1 ;
38150 int ecode1 = 0 ;
38151 PyObject * obj0 = 0 ;
38152 char * kwnames[] = {
38153 (char *) "variant", NULL
38154 };
38155
38156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38157 if (obj0) {
38158 ecode1 = SWIG_AsVal_int(obj0, &val1);
38159 if (!SWIG_IsOK(ecode1)) {
38160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38161 }
38162 arg1 = static_cast< wxWindowVariant >(val1);
38163 }
38164 {
38165 if (!wxPyCheckForApp()) SWIG_fail;
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 result = wxWindow::GetClassDefaultAttributes(arg1);
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38172 return resultobj;
38173 fail:
38174 return NULL;
38175 }
38176
38177
38178 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38179 PyObject *resultobj = 0;
38180 wxWindow *arg1 = (wxWindow *) 0 ;
38181 wxColour *arg2 = 0 ;
38182 bool result;
38183 void *argp1 = 0 ;
38184 int res1 = 0 ;
38185 wxColour temp2 ;
38186 PyObject * obj0 = 0 ;
38187 PyObject * obj1 = 0 ;
38188 char * kwnames[] = {
38189 (char *) "self",(char *) "colour", NULL
38190 };
38191
38192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38194 if (!SWIG_IsOK(res1)) {
38195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38196 }
38197 arg1 = reinterpret_cast< wxWindow * >(argp1);
38198 {
38199 arg2 = &temp2;
38200 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38201 }
38202 {
38203 PyThreadState* __tstate = wxPyBeginAllowThreads();
38204 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38205 wxPyEndAllowThreads(__tstate);
38206 if (PyErr_Occurred()) SWIG_fail;
38207 }
38208 {
38209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38210 }
38211 return resultobj;
38212 fail:
38213 return NULL;
38214 }
38215
38216
38217 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38218 PyObject *resultobj = 0;
38219 wxWindow *arg1 = (wxWindow *) 0 ;
38220 wxColour *arg2 = 0 ;
38221 void *argp1 = 0 ;
38222 int res1 = 0 ;
38223 wxColour temp2 ;
38224 PyObject * obj0 = 0 ;
38225 PyObject * obj1 = 0 ;
38226 char * kwnames[] = {
38227 (char *) "self",(char *) "colour", NULL
38228 };
38229
38230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",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_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38234 }
38235 arg1 = reinterpret_cast< wxWindow * >(argp1);
38236 {
38237 arg2 = &temp2;
38238 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38239 }
38240 {
38241 PyThreadState* __tstate = wxPyBeginAllowThreads();
38242 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38243 wxPyEndAllowThreads(__tstate);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 }
38246 resultobj = SWIG_Py_Void();
38247 return resultobj;
38248 fail:
38249 return NULL;
38250 }
38251
38252
38253 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38254 PyObject *resultobj = 0;
38255 wxWindow *arg1 = (wxWindow *) 0 ;
38256 wxColour *arg2 = 0 ;
38257 bool result;
38258 void *argp1 = 0 ;
38259 int res1 = 0 ;
38260 wxColour temp2 ;
38261 PyObject * obj0 = 0 ;
38262 PyObject * obj1 = 0 ;
38263 char * kwnames[] = {
38264 (char *) "self",(char *) "colour", NULL
38265 };
38266
38267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",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_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38271 }
38272 arg1 = reinterpret_cast< wxWindow * >(argp1);
38273 {
38274 arg2 = &temp2;
38275 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38276 }
38277 {
38278 PyThreadState* __tstate = wxPyBeginAllowThreads();
38279 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38280 wxPyEndAllowThreads(__tstate);
38281 if (PyErr_Occurred()) SWIG_fail;
38282 }
38283 {
38284 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38285 }
38286 return resultobj;
38287 fail:
38288 return NULL;
38289 }
38290
38291
38292 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38293 PyObject *resultobj = 0;
38294 wxWindow *arg1 = (wxWindow *) 0 ;
38295 wxColour *arg2 = 0 ;
38296 void *argp1 = 0 ;
38297 int res1 = 0 ;
38298 wxColour temp2 ;
38299 PyObject * obj0 = 0 ;
38300 PyObject * obj1 = 0 ;
38301 char * kwnames[] = {
38302 (char *) "self",(char *) "colour", NULL
38303 };
38304
38305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38307 if (!SWIG_IsOK(res1)) {
38308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38309 }
38310 arg1 = reinterpret_cast< wxWindow * >(argp1);
38311 {
38312 arg2 = &temp2;
38313 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38314 }
38315 {
38316 PyThreadState* __tstate = wxPyBeginAllowThreads();
38317 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38318 wxPyEndAllowThreads(__tstate);
38319 if (PyErr_Occurred()) SWIG_fail;
38320 }
38321 resultobj = SWIG_Py_Void();
38322 return resultobj;
38323 fail:
38324 return NULL;
38325 }
38326
38327
38328 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38329 PyObject *resultobj = 0;
38330 wxWindow *arg1 = (wxWindow *) 0 ;
38331 wxColour result;
38332 void *argp1 = 0 ;
38333 int res1 = 0 ;
38334 PyObject *swig_obj[1] ;
38335
38336 if (!args) SWIG_fail;
38337 swig_obj[0] = args;
38338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38339 if (!SWIG_IsOK(res1)) {
38340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38341 }
38342 arg1 = reinterpret_cast< wxWindow * >(argp1);
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38346 wxPyEndAllowThreads(__tstate);
38347 if (PyErr_Occurred()) SWIG_fail;
38348 }
38349 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38350 return resultobj;
38351 fail:
38352 return NULL;
38353 }
38354
38355
38356 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38357 PyObject *resultobj = 0;
38358 wxWindow *arg1 = (wxWindow *) 0 ;
38359 wxColour result;
38360 void *argp1 = 0 ;
38361 int res1 = 0 ;
38362 PyObject *swig_obj[1] ;
38363
38364 if (!args) SWIG_fail;
38365 swig_obj[0] = args;
38366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38367 if (!SWIG_IsOK(res1)) {
38368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38369 }
38370 arg1 = reinterpret_cast< wxWindow * >(argp1);
38371 {
38372 PyThreadState* __tstate = wxPyBeginAllowThreads();
38373 result = ((wxWindow const *)arg1)->GetForegroundColour();
38374 wxPyEndAllowThreads(__tstate);
38375 if (PyErr_Occurred()) SWIG_fail;
38376 }
38377 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38378 return resultobj;
38379 fail:
38380 return NULL;
38381 }
38382
38383
38384 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38385 PyObject *resultobj = 0;
38386 wxWindow *arg1 = (wxWindow *) 0 ;
38387 bool result;
38388 void *argp1 = 0 ;
38389 int res1 = 0 ;
38390 PyObject *swig_obj[1] ;
38391
38392 if (!args) SWIG_fail;
38393 swig_obj[0] = args;
38394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38395 if (!SWIG_IsOK(res1)) {
38396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38397 }
38398 arg1 = reinterpret_cast< wxWindow * >(argp1);
38399 {
38400 PyThreadState* __tstate = wxPyBeginAllowThreads();
38401 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38402 wxPyEndAllowThreads(__tstate);
38403 if (PyErr_Occurred()) SWIG_fail;
38404 }
38405 {
38406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38407 }
38408 return resultobj;
38409 fail:
38410 return NULL;
38411 }
38412
38413
38414 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38415 PyObject *resultobj = 0;
38416 wxWindow *arg1 = (wxWindow *) 0 ;
38417 bool result;
38418 void *argp1 = 0 ;
38419 int res1 = 0 ;
38420 PyObject *swig_obj[1] ;
38421
38422 if (!args) SWIG_fail;
38423 swig_obj[0] = args;
38424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38425 if (!SWIG_IsOK(res1)) {
38426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38427 }
38428 arg1 = reinterpret_cast< wxWindow * >(argp1);
38429 {
38430 PyThreadState* __tstate = wxPyBeginAllowThreads();
38431 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38432 wxPyEndAllowThreads(__tstate);
38433 if (PyErr_Occurred()) SWIG_fail;
38434 }
38435 {
38436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38437 }
38438 return resultobj;
38439 fail:
38440 return NULL;
38441 }
38442
38443
38444 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38445 PyObject *resultobj = 0;
38446 wxWindow *arg1 = (wxWindow *) 0 ;
38447 wxBackgroundStyle arg2 ;
38448 bool result;
38449 void *argp1 = 0 ;
38450 int res1 = 0 ;
38451 int val2 ;
38452 int ecode2 = 0 ;
38453 PyObject * obj0 = 0 ;
38454 PyObject * obj1 = 0 ;
38455 char * kwnames[] = {
38456 (char *) "self",(char *) "style", NULL
38457 };
38458
38459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38461 if (!SWIG_IsOK(res1)) {
38462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38463 }
38464 arg1 = reinterpret_cast< wxWindow * >(argp1);
38465 ecode2 = SWIG_AsVal_int(obj1, &val2);
38466 if (!SWIG_IsOK(ecode2)) {
38467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38468 }
38469 arg2 = static_cast< wxBackgroundStyle >(val2);
38470 {
38471 PyThreadState* __tstate = wxPyBeginAllowThreads();
38472 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38473 wxPyEndAllowThreads(__tstate);
38474 if (PyErr_Occurred()) SWIG_fail;
38475 }
38476 {
38477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38478 }
38479 return resultobj;
38480 fail:
38481 return NULL;
38482 }
38483
38484
38485 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38486 PyObject *resultobj = 0;
38487 wxWindow *arg1 = (wxWindow *) 0 ;
38488 wxBackgroundStyle result;
38489 void *argp1 = 0 ;
38490 int res1 = 0 ;
38491 PyObject *swig_obj[1] ;
38492
38493 if (!args) SWIG_fail;
38494 swig_obj[0] = args;
38495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38496 if (!SWIG_IsOK(res1)) {
38497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38498 }
38499 arg1 = reinterpret_cast< wxWindow * >(argp1);
38500 {
38501 PyThreadState* __tstate = wxPyBeginAllowThreads();
38502 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38503 wxPyEndAllowThreads(__tstate);
38504 if (PyErr_Occurred()) SWIG_fail;
38505 }
38506 resultobj = SWIG_From_int(static_cast< int >(result));
38507 return resultobj;
38508 fail:
38509 return NULL;
38510 }
38511
38512
38513 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38514 PyObject *resultobj = 0;
38515 wxWindow *arg1 = (wxWindow *) 0 ;
38516 bool result;
38517 void *argp1 = 0 ;
38518 int res1 = 0 ;
38519 PyObject *swig_obj[1] ;
38520
38521 if (!args) SWIG_fail;
38522 swig_obj[0] = args;
38523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38524 if (!SWIG_IsOK(res1)) {
38525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38526 }
38527 arg1 = reinterpret_cast< wxWindow * >(argp1);
38528 {
38529 PyThreadState* __tstate = wxPyBeginAllowThreads();
38530 result = (bool)(arg1)->HasTransparentBackground();
38531 wxPyEndAllowThreads(__tstate);
38532 if (PyErr_Occurred()) SWIG_fail;
38533 }
38534 {
38535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38536 }
38537 return resultobj;
38538 fail:
38539 return NULL;
38540 }
38541
38542
38543 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38544 PyObject *resultobj = 0;
38545 wxWindow *arg1 = (wxWindow *) 0 ;
38546 wxCursor *arg2 = 0 ;
38547 bool result;
38548 void *argp1 = 0 ;
38549 int res1 = 0 ;
38550 void *argp2 = 0 ;
38551 int res2 = 0 ;
38552 PyObject * obj0 = 0 ;
38553 PyObject * obj1 = 0 ;
38554 char * kwnames[] = {
38555 (char *) "self",(char *) "cursor", NULL
38556 };
38557
38558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38560 if (!SWIG_IsOK(res1)) {
38561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38562 }
38563 arg1 = reinterpret_cast< wxWindow * >(argp1);
38564 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38565 if (!SWIG_IsOK(res2)) {
38566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38567 }
38568 if (!argp2) {
38569 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38570 }
38571 arg2 = reinterpret_cast< wxCursor * >(argp2);
38572 {
38573 PyThreadState* __tstate = wxPyBeginAllowThreads();
38574 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38575 wxPyEndAllowThreads(__tstate);
38576 if (PyErr_Occurred()) SWIG_fail;
38577 }
38578 {
38579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38580 }
38581 return resultobj;
38582 fail:
38583 return NULL;
38584 }
38585
38586
38587 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38588 PyObject *resultobj = 0;
38589 wxWindow *arg1 = (wxWindow *) 0 ;
38590 wxCursor result;
38591 void *argp1 = 0 ;
38592 int res1 = 0 ;
38593 PyObject *swig_obj[1] ;
38594
38595 if (!args) SWIG_fail;
38596 swig_obj[0] = args;
38597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38598 if (!SWIG_IsOK(res1)) {
38599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38600 }
38601 arg1 = reinterpret_cast< wxWindow * >(argp1);
38602 {
38603 PyThreadState* __tstate = wxPyBeginAllowThreads();
38604 result = (arg1)->GetCursor();
38605 wxPyEndAllowThreads(__tstate);
38606 if (PyErr_Occurred()) SWIG_fail;
38607 }
38608 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38609 return resultobj;
38610 fail:
38611 return NULL;
38612 }
38613
38614
38615 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38616 PyObject *resultobj = 0;
38617 wxWindow *arg1 = (wxWindow *) 0 ;
38618 wxFont *arg2 = 0 ;
38619 bool result;
38620 void *argp1 = 0 ;
38621 int res1 = 0 ;
38622 void *argp2 = 0 ;
38623 int res2 = 0 ;
38624 PyObject * obj0 = 0 ;
38625 PyObject * obj1 = 0 ;
38626 char * kwnames[] = {
38627 (char *) "self",(char *) "font", NULL
38628 };
38629
38630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38632 if (!SWIG_IsOK(res1)) {
38633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38634 }
38635 arg1 = reinterpret_cast< wxWindow * >(argp1);
38636 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38637 if (!SWIG_IsOK(res2)) {
38638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38639 }
38640 if (!argp2) {
38641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38642 }
38643 arg2 = reinterpret_cast< wxFont * >(argp2);
38644 {
38645 PyThreadState* __tstate = wxPyBeginAllowThreads();
38646 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38647 wxPyEndAllowThreads(__tstate);
38648 if (PyErr_Occurred()) SWIG_fail;
38649 }
38650 {
38651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38652 }
38653 return resultobj;
38654 fail:
38655 return NULL;
38656 }
38657
38658
38659 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38660 PyObject *resultobj = 0;
38661 wxWindow *arg1 = (wxWindow *) 0 ;
38662 wxFont *arg2 = 0 ;
38663 void *argp1 = 0 ;
38664 int res1 = 0 ;
38665 void *argp2 = 0 ;
38666 int res2 = 0 ;
38667 PyObject * obj0 = 0 ;
38668 PyObject * obj1 = 0 ;
38669 char * kwnames[] = {
38670 (char *) "self",(char *) "font", NULL
38671 };
38672
38673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38675 if (!SWIG_IsOK(res1)) {
38676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38677 }
38678 arg1 = reinterpret_cast< wxWindow * >(argp1);
38679 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38680 if (!SWIG_IsOK(res2)) {
38681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38682 }
38683 if (!argp2) {
38684 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38685 }
38686 arg2 = reinterpret_cast< wxFont * >(argp2);
38687 {
38688 PyThreadState* __tstate = wxPyBeginAllowThreads();
38689 (arg1)->SetOwnFont((wxFont const &)*arg2);
38690 wxPyEndAllowThreads(__tstate);
38691 if (PyErr_Occurred()) SWIG_fail;
38692 }
38693 resultobj = SWIG_Py_Void();
38694 return resultobj;
38695 fail:
38696 return NULL;
38697 }
38698
38699
38700 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38701 PyObject *resultobj = 0;
38702 wxWindow *arg1 = (wxWindow *) 0 ;
38703 wxFont result;
38704 void *argp1 = 0 ;
38705 int res1 = 0 ;
38706 PyObject *swig_obj[1] ;
38707
38708 if (!args) SWIG_fail;
38709 swig_obj[0] = args;
38710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38711 if (!SWIG_IsOK(res1)) {
38712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38713 }
38714 arg1 = reinterpret_cast< wxWindow * >(argp1);
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 result = (arg1)->GetFont();
38718 wxPyEndAllowThreads(__tstate);
38719 if (PyErr_Occurred()) SWIG_fail;
38720 }
38721 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38722 return resultobj;
38723 fail:
38724 return NULL;
38725 }
38726
38727
38728 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38729 PyObject *resultobj = 0;
38730 wxWindow *arg1 = (wxWindow *) 0 ;
38731 wxCaret *arg2 = (wxCaret *) 0 ;
38732 void *argp1 = 0 ;
38733 int res1 = 0 ;
38734 int res2 = 0 ;
38735 PyObject * obj0 = 0 ;
38736 PyObject * obj1 = 0 ;
38737 char * kwnames[] = {
38738 (char *) "self",(char *) "caret", NULL
38739 };
38740
38741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38743 if (!SWIG_IsOK(res1)) {
38744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38745 }
38746 arg1 = reinterpret_cast< wxWindow * >(argp1);
38747 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38748 if (!SWIG_IsOK(res2)) {
38749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38750 }
38751 {
38752 PyThreadState* __tstate = wxPyBeginAllowThreads();
38753 (arg1)->SetCaret(arg2);
38754 wxPyEndAllowThreads(__tstate);
38755 if (PyErr_Occurred()) SWIG_fail;
38756 }
38757 resultobj = SWIG_Py_Void();
38758 return resultobj;
38759 fail:
38760 return NULL;
38761 }
38762
38763
38764 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38765 PyObject *resultobj = 0;
38766 wxWindow *arg1 = (wxWindow *) 0 ;
38767 wxCaret *result = 0 ;
38768 void *argp1 = 0 ;
38769 int res1 = 0 ;
38770 PyObject *swig_obj[1] ;
38771
38772 if (!args) SWIG_fail;
38773 swig_obj[0] = args;
38774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38775 if (!SWIG_IsOK(res1)) {
38776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38777 }
38778 arg1 = reinterpret_cast< wxWindow * >(argp1);
38779 {
38780 PyThreadState* __tstate = wxPyBeginAllowThreads();
38781 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38782 wxPyEndAllowThreads(__tstate);
38783 if (PyErr_Occurred()) SWIG_fail;
38784 }
38785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38786 return resultobj;
38787 fail:
38788 return NULL;
38789 }
38790
38791
38792 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38793 PyObject *resultobj = 0;
38794 wxWindow *arg1 = (wxWindow *) 0 ;
38795 int result;
38796 void *argp1 = 0 ;
38797 int res1 = 0 ;
38798 PyObject *swig_obj[1] ;
38799
38800 if (!args) SWIG_fail;
38801 swig_obj[0] = args;
38802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38803 if (!SWIG_IsOK(res1)) {
38804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38805 }
38806 arg1 = reinterpret_cast< wxWindow * >(argp1);
38807 {
38808 PyThreadState* __tstate = wxPyBeginAllowThreads();
38809 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38810 wxPyEndAllowThreads(__tstate);
38811 if (PyErr_Occurred()) SWIG_fail;
38812 }
38813 resultobj = SWIG_From_int(static_cast< int >(result));
38814 return resultobj;
38815 fail:
38816 return NULL;
38817 }
38818
38819
38820 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38821 PyObject *resultobj = 0;
38822 wxWindow *arg1 = (wxWindow *) 0 ;
38823 int result;
38824 void *argp1 = 0 ;
38825 int res1 = 0 ;
38826 PyObject *swig_obj[1] ;
38827
38828 if (!args) SWIG_fail;
38829 swig_obj[0] = args;
38830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38831 if (!SWIG_IsOK(res1)) {
38832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38833 }
38834 arg1 = reinterpret_cast< wxWindow * >(argp1);
38835 {
38836 PyThreadState* __tstate = wxPyBeginAllowThreads();
38837 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38838 wxPyEndAllowThreads(__tstate);
38839 if (PyErr_Occurred()) SWIG_fail;
38840 }
38841 resultobj = SWIG_From_int(static_cast< int >(result));
38842 return resultobj;
38843 fail:
38844 return NULL;
38845 }
38846
38847
38848 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38849 PyObject *resultobj = 0;
38850 wxWindow *arg1 = (wxWindow *) 0 ;
38851 wxString *arg2 = 0 ;
38852 int *arg3 = (int *) 0 ;
38853 int *arg4 = (int *) 0 ;
38854 void *argp1 = 0 ;
38855 int res1 = 0 ;
38856 bool temp2 = false ;
38857 int temp3 ;
38858 int res3 = SWIG_TMPOBJ ;
38859 int temp4 ;
38860 int res4 = SWIG_TMPOBJ ;
38861 PyObject * obj0 = 0 ;
38862 PyObject * obj1 = 0 ;
38863 char * kwnames[] = {
38864 (char *) "self",(char *) "string", NULL
38865 };
38866
38867 arg3 = &temp3;
38868 arg4 = &temp4;
38869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38871 if (!SWIG_IsOK(res1)) {
38872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38873 }
38874 arg1 = reinterpret_cast< wxWindow * >(argp1);
38875 {
38876 arg2 = wxString_in_helper(obj1);
38877 if (arg2 == NULL) SWIG_fail;
38878 temp2 = true;
38879 }
38880 {
38881 PyThreadState* __tstate = wxPyBeginAllowThreads();
38882 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38883 wxPyEndAllowThreads(__tstate);
38884 if (PyErr_Occurred()) SWIG_fail;
38885 }
38886 resultobj = SWIG_Py_Void();
38887 if (SWIG_IsTmpObj(res3)) {
38888 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38889 } else {
38890 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38891 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38892 }
38893 if (SWIG_IsTmpObj(res4)) {
38894 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38895 } else {
38896 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38897 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38898 }
38899 {
38900 if (temp2)
38901 delete arg2;
38902 }
38903 return resultobj;
38904 fail:
38905 {
38906 if (temp2)
38907 delete arg2;
38908 }
38909 return NULL;
38910 }
38911
38912
38913 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38914 PyObject *resultobj = 0;
38915 wxWindow *arg1 = (wxWindow *) 0 ;
38916 wxString *arg2 = 0 ;
38917 int *arg3 = (int *) 0 ;
38918 int *arg4 = (int *) 0 ;
38919 int *arg5 = (int *) 0 ;
38920 int *arg6 = (int *) 0 ;
38921 wxFont *arg7 = (wxFont *) NULL ;
38922 void *argp1 = 0 ;
38923 int res1 = 0 ;
38924 bool temp2 = false ;
38925 int temp3 ;
38926 int res3 = SWIG_TMPOBJ ;
38927 int temp4 ;
38928 int res4 = SWIG_TMPOBJ ;
38929 int temp5 ;
38930 int res5 = SWIG_TMPOBJ ;
38931 int temp6 ;
38932 int res6 = SWIG_TMPOBJ ;
38933 void *argp7 = 0 ;
38934 int res7 = 0 ;
38935 PyObject * obj0 = 0 ;
38936 PyObject * obj1 = 0 ;
38937 PyObject * obj2 = 0 ;
38938 char * kwnames[] = {
38939 (char *) "self",(char *) "string",(char *) "font", NULL
38940 };
38941
38942 arg3 = &temp3;
38943 arg4 = &temp4;
38944 arg5 = &temp5;
38945 arg6 = &temp6;
38946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38948 if (!SWIG_IsOK(res1)) {
38949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38950 }
38951 arg1 = reinterpret_cast< wxWindow * >(argp1);
38952 {
38953 arg2 = wxString_in_helper(obj1);
38954 if (arg2 == NULL) SWIG_fail;
38955 temp2 = true;
38956 }
38957 if (obj2) {
38958 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38959 if (!SWIG_IsOK(res7)) {
38960 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38961 }
38962 arg7 = reinterpret_cast< wxFont * >(argp7);
38963 }
38964 {
38965 PyThreadState* __tstate = wxPyBeginAllowThreads();
38966 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38967 wxPyEndAllowThreads(__tstate);
38968 if (PyErr_Occurred()) SWIG_fail;
38969 }
38970 resultobj = SWIG_Py_Void();
38971 if (SWIG_IsTmpObj(res3)) {
38972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38973 } else {
38974 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38975 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38976 }
38977 if (SWIG_IsTmpObj(res4)) {
38978 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38979 } else {
38980 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38981 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38982 }
38983 if (SWIG_IsTmpObj(res5)) {
38984 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38985 } else {
38986 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38987 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38988 }
38989 if (SWIG_IsTmpObj(res6)) {
38990 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38991 } else {
38992 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38993 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38994 }
38995 {
38996 if (temp2)
38997 delete arg2;
38998 }
38999 return resultobj;
39000 fail:
39001 {
39002 if (temp2)
39003 delete arg2;
39004 }
39005 return NULL;
39006 }
39007
39008
39009 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39010 PyObject *resultobj = 0;
39011 wxWindow *arg1 = (wxWindow *) 0 ;
39012 int *arg2 = (int *) 0 ;
39013 int *arg3 = (int *) 0 ;
39014 void *argp1 = 0 ;
39015 int res1 = 0 ;
39016 int temp2 ;
39017 int res2 = 0 ;
39018 int temp3 ;
39019 int res3 = 0 ;
39020 PyObject * obj0 = 0 ;
39021 PyObject * obj1 = 0 ;
39022 PyObject * obj2 = 0 ;
39023 char * kwnames[] = {
39024 (char *) "self",(char *) "x",(char *) "y", NULL
39025 };
39026
39027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39029 if (!SWIG_IsOK(res1)) {
39030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39031 }
39032 arg1 = reinterpret_cast< wxWindow * >(argp1);
39033 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39034 int val;
39035 int ecode = SWIG_AsVal_int(obj1, &val);
39036 if (!SWIG_IsOK(ecode)) {
39037 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39038 }
39039 temp2 = static_cast< int >(val);
39040 arg2 = &temp2;
39041 res2 = SWIG_AddTmpMask(ecode);
39042 }
39043 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39044 int val;
39045 int ecode = SWIG_AsVal_int(obj2, &val);
39046 if (!SWIG_IsOK(ecode)) {
39047 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39048 }
39049 temp3 = static_cast< int >(val);
39050 arg3 = &temp3;
39051 res3 = SWIG_AddTmpMask(ecode);
39052 }
39053 {
39054 PyThreadState* __tstate = wxPyBeginAllowThreads();
39055 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39056 wxPyEndAllowThreads(__tstate);
39057 if (PyErr_Occurred()) SWIG_fail;
39058 }
39059 resultobj = SWIG_Py_Void();
39060 if (SWIG_IsTmpObj(res2)) {
39061 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39062 } else {
39063 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39064 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39065 }
39066 if (SWIG_IsTmpObj(res3)) {
39067 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39068 } else {
39069 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39070 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39071 }
39072 return resultobj;
39073 fail:
39074 return NULL;
39075 }
39076
39077
39078 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39079 PyObject *resultobj = 0;
39080 wxWindow *arg1 = (wxWindow *) 0 ;
39081 int *arg2 = (int *) 0 ;
39082 int *arg3 = (int *) 0 ;
39083 void *argp1 = 0 ;
39084 int res1 = 0 ;
39085 int temp2 ;
39086 int res2 = 0 ;
39087 int temp3 ;
39088 int res3 = 0 ;
39089 PyObject * obj0 = 0 ;
39090 PyObject * obj1 = 0 ;
39091 PyObject * obj2 = 0 ;
39092 char * kwnames[] = {
39093 (char *) "self",(char *) "x",(char *) "y", NULL
39094 };
39095
39096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39098 if (!SWIG_IsOK(res1)) {
39099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39100 }
39101 arg1 = reinterpret_cast< wxWindow * >(argp1);
39102 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39103 int val;
39104 int ecode = SWIG_AsVal_int(obj1, &val);
39105 if (!SWIG_IsOK(ecode)) {
39106 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39107 }
39108 temp2 = static_cast< int >(val);
39109 arg2 = &temp2;
39110 res2 = SWIG_AddTmpMask(ecode);
39111 }
39112 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39113 int val;
39114 int ecode = SWIG_AsVal_int(obj2, &val);
39115 if (!SWIG_IsOK(ecode)) {
39116 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39117 }
39118 temp3 = static_cast< int >(val);
39119 arg3 = &temp3;
39120 res3 = SWIG_AddTmpMask(ecode);
39121 }
39122 {
39123 PyThreadState* __tstate = wxPyBeginAllowThreads();
39124 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39125 wxPyEndAllowThreads(__tstate);
39126 if (PyErr_Occurred()) SWIG_fail;
39127 }
39128 resultobj = SWIG_Py_Void();
39129 if (SWIG_IsTmpObj(res2)) {
39130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39131 } else {
39132 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39134 }
39135 if (SWIG_IsTmpObj(res3)) {
39136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39137 } else {
39138 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39139 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39140 }
39141 return resultobj;
39142 fail:
39143 return NULL;
39144 }
39145
39146
39147 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39148 PyObject *resultobj = 0;
39149 wxWindow *arg1 = (wxWindow *) 0 ;
39150 wxPoint *arg2 = 0 ;
39151 wxPoint result;
39152 void *argp1 = 0 ;
39153 int res1 = 0 ;
39154 wxPoint temp2 ;
39155 PyObject * obj0 = 0 ;
39156 PyObject * obj1 = 0 ;
39157 char * kwnames[] = {
39158 (char *) "self",(char *) "pt", NULL
39159 };
39160
39161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39163 if (!SWIG_IsOK(res1)) {
39164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39165 }
39166 arg1 = reinterpret_cast< wxWindow * >(argp1);
39167 {
39168 arg2 = &temp2;
39169 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39170 }
39171 {
39172 PyThreadState* __tstate = wxPyBeginAllowThreads();
39173 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39174 wxPyEndAllowThreads(__tstate);
39175 if (PyErr_Occurred()) SWIG_fail;
39176 }
39177 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39178 return resultobj;
39179 fail:
39180 return NULL;
39181 }
39182
39183
39184 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39185 PyObject *resultobj = 0;
39186 wxWindow *arg1 = (wxWindow *) 0 ;
39187 wxPoint *arg2 = 0 ;
39188 wxPoint result;
39189 void *argp1 = 0 ;
39190 int res1 = 0 ;
39191 wxPoint temp2 ;
39192 PyObject * obj0 = 0 ;
39193 PyObject * obj1 = 0 ;
39194 char * kwnames[] = {
39195 (char *) "self",(char *) "pt", NULL
39196 };
39197
39198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39200 if (!SWIG_IsOK(res1)) {
39201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39202 }
39203 arg1 = reinterpret_cast< wxWindow * >(argp1);
39204 {
39205 arg2 = &temp2;
39206 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39207 }
39208 {
39209 PyThreadState* __tstate = wxPyBeginAllowThreads();
39210 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39211 wxPyEndAllowThreads(__tstate);
39212 if (PyErr_Occurred()) SWIG_fail;
39213 }
39214 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39215 return resultobj;
39216 fail:
39217 return NULL;
39218 }
39219
39220
39221 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39222 PyObject *resultobj = 0;
39223 wxWindow *arg1 = (wxWindow *) 0 ;
39224 int arg2 ;
39225 int arg3 ;
39226 wxHitTest result;
39227 void *argp1 = 0 ;
39228 int res1 = 0 ;
39229 int val2 ;
39230 int ecode2 = 0 ;
39231 int val3 ;
39232 int ecode3 = 0 ;
39233 PyObject * obj0 = 0 ;
39234 PyObject * obj1 = 0 ;
39235 PyObject * obj2 = 0 ;
39236 char * kwnames[] = {
39237 (char *) "self",(char *) "x",(char *) "y", NULL
39238 };
39239
39240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39242 if (!SWIG_IsOK(res1)) {
39243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39244 }
39245 arg1 = reinterpret_cast< wxWindow * >(argp1);
39246 ecode2 = SWIG_AsVal_int(obj1, &val2);
39247 if (!SWIG_IsOK(ecode2)) {
39248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39249 }
39250 arg2 = static_cast< int >(val2);
39251 ecode3 = SWIG_AsVal_int(obj2, &val3);
39252 if (!SWIG_IsOK(ecode3)) {
39253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39254 }
39255 arg3 = static_cast< int >(val3);
39256 {
39257 PyThreadState* __tstate = wxPyBeginAllowThreads();
39258 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39259 wxPyEndAllowThreads(__tstate);
39260 if (PyErr_Occurred()) SWIG_fail;
39261 }
39262 resultobj = SWIG_From_int(static_cast< int >(result));
39263 return resultobj;
39264 fail:
39265 return NULL;
39266 }
39267
39268
39269 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39270 PyObject *resultobj = 0;
39271 wxWindow *arg1 = (wxWindow *) 0 ;
39272 wxPoint *arg2 = 0 ;
39273 wxHitTest result;
39274 void *argp1 = 0 ;
39275 int res1 = 0 ;
39276 wxPoint temp2 ;
39277 PyObject * obj0 = 0 ;
39278 PyObject * obj1 = 0 ;
39279 char * kwnames[] = {
39280 (char *) "self",(char *) "pt", NULL
39281 };
39282
39283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39285 if (!SWIG_IsOK(res1)) {
39286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39287 }
39288 arg1 = reinterpret_cast< wxWindow * >(argp1);
39289 {
39290 arg2 = &temp2;
39291 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39292 }
39293 {
39294 PyThreadState* __tstate = wxPyBeginAllowThreads();
39295 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39296 wxPyEndAllowThreads(__tstate);
39297 if (PyErr_Occurred()) SWIG_fail;
39298 }
39299 resultobj = SWIG_From_int(static_cast< int >(result));
39300 return resultobj;
39301 fail:
39302 return NULL;
39303 }
39304
39305
39306 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39307 PyObject *resultobj = 0;
39308 wxWindow *arg1 = (wxWindow *) 0 ;
39309 long arg2 ;
39310 wxBorder result;
39311 void *argp1 = 0 ;
39312 int res1 = 0 ;
39313 long val2 ;
39314 int ecode2 = 0 ;
39315
39316 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39318 if (!SWIG_IsOK(res1)) {
39319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39320 }
39321 arg1 = reinterpret_cast< wxWindow * >(argp1);
39322 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39323 if (!SWIG_IsOK(ecode2)) {
39324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39325 }
39326 arg2 = static_cast< long >(val2);
39327 {
39328 PyThreadState* __tstate = wxPyBeginAllowThreads();
39329 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39330 wxPyEndAllowThreads(__tstate);
39331 if (PyErr_Occurred()) SWIG_fail;
39332 }
39333 resultobj = SWIG_From_int(static_cast< int >(result));
39334 return resultobj;
39335 fail:
39336 return NULL;
39337 }
39338
39339
39340 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39341 PyObject *resultobj = 0;
39342 wxWindow *arg1 = (wxWindow *) 0 ;
39343 wxBorder result;
39344 void *argp1 = 0 ;
39345 int res1 = 0 ;
39346
39347 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39348 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39349 if (!SWIG_IsOK(res1)) {
39350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39351 }
39352 arg1 = reinterpret_cast< wxWindow * >(argp1);
39353 {
39354 PyThreadState* __tstate = wxPyBeginAllowThreads();
39355 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39356 wxPyEndAllowThreads(__tstate);
39357 if (PyErr_Occurred()) SWIG_fail;
39358 }
39359 resultobj = SWIG_From_int(static_cast< int >(result));
39360 return resultobj;
39361 fail:
39362 return NULL;
39363 }
39364
39365
39366 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39367 int argc;
39368 PyObject *argv[3];
39369
39370 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39371 --argc;
39372 if (argc == 1) {
39373 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39374 }
39375 if (argc == 2) {
39376 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39377 }
39378
39379 fail:
39380 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39381 return NULL;
39382 }
39383
39384
39385 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39386 PyObject *resultobj = 0;
39387 wxWindow *arg1 = (wxWindow *) 0 ;
39388 long arg2 = (long) wxUPDATE_UI_NONE ;
39389 void *argp1 = 0 ;
39390 int res1 = 0 ;
39391 long val2 ;
39392 int ecode2 = 0 ;
39393 PyObject * obj0 = 0 ;
39394 PyObject * obj1 = 0 ;
39395 char * kwnames[] = {
39396 (char *) "self",(char *) "flags", NULL
39397 };
39398
39399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",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_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39403 }
39404 arg1 = reinterpret_cast< wxWindow * >(argp1);
39405 if (obj1) {
39406 ecode2 = SWIG_AsVal_long(obj1, &val2);
39407 if (!SWIG_IsOK(ecode2)) {
39408 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39409 }
39410 arg2 = static_cast< long >(val2);
39411 }
39412 {
39413 PyThreadState* __tstate = wxPyBeginAllowThreads();
39414 (arg1)->UpdateWindowUI(arg2);
39415 wxPyEndAllowThreads(__tstate);
39416 if (PyErr_Occurred()) SWIG_fail;
39417 }
39418 resultobj = SWIG_Py_Void();
39419 return resultobj;
39420 fail:
39421 return NULL;
39422 }
39423
39424
39425 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39426 PyObject *resultobj = 0;
39427 wxWindow *arg1 = (wxWindow *) 0 ;
39428 wxMenu *arg2 = (wxMenu *) 0 ;
39429 int arg3 = (int) -1 ;
39430 int arg4 = (int) -1 ;
39431 bool result;
39432 void *argp1 = 0 ;
39433 int res1 = 0 ;
39434 void *argp2 = 0 ;
39435 int res2 = 0 ;
39436 int val3 ;
39437 int ecode3 = 0 ;
39438 int val4 ;
39439 int ecode4 = 0 ;
39440 PyObject * obj0 = 0 ;
39441 PyObject * obj1 = 0 ;
39442 PyObject * obj2 = 0 ;
39443 PyObject * obj3 = 0 ;
39444 char * kwnames[] = {
39445 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39446 };
39447
39448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39450 if (!SWIG_IsOK(res1)) {
39451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39452 }
39453 arg1 = reinterpret_cast< wxWindow * >(argp1);
39454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39455 if (!SWIG_IsOK(res2)) {
39456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39457 }
39458 arg2 = reinterpret_cast< wxMenu * >(argp2);
39459 if (obj2) {
39460 ecode3 = SWIG_AsVal_int(obj2, &val3);
39461 if (!SWIG_IsOK(ecode3)) {
39462 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39463 }
39464 arg3 = static_cast< int >(val3);
39465 }
39466 if (obj3) {
39467 ecode4 = SWIG_AsVal_int(obj3, &val4);
39468 if (!SWIG_IsOK(ecode4)) {
39469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39470 }
39471 arg4 = static_cast< int >(val4);
39472 }
39473 {
39474 PyThreadState* __tstate = wxPyBeginAllowThreads();
39475 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39476 wxPyEndAllowThreads(__tstate);
39477 if (PyErr_Occurred()) SWIG_fail;
39478 }
39479 {
39480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39481 }
39482 return resultobj;
39483 fail:
39484 return NULL;
39485 }
39486
39487
39488 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39489 PyObject *resultobj = 0;
39490 wxWindow *arg1 = (wxWindow *) 0 ;
39491 wxMenu *arg2 = (wxMenu *) 0 ;
39492 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39493 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39494 bool result;
39495 void *argp1 = 0 ;
39496 int res1 = 0 ;
39497 void *argp2 = 0 ;
39498 int res2 = 0 ;
39499 wxPoint temp3 ;
39500 PyObject * obj0 = 0 ;
39501 PyObject * obj1 = 0 ;
39502 PyObject * obj2 = 0 ;
39503 char * kwnames[] = {
39504 (char *) "self",(char *) "menu",(char *) "pos", NULL
39505 };
39506
39507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39509 if (!SWIG_IsOK(res1)) {
39510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39511 }
39512 arg1 = reinterpret_cast< wxWindow * >(argp1);
39513 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39514 if (!SWIG_IsOK(res2)) {
39515 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39516 }
39517 arg2 = reinterpret_cast< wxMenu * >(argp2);
39518 if (obj2) {
39519 {
39520 arg3 = &temp3;
39521 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39522 }
39523 }
39524 {
39525 PyThreadState* __tstate = wxPyBeginAllowThreads();
39526 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39527 wxPyEndAllowThreads(__tstate);
39528 if (PyErr_Occurred()) SWIG_fail;
39529 }
39530 {
39531 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39532 }
39533 return resultobj;
39534 fail:
39535 return NULL;
39536 }
39537
39538
39539 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39540 PyObject *resultobj = 0;
39541 wxWindow *arg1 = (wxWindow *) 0 ;
39542 bool result;
39543 void *argp1 = 0 ;
39544 int res1 = 0 ;
39545 PyObject *swig_obj[1] ;
39546
39547 if (!args) SWIG_fail;
39548 swig_obj[0] = args;
39549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39550 if (!SWIG_IsOK(res1)) {
39551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39552 }
39553 arg1 = reinterpret_cast< wxWindow * >(argp1);
39554 {
39555 PyThreadState* __tstate = wxPyBeginAllowThreads();
39556 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39557 wxPyEndAllowThreads(__tstate);
39558 if (PyErr_Occurred()) SWIG_fail;
39559 }
39560 {
39561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39562 }
39563 return resultobj;
39564 fail:
39565 return NULL;
39566 }
39567
39568
39569 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39570 PyObject *resultobj = 0;
39571 wxWindow *arg1 = (wxWindow *) 0 ;
39572 long result;
39573 void *argp1 = 0 ;
39574 int res1 = 0 ;
39575 PyObject *swig_obj[1] ;
39576
39577 if (!args) SWIG_fail;
39578 swig_obj[0] = args;
39579 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39580 if (!SWIG_IsOK(res1)) {
39581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39582 }
39583 arg1 = reinterpret_cast< wxWindow * >(argp1);
39584 {
39585 PyThreadState* __tstate = wxPyBeginAllowThreads();
39586 result = (long)wxWindow_GetHandle(arg1);
39587 wxPyEndAllowThreads(__tstate);
39588 if (PyErr_Occurred()) SWIG_fail;
39589 }
39590 resultobj = SWIG_From_long(static_cast< long >(result));
39591 return resultobj;
39592 fail:
39593 return NULL;
39594 }
39595
39596
39597 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39598 PyObject *resultobj = 0;
39599 wxWindow *arg1 = (wxWindow *) 0 ;
39600 long arg2 ;
39601 void *argp1 = 0 ;
39602 int res1 = 0 ;
39603 long val2 ;
39604 int ecode2 = 0 ;
39605 PyObject * obj0 = 0 ;
39606 PyObject * obj1 = 0 ;
39607 char * kwnames[] = {
39608 (char *) "self",(char *) "handle", NULL
39609 };
39610
39611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39613 if (!SWIG_IsOK(res1)) {
39614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39615 }
39616 arg1 = reinterpret_cast< wxWindow * >(argp1);
39617 ecode2 = SWIG_AsVal_long(obj1, &val2);
39618 if (!SWIG_IsOK(ecode2)) {
39619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39620 }
39621 arg2 = static_cast< long >(val2);
39622 {
39623 PyThreadState* __tstate = wxPyBeginAllowThreads();
39624 wxWindow_AssociateHandle(arg1,arg2);
39625 wxPyEndAllowThreads(__tstate);
39626 if (PyErr_Occurred()) SWIG_fail;
39627 }
39628 resultobj = SWIG_Py_Void();
39629 return resultobj;
39630 fail:
39631 return NULL;
39632 }
39633
39634
39635 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39636 PyObject *resultobj = 0;
39637 wxWindow *arg1 = (wxWindow *) 0 ;
39638 void *argp1 = 0 ;
39639 int res1 = 0 ;
39640 PyObject *swig_obj[1] ;
39641
39642 if (!args) SWIG_fail;
39643 swig_obj[0] = args;
39644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39645 if (!SWIG_IsOK(res1)) {
39646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39647 }
39648 arg1 = reinterpret_cast< wxWindow * >(argp1);
39649 {
39650 PyThreadState* __tstate = wxPyBeginAllowThreads();
39651 (arg1)->DissociateHandle();
39652 wxPyEndAllowThreads(__tstate);
39653 if (PyErr_Occurred()) SWIG_fail;
39654 }
39655 resultobj = SWIG_Py_Void();
39656 return resultobj;
39657 fail:
39658 return NULL;
39659 }
39660
39661
39662 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39663 PyObject *resultobj = 0;
39664 wxWindow *arg1 = (wxWindow *) 0 ;
39665 wxPaintEvent *arg2 = 0 ;
39666 void *argp1 = 0 ;
39667 int res1 = 0 ;
39668 void *argp2 = 0 ;
39669 int res2 = 0 ;
39670 PyObject * obj0 = 0 ;
39671 PyObject * obj1 = 0 ;
39672 char * kwnames[] = {
39673 (char *) "self",(char *) "event", NULL
39674 };
39675
39676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39678 if (!SWIG_IsOK(res1)) {
39679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39680 }
39681 arg1 = reinterpret_cast< wxWindow * >(argp1);
39682 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39683 if (!SWIG_IsOK(res2)) {
39684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39685 }
39686 if (!argp2) {
39687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39688 }
39689 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39690 {
39691 PyThreadState* __tstate = wxPyBeginAllowThreads();
39692 (arg1)->OnPaint(*arg2);
39693 wxPyEndAllowThreads(__tstate);
39694 if (PyErr_Occurred()) SWIG_fail;
39695 }
39696 resultobj = SWIG_Py_Void();
39697 return resultobj;
39698 fail:
39699 return NULL;
39700 }
39701
39702
39703 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39704 PyObject *resultobj = 0;
39705 wxWindow *arg1 = (wxWindow *) 0 ;
39706 int arg2 ;
39707 bool result;
39708 void *argp1 = 0 ;
39709 int res1 = 0 ;
39710 int val2 ;
39711 int ecode2 = 0 ;
39712 PyObject * obj0 = 0 ;
39713 PyObject * obj1 = 0 ;
39714 char * kwnames[] = {
39715 (char *) "self",(char *) "orient", NULL
39716 };
39717
39718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39720 if (!SWIG_IsOK(res1)) {
39721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39722 }
39723 arg1 = reinterpret_cast< wxWindow * >(argp1);
39724 ecode2 = SWIG_AsVal_int(obj1, &val2);
39725 if (!SWIG_IsOK(ecode2)) {
39726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39727 }
39728 arg2 = static_cast< int >(val2);
39729 {
39730 PyThreadState* __tstate = wxPyBeginAllowThreads();
39731 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39732 wxPyEndAllowThreads(__tstate);
39733 if (PyErr_Occurred()) SWIG_fail;
39734 }
39735 {
39736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39737 }
39738 return resultobj;
39739 fail:
39740 return NULL;
39741 }
39742
39743
39744 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39745 PyObject *resultobj = 0;
39746 wxWindow *arg1 = (wxWindow *) 0 ;
39747 int arg2 ;
39748 int arg3 ;
39749 int arg4 ;
39750 int arg5 ;
39751 bool arg6 = (bool) true ;
39752 void *argp1 = 0 ;
39753 int res1 = 0 ;
39754 int val2 ;
39755 int ecode2 = 0 ;
39756 int val3 ;
39757 int ecode3 = 0 ;
39758 int val4 ;
39759 int ecode4 = 0 ;
39760 int val5 ;
39761 int ecode5 = 0 ;
39762 bool val6 ;
39763 int ecode6 = 0 ;
39764 PyObject * obj0 = 0 ;
39765 PyObject * obj1 = 0 ;
39766 PyObject * obj2 = 0 ;
39767 PyObject * obj3 = 0 ;
39768 PyObject * obj4 = 0 ;
39769 PyObject * obj5 = 0 ;
39770 char * kwnames[] = {
39771 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39772 };
39773
39774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39776 if (!SWIG_IsOK(res1)) {
39777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39778 }
39779 arg1 = reinterpret_cast< wxWindow * >(argp1);
39780 ecode2 = SWIG_AsVal_int(obj1, &val2);
39781 if (!SWIG_IsOK(ecode2)) {
39782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39783 }
39784 arg2 = static_cast< int >(val2);
39785 ecode3 = SWIG_AsVal_int(obj2, &val3);
39786 if (!SWIG_IsOK(ecode3)) {
39787 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39788 }
39789 arg3 = static_cast< int >(val3);
39790 ecode4 = SWIG_AsVal_int(obj3, &val4);
39791 if (!SWIG_IsOK(ecode4)) {
39792 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39793 }
39794 arg4 = static_cast< int >(val4);
39795 ecode5 = SWIG_AsVal_int(obj4, &val5);
39796 if (!SWIG_IsOK(ecode5)) {
39797 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39798 }
39799 arg5 = static_cast< int >(val5);
39800 if (obj5) {
39801 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39802 if (!SWIG_IsOK(ecode6)) {
39803 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39804 }
39805 arg6 = static_cast< bool >(val6);
39806 }
39807 {
39808 PyThreadState* __tstate = wxPyBeginAllowThreads();
39809 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39810 wxPyEndAllowThreads(__tstate);
39811 if (PyErr_Occurred()) SWIG_fail;
39812 }
39813 resultobj = SWIG_Py_Void();
39814 return resultobj;
39815 fail:
39816 return NULL;
39817 }
39818
39819
39820 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39821 PyObject *resultobj = 0;
39822 wxWindow *arg1 = (wxWindow *) 0 ;
39823 int arg2 ;
39824 int arg3 ;
39825 bool arg4 = (bool) true ;
39826 void *argp1 = 0 ;
39827 int res1 = 0 ;
39828 int val2 ;
39829 int ecode2 = 0 ;
39830 int val3 ;
39831 int ecode3 = 0 ;
39832 bool val4 ;
39833 int ecode4 = 0 ;
39834 PyObject * obj0 = 0 ;
39835 PyObject * obj1 = 0 ;
39836 PyObject * obj2 = 0 ;
39837 PyObject * obj3 = 0 ;
39838 char * kwnames[] = {
39839 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39840 };
39841
39842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39844 if (!SWIG_IsOK(res1)) {
39845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39846 }
39847 arg1 = reinterpret_cast< wxWindow * >(argp1);
39848 ecode2 = SWIG_AsVal_int(obj1, &val2);
39849 if (!SWIG_IsOK(ecode2)) {
39850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39851 }
39852 arg2 = static_cast< int >(val2);
39853 ecode3 = SWIG_AsVal_int(obj2, &val3);
39854 if (!SWIG_IsOK(ecode3)) {
39855 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39856 }
39857 arg3 = static_cast< int >(val3);
39858 if (obj3) {
39859 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39860 if (!SWIG_IsOK(ecode4)) {
39861 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39862 }
39863 arg4 = static_cast< bool >(val4);
39864 }
39865 {
39866 PyThreadState* __tstate = wxPyBeginAllowThreads();
39867 (arg1)->SetScrollPos(arg2,arg3,arg4);
39868 wxPyEndAllowThreads(__tstate);
39869 if (PyErr_Occurred()) SWIG_fail;
39870 }
39871 resultobj = SWIG_Py_Void();
39872 return resultobj;
39873 fail:
39874 return NULL;
39875 }
39876
39877
39878 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39879 PyObject *resultobj = 0;
39880 wxWindow *arg1 = (wxWindow *) 0 ;
39881 int arg2 ;
39882 int result;
39883 void *argp1 = 0 ;
39884 int res1 = 0 ;
39885 int val2 ;
39886 int ecode2 = 0 ;
39887 PyObject * obj0 = 0 ;
39888 PyObject * obj1 = 0 ;
39889 char * kwnames[] = {
39890 (char *) "self",(char *) "orientation", NULL
39891 };
39892
39893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39895 if (!SWIG_IsOK(res1)) {
39896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39897 }
39898 arg1 = reinterpret_cast< wxWindow * >(argp1);
39899 ecode2 = SWIG_AsVal_int(obj1, &val2);
39900 if (!SWIG_IsOK(ecode2)) {
39901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39902 }
39903 arg2 = static_cast< int >(val2);
39904 {
39905 PyThreadState* __tstate = wxPyBeginAllowThreads();
39906 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39907 wxPyEndAllowThreads(__tstate);
39908 if (PyErr_Occurred()) SWIG_fail;
39909 }
39910 resultobj = SWIG_From_int(static_cast< int >(result));
39911 return resultobj;
39912 fail:
39913 return NULL;
39914 }
39915
39916
39917 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39918 PyObject *resultobj = 0;
39919 wxWindow *arg1 = (wxWindow *) 0 ;
39920 int arg2 ;
39921 int result;
39922 void *argp1 = 0 ;
39923 int res1 = 0 ;
39924 int val2 ;
39925 int ecode2 = 0 ;
39926 PyObject * obj0 = 0 ;
39927 PyObject * obj1 = 0 ;
39928 char * kwnames[] = {
39929 (char *) "self",(char *) "orientation", NULL
39930 };
39931
39932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39934 if (!SWIG_IsOK(res1)) {
39935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39936 }
39937 arg1 = reinterpret_cast< wxWindow * >(argp1);
39938 ecode2 = SWIG_AsVal_int(obj1, &val2);
39939 if (!SWIG_IsOK(ecode2)) {
39940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39941 }
39942 arg2 = static_cast< int >(val2);
39943 {
39944 PyThreadState* __tstate = wxPyBeginAllowThreads();
39945 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39946 wxPyEndAllowThreads(__tstate);
39947 if (PyErr_Occurred()) SWIG_fail;
39948 }
39949 resultobj = SWIG_From_int(static_cast< int >(result));
39950 return resultobj;
39951 fail:
39952 return NULL;
39953 }
39954
39955
39956 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39957 PyObject *resultobj = 0;
39958 wxWindow *arg1 = (wxWindow *) 0 ;
39959 int arg2 ;
39960 int result;
39961 void *argp1 = 0 ;
39962 int res1 = 0 ;
39963 int val2 ;
39964 int ecode2 = 0 ;
39965 PyObject * obj0 = 0 ;
39966 PyObject * obj1 = 0 ;
39967 char * kwnames[] = {
39968 (char *) "self",(char *) "orientation", NULL
39969 };
39970
39971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39973 if (!SWIG_IsOK(res1)) {
39974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39975 }
39976 arg1 = reinterpret_cast< wxWindow * >(argp1);
39977 ecode2 = SWIG_AsVal_int(obj1, &val2);
39978 if (!SWIG_IsOK(ecode2)) {
39979 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39980 }
39981 arg2 = static_cast< int >(val2);
39982 {
39983 PyThreadState* __tstate = wxPyBeginAllowThreads();
39984 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39985 wxPyEndAllowThreads(__tstate);
39986 if (PyErr_Occurred()) SWIG_fail;
39987 }
39988 resultobj = SWIG_From_int(static_cast< int >(result));
39989 return resultobj;
39990 fail:
39991 return NULL;
39992 }
39993
39994
39995 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39996 PyObject *resultobj = 0;
39997 wxWindow *arg1 = (wxWindow *) 0 ;
39998 int arg2 ;
39999 int arg3 ;
40000 wxRect *arg4 = (wxRect *) NULL ;
40001 void *argp1 = 0 ;
40002 int res1 = 0 ;
40003 int val2 ;
40004 int ecode2 = 0 ;
40005 int val3 ;
40006 int ecode3 = 0 ;
40007 void *argp4 = 0 ;
40008 int res4 = 0 ;
40009 PyObject * obj0 = 0 ;
40010 PyObject * obj1 = 0 ;
40011 PyObject * obj2 = 0 ;
40012 PyObject * obj3 = 0 ;
40013 char * kwnames[] = {
40014 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40015 };
40016
40017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40019 if (!SWIG_IsOK(res1)) {
40020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40021 }
40022 arg1 = reinterpret_cast< wxWindow * >(argp1);
40023 ecode2 = SWIG_AsVal_int(obj1, &val2);
40024 if (!SWIG_IsOK(ecode2)) {
40025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40026 }
40027 arg2 = static_cast< int >(val2);
40028 ecode3 = SWIG_AsVal_int(obj2, &val3);
40029 if (!SWIG_IsOK(ecode3)) {
40030 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40031 }
40032 arg3 = static_cast< int >(val3);
40033 if (obj3) {
40034 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40035 if (!SWIG_IsOK(res4)) {
40036 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40037 }
40038 arg4 = reinterpret_cast< wxRect * >(argp4);
40039 }
40040 {
40041 PyThreadState* __tstate = wxPyBeginAllowThreads();
40042 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40043 wxPyEndAllowThreads(__tstate);
40044 if (PyErr_Occurred()) SWIG_fail;
40045 }
40046 resultobj = SWIG_Py_Void();
40047 return resultobj;
40048 fail:
40049 return NULL;
40050 }
40051
40052
40053 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40054 PyObject *resultobj = 0;
40055 wxWindow *arg1 = (wxWindow *) 0 ;
40056 int arg2 ;
40057 bool result;
40058 void *argp1 = 0 ;
40059 int res1 = 0 ;
40060 int val2 ;
40061 int ecode2 = 0 ;
40062 PyObject * obj0 = 0 ;
40063 PyObject * obj1 = 0 ;
40064 char * kwnames[] = {
40065 (char *) "self",(char *) "lines", NULL
40066 };
40067
40068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40070 if (!SWIG_IsOK(res1)) {
40071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40072 }
40073 arg1 = reinterpret_cast< wxWindow * >(argp1);
40074 ecode2 = SWIG_AsVal_int(obj1, &val2);
40075 if (!SWIG_IsOK(ecode2)) {
40076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40077 }
40078 arg2 = static_cast< int >(val2);
40079 {
40080 PyThreadState* __tstate = wxPyBeginAllowThreads();
40081 result = (bool)(arg1)->ScrollLines(arg2);
40082 wxPyEndAllowThreads(__tstate);
40083 if (PyErr_Occurred()) SWIG_fail;
40084 }
40085 {
40086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40087 }
40088 return resultobj;
40089 fail:
40090 return NULL;
40091 }
40092
40093
40094 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40095 PyObject *resultobj = 0;
40096 wxWindow *arg1 = (wxWindow *) 0 ;
40097 int arg2 ;
40098 bool result;
40099 void *argp1 = 0 ;
40100 int res1 = 0 ;
40101 int val2 ;
40102 int ecode2 = 0 ;
40103 PyObject * obj0 = 0 ;
40104 PyObject * obj1 = 0 ;
40105 char * kwnames[] = {
40106 (char *) "self",(char *) "pages", NULL
40107 };
40108
40109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40111 if (!SWIG_IsOK(res1)) {
40112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40113 }
40114 arg1 = reinterpret_cast< wxWindow * >(argp1);
40115 ecode2 = SWIG_AsVal_int(obj1, &val2);
40116 if (!SWIG_IsOK(ecode2)) {
40117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40118 }
40119 arg2 = static_cast< int >(val2);
40120 {
40121 PyThreadState* __tstate = wxPyBeginAllowThreads();
40122 result = (bool)(arg1)->ScrollPages(arg2);
40123 wxPyEndAllowThreads(__tstate);
40124 if (PyErr_Occurred()) SWIG_fail;
40125 }
40126 {
40127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40128 }
40129 return resultobj;
40130 fail:
40131 return NULL;
40132 }
40133
40134
40135 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40136 PyObject *resultobj = 0;
40137 wxWindow *arg1 = (wxWindow *) 0 ;
40138 bool result;
40139 void *argp1 = 0 ;
40140 int res1 = 0 ;
40141 PyObject *swig_obj[1] ;
40142
40143 if (!args) SWIG_fail;
40144 swig_obj[0] = args;
40145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40146 if (!SWIG_IsOK(res1)) {
40147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40148 }
40149 arg1 = reinterpret_cast< wxWindow * >(argp1);
40150 {
40151 PyThreadState* __tstate = wxPyBeginAllowThreads();
40152 result = (bool)(arg1)->LineUp();
40153 wxPyEndAllowThreads(__tstate);
40154 if (PyErr_Occurred()) SWIG_fail;
40155 }
40156 {
40157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40158 }
40159 return resultobj;
40160 fail:
40161 return NULL;
40162 }
40163
40164
40165 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40166 PyObject *resultobj = 0;
40167 wxWindow *arg1 = (wxWindow *) 0 ;
40168 bool result;
40169 void *argp1 = 0 ;
40170 int res1 = 0 ;
40171 PyObject *swig_obj[1] ;
40172
40173 if (!args) SWIG_fail;
40174 swig_obj[0] = args;
40175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40176 if (!SWIG_IsOK(res1)) {
40177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40178 }
40179 arg1 = reinterpret_cast< wxWindow * >(argp1);
40180 {
40181 PyThreadState* __tstate = wxPyBeginAllowThreads();
40182 result = (bool)(arg1)->LineDown();
40183 wxPyEndAllowThreads(__tstate);
40184 if (PyErr_Occurred()) SWIG_fail;
40185 }
40186 {
40187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40188 }
40189 return resultobj;
40190 fail:
40191 return NULL;
40192 }
40193
40194
40195 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40196 PyObject *resultobj = 0;
40197 wxWindow *arg1 = (wxWindow *) 0 ;
40198 bool result;
40199 void *argp1 = 0 ;
40200 int res1 = 0 ;
40201 PyObject *swig_obj[1] ;
40202
40203 if (!args) SWIG_fail;
40204 swig_obj[0] = args;
40205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40206 if (!SWIG_IsOK(res1)) {
40207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40208 }
40209 arg1 = reinterpret_cast< wxWindow * >(argp1);
40210 {
40211 PyThreadState* __tstate = wxPyBeginAllowThreads();
40212 result = (bool)(arg1)->PageUp();
40213 wxPyEndAllowThreads(__tstate);
40214 if (PyErr_Occurred()) SWIG_fail;
40215 }
40216 {
40217 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40218 }
40219 return resultobj;
40220 fail:
40221 return NULL;
40222 }
40223
40224
40225 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40226 PyObject *resultobj = 0;
40227 wxWindow *arg1 = (wxWindow *) 0 ;
40228 bool result;
40229 void *argp1 = 0 ;
40230 int res1 = 0 ;
40231 PyObject *swig_obj[1] ;
40232
40233 if (!args) SWIG_fail;
40234 swig_obj[0] = args;
40235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40236 if (!SWIG_IsOK(res1)) {
40237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40238 }
40239 arg1 = reinterpret_cast< wxWindow * >(argp1);
40240 {
40241 PyThreadState* __tstate = wxPyBeginAllowThreads();
40242 result = (bool)(arg1)->PageDown();
40243 wxPyEndAllowThreads(__tstate);
40244 if (PyErr_Occurred()) SWIG_fail;
40245 }
40246 {
40247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40248 }
40249 return resultobj;
40250 fail:
40251 return NULL;
40252 }
40253
40254
40255 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40256 PyObject *resultobj = 0;
40257 wxWindow *arg1 = (wxWindow *) 0 ;
40258 wxString *arg2 = 0 ;
40259 void *argp1 = 0 ;
40260 int res1 = 0 ;
40261 bool temp2 = false ;
40262 PyObject * obj0 = 0 ;
40263 PyObject * obj1 = 0 ;
40264 char * kwnames[] = {
40265 (char *) "self",(char *) "text", NULL
40266 };
40267
40268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40270 if (!SWIG_IsOK(res1)) {
40271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40272 }
40273 arg1 = reinterpret_cast< wxWindow * >(argp1);
40274 {
40275 arg2 = wxString_in_helper(obj1);
40276 if (arg2 == NULL) SWIG_fail;
40277 temp2 = true;
40278 }
40279 {
40280 PyThreadState* __tstate = wxPyBeginAllowThreads();
40281 (arg1)->SetHelpText((wxString const &)*arg2);
40282 wxPyEndAllowThreads(__tstate);
40283 if (PyErr_Occurred()) SWIG_fail;
40284 }
40285 resultobj = SWIG_Py_Void();
40286 {
40287 if (temp2)
40288 delete arg2;
40289 }
40290 return resultobj;
40291 fail:
40292 {
40293 if (temp2)
40294 delete arg2;
40295 }
40296 return NULL;
40297 }
40298
40299
40300 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40301 PyObject *resultobj = 0;
40302 wxWindow *arg1 = (wxWindow *) 0 ;
40303 wxString *arg2 = 0 ;
40304 void *argp1 = 0 ;
40305 int res1 = 0 ;
40306 bool temp2 = false ;
40307 PyObject * obj0 = 0 ;
40308 PyObject * obj1 = 0 ;
40309 char * kwnames[] = {
40310 (char *) "self",(char *) "text", NULL
40311 };
40312
40313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40315 if (!SWIG_IsOK(res1)) {
40316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40317 }
40318 arg1 = reinterpret_cast< wxWindow * >(argp1);
40319 {
40320 arg2 = wxString_in_helper(obj1);
40321 if (arg2 == NULL) SWIG_fail;
40322 temp2 = true;
40323 }
40324 {
40325 PyThreadState* __tstate = wxPyBeginAllowThreads();
40326 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40327 wxPyEndAllowThreads(__tstate);
40328 if (PyErr_Occurred()) SWIG_fail;
40329 }
40330 resultobj = SWIG_Py_Void();
40331 {
40332 if (temp2)
40333 delete arg2;
40334 }
40335 return resultobj;
40336 fail:
40337 {
40338 if (temp2)
40339 delete arg2;
40340 }
40341 return NULL;
40342 }
40343
40344
40345 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40346 PyObject *resultobj = 0;
40347 wxWindow *arg1 = (wxWindow *) 0 ;
40348 wxPoint *arg2 = 0 ;
40349 wxHelpEvent::Origin arg3 ;
40350 wxString result;
40351 void *argp1 = 0 ;
40352 int res1 = 0 ;
40353 wxPoint temp2 ;
40354 void *argp3 ;
40355 int res3 = 0 ;
40356 PyObject * obj0 = 0 ;
40357 PyObject * obj1 = 0 ;
40358 PyObject * obj2 = 0 ;
40359 char * kwnames[] = {
40360 (char *) "self",(char *) "pt",(char *) "origin", NULL
40361 };
40362
40363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40365 if (!SWIG_IsOK(res1)) {
40366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40367 }
40368 arg1 = reinterpret_cast< wxWindow * >(argp1);
40369 {
40370 arg2 = &temp2;
40371 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40372 }
40373 {
40374 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40375 if (!SWIG_IsOK(res3)) {
40376 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40377 }
40378 if (!argp3) {
40379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40380 } else {
40381 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40382 arg3 = *temp;
40383 if (SWIG_IsNewObj(res3)) delete temp;
40384 }
40385 }
40386 {
40387 PyThreadState* __tstate = wxPyBeginAllowThreads();
40388 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40389 wxPyEndAllowThreads(__tstate);
40390 if (PyErr_Occurred()) SWIG_fail;
40391 }
40392 {
40393 #if wxUSE_UNICODE
40394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40395 #else
40396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40397 #endif
40398 }
40399 return resultobj;
40400 fail:
40401 return NULL;
40402 }
40403
40404
40405 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40406 PyObject *resultobj = 0;
40407 wxWindow *arg1 = (wxWindow *) 0 ;
40408 wxString result;
40409 void *argp1 = 0 ;
40410 int res1 = 0 ;
40411 PyObject *swig_obj[1] ;
40412
40413 if (!args) SWIG_fail;
40414 swig_obj[0] = args;
40415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40416 if (!SWIG_IsOK(res1)) {
40417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40418 }
40419 arg1 = reinterpret_cast< wxWindow * >(argp1);
40420 {
40421 PyThreadState* __tstate = wxPyBeginAllowThreads();
40422 result = ((wxWindow const *)arg1)->GetHelpText();
40423 wxPyEndAllowThreads(__tstate);
40424 if (PyErr_Occurred()) SWIG_fail;
40425 }
40426 {
40427 #if wxUSE_UNICODE
40428 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40429 #else
40430 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40431 #endif
40432 }
40433 return resultobj;
40434 fail:
40435 return NULL;
40436 }
40437
40438
40439 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40440 PyObject *resultobj = 0;
40441 wxWindow *arg1 = (wxWindow *) 0 ;
40442 wxString *arg2 = 0 ;
40443 void *argp1 = 0 ;
40444 int res1 = 0 ;
40445 bool temp2 = false ;
40446 PyObject * obj0 = 0 ;
40447 PyObject * obj1 = 0 ;
40448 char * kwnames[] = {
40449 (char *) "self",(char *) "tip", NULL
40450 };
40451
40452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",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_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40456 }
40457 arg1 = reinterpret_cast< wxWindow * >(argp1);
40458 {
40459 arg2 = wxString_in_helper(obj1);
40460 if (arg2 == NULL) SWIG_fail;
40461 temp2 = true;
40462 }
40463 {
40464 PyThreadState* __tstate = wxPyBeginAllowThreads();
40465 (arg1)->SetToolTip((wxString const &)*arg2);
40466 wxPyEndAllowThreads(__tstate);
40467 if (PyErr_Occurred()) SWIG_fail;
40468 }
40469 resultobj = SWIG_Py_Void();
40470 {
40471 if (temp2)
40472 delete arg2;
40473 }
40474 return resultobj;
40475 fail:
40476 {
40477 if (temp2)
40478 delete arg2;
40479 }
40480 return NULL;
40481 }
40482
40483
40484 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40485 PyObject *resultobj = 0;
40486 wxWindow *arg1 = (wxWindow *) 0 ;
40487 wxToolTip *arg2 = (wxToolTip *) 0 ;
40488 void *argp1 = 0 ;
40489 int res1 = 0 ;
40490 int res2 = 0 ;
40491 PyObject * obj0 = 0 ;
40492 PyObject * obj1 = 0 ;
40493 char * kwnames[] = {
40494 (char *) "self",(char *) "tip", NULL
40495 };
40496
40497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40499 if (!SWIG_IsOK(res1)) {
40500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40501 }
40502 arg1 = reinterpret_cast< wxWindow * >(argp1);
40503 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40504 if (!SWIG_IsOK(res2)) {
40505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40506 }
40507 {
40508 PyThreadState* __tstate = wxPyBeginAllowThreads();
40509 (arg1)->SetToolTip(arg2);
40510 wxPyEndAllowThreads(__tstate);
40511 if (PyErr_Occurred()) SWIG_fail;
40512 }
40513 resultobj = SWIG_Py_Void();
40514 return resultobj;
40515 fail:
40516 return NULL;
40517 }
40518
40519
40520 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40521 PyObject *resultobj = 0;
40522 wxWindow *arg1 = (wxWindow *) 0 ;
40523 wxToolTip *result = 0 ;
40524 void *argp1 = 0 ;
40525 int res1 = 0 ;
40526 PyObject *swig_obj[1] ;
40527
40528 if (!args) SWIG_fail;
40529 swig_obj[0] = args;
40530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40531 if (!SWIG_IsOK(res1)) {
40532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40533 }
40534 arg1 = reinterpret_cast< wxWindow * >(argp1);
40535 {
40536 PyThreadState* __tstate = wxPyBeginAllowThreads();
40537 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40538 wxPyEndAllowThreads(__tstate);
40539 if (PyErr_Occurred()) SWIG_fail;
40540 }
40541 {
40542 resultobj = wxPyMake_wxObject(result, (bool)0);
40543 }
40544 return resultobj;
40545 fail:
40546 return NULL;
40547 }
40548
40549
40550 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40551 PyObject *resultobj = 0;
40552 wxWindow *arg1 = (wxWindow *) 0 ;
40553 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40554 void *argp1 = 0 ;
40555 int res1 = 0 ;
40556 int res2 = 0 ;
40557 PyObject * obj0 = 0 ;
40558 PyObject * obj1 = 0 ;
40559 char * kwnames[] = {
40560 (char *) "self",(char *) "dropTarget", NULL
40561 };
40562
40563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40565 if (!SWIG_IsOK(res1)) {
40566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40567 }
40568 arg1 = reinterpret_cast< wxWindow * >(argp1);
40569 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40570 if (!SWIG_IsOK(res2)) {
40571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40572 }
40573 {
40574 PyThreadState* __tstate = wxPyBeginAllowThreads();
40575 (arg1)->SetDropTarget(arg2);
40576 wxPyEndAllowThreads(__tstate);
40577 if (PyErr_Occurred()) SWIG_fail;
40578 }
40579 resultobj = SWIG_Py_Void();
40580 return resultobj;
40581 fail:
40582 return NULL;
40583 }
40584
40585
40586 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40587 PyObject *resultobj = 0;
40588 wxWindow *arg1 = (wxWindow *) 0 ;
40589 wxPyDropTarget *result = 0 ;
40590 void *argp1 = 0 ;
40591 int res1 = 0 ;
40592 PyObject *swig_obj[1] ;
40593
40594 if (!args) SWIG_fail;
40595 swig_obj[0] = args;
40596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40597 if (!SWIG_IsOK(res1)) {
40598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40599 }
40600 arg1 = reinterpret_cast< wxWindow * >(argp1);
40601 {
40602 PyThreadState* __tstate = wxPyBeginAllowThreads();
40603 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40604 wxPyEndAllowThreads(__tstate);
40605 if (PyErr_Occurred()) SWIG_fail;
40606 }
40607 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40608 return resultobj;
40609 fail:
40610 return NULL;
40611 }
40612
40613
40614 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40615 PyObject *resultobj = 0;
40616 wxWindow *arg1 = (wxWindow *) 0 ;
40617 bool arg2 ;
40618 void *argp1 = 0 ;
40619 int res1 = 0 ;
40620 bool val2 ;
40621 int ecode2 = 0 ;
40622 PyObject * obj0 = 0 ;
40623 PyObject * obj1 = 0 ;
40624 char * kwnames[] = {
40625 (char *) "self",(char *) "accept", NULL
40626 };
40627
40628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40629 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40630 if (!SWIG_IsOK(res1)) {
40631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40632 }
40633 arg1 = reinterpret_cast< wxWindow * >(argp1);
40634 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40635 if (!SWIG_IsOK(ecode2)) {
40636 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40637 }
40638 arg2 = static_cast< bool >(val2);
40639 {
40640 PyThreadState* __tstate = wxPyBeginAllowThreads();
40641 (arg1)->DragAcceptFiles(arg2);
40642 wxPyEndAllowThreads(__tstate);
40643 if (PyErr_Occurred()) SWIG_fail;
40644 }
40645 resultobj = SWIG_Py_Void();
40646 return resultobj;
40647 fail:
40648 return NULL;
40649 }
40650
40651
40652 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40653 PyObject *resultobj = 0;
40654 wxWindow *arg1 = (wxWindow *) 0 ;
40655 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40656 void *argp1 = 0 ;
40657 int res1 = 0 ;
40658 int res2 = 0 ;
40659 PyObject * obj0 = 0 ;
40660 PyObject * obj1 = 0 ;
40661 char * kwnames[] = {
40662 (char *) "self",(char *) "constraints", NULL
40663 };
40664
40665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40667 if (!SWIG_IsOK(res1)) {
40668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40669 }
40670 arg1 = reinterpret_cast< wxWindow * >(argp1);
40671 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40672 if (!SWIG_IsOK(res2)) {
40673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40674 }
40675 {
40676 PyThreadState* __tstate = wxPyBeginAllowThreads();
40677 (arg1)->SetConstraints(arg2);
40678 wxPyEndAllowThreads(__tstate);
40679 if (PyErr_Occurred()) SWIG_fail;
40680 }
40681 resultobj = SWIG_Py_Void();
40682 return resultobj;
40683 fail:
40684 return NULL;
40685 }
40686
40687
40688 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40689 PyObject *resultobj = 0;
40690 wxWindow *arg1 = (wxWindow *) 0 ;
40691 wxLayoutConstraints *result = 0 ;
40692 void *argp1 = 0 ;
40693 int res1 = 0 ;
40694 PyObject *swig_obj[1] ;
40695
40696 if (!args) SWIG_fail;
40697 swig_obj[0] = args;
40698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40699 if (!SWIG_IsOK(res1)) {
40700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40701 }
40702 arg1 = reinterpret_cast< wxWindow * >(argp1);
40703 {
40704 PyThreadState* __tstate = wxPyBeginAllowThreads();
40705 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40706 wxPyEndAllowThreads(__tstate);
40707 if (PyErr_Occurred()) SWIG_fail;
40708 }
40709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40710 return resultobj;
40711 fail:
40712 return NULL;
40713 }
40714
40715
40716 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40717 PyObject *resultobj = 0;
40718 wxWindow *arg1 = (wxWindow *) 0 ;
40719 bool arg2 ;
40720 void *argp1 = 0 ;
40721 int res1 = 0 ;
40722 bool val2 ;
40723 int ecode2 = 0 ;
40724 PyObject * obj0 = 0 ;
40725 PyObject * obj1 = 0 ;
40726 char * kwnames[] = {
40727 (char *) "self",(char *) "autoLayout", NULL
40728 };
40729
40730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40732 if (!SWIG_IsOK(res1)) {
40733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40734 }
40735 arg1 = reinterpret_cast< wxWindow * >(argp1);
40736 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40737 if (!SWIG_IsOK(ecode2)) {
40738 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40739 }
40740 arg2 = static_cast< bool >(val2);
40741 {
40742 PyThreadState* __tstate = wxPyBeginAllowThreads();
40743 (arg1)->SetAutoLayout(arg2);
40744 wxPyEndAllowThreads(__tstate);
40745 if (PyErr_Occurred()) SWIG_fail;
40746 }
40747 resultobj = SWIG_Py_Void();
40748 return resultobj;
40749 fail:
40750 return NULL;
40751 }
40752
40753
40754 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40755 PyObject *resultobj = 0;
40756 wxWindow *arg1 = (wxWindow *) 0 ;
40757 bool result;
40758 void *argp1 = 0 ;
40759 int res1 = 0 ;
40760 PyObject *swig_obj[1] ;
40761
40762 if (!args) SWIG_fail;
40763 swig_obj[0] = args;
40764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40765 if (!SWIG_IsOK(res1)) {
40766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40767 }
40768 arg1 = reinterpret_cast< wxWindow * >(argp1);
40769 {
40770 PyThreadState* __tstate = wxPyBeginAllowThreads();
40771 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40772 wxPyEndAllowThreads(__tstate);
40773 if (PyErr_Occurred()) SWIG_fail;
40774 }
40775 {
40776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40777 }
40778 return resultobj;
40779 fail:
40780 return NULL;
40781 }
40782
40783
40784 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40785 PyObject *resultobj = 0;
40786 wxWindow *arg1 = (wxWindow *) 0 ;
40787 bool result;
40788 void *argp1 = 0 ;
40789 int res1 = 0 ;
40790 PyObject *swig_obj[1] ;
40791
40792 if (!args) SWIG_fail;
40793 swig_obj[0] = args;
40794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40795 if (!SWIG_IsOK(res1)) {
40796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40797 }
40798 arg1 = reinterpret_cast< wxWindow * >(argp1);
40799 {
40800 PyThreadState* __tstate = wxPyBeginAllowThreads();
40801 result = (bool)(arg1)->Layout();
40802 wxPyEndAllowThreads(__tstate);
40803 if (PyErr_Occurred()) SWIG_fail;
40804 }
40805 {
40806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40807 }
40808 return resultobj;
40809 fail:
40810 return NULL;
40811 }
40812
40813
40814 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40815 PyObject *resultobj = 0;
40816 wxWindow *arg1 = (wxWindow *) 0 ;
40817 wxSizer *arg2 = (wxSizer *) 0 ;
40818 bool arg3 = (bool) true ;
40819 void *argp1 = 0 ;
40820 int res1 = 0 ;
40821 int res2 = 0 ;
40822 bool val3 ;
40823 int ecode3 = 0 ;
40824 PyObject * obj0 = 0 ;
40825 PyObject * obj1 = 0 ;
40826 PyObject * obj2 = 0 ;
40827 char * kwnames[] = {
40828 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40829 };
40830
40831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40833 if (!SWIG_IsOK(res1)) {
40834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40835 }
40836 arg1 = reinterpret_cast< wxWindow * >(argp1);
40837 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40838 if (!SWIG_IsOK(res2)) {
40839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40840 }
40841 if (obj2) {
40842 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40843 if (!SWIG_IsOK(ecode3)) {
40844 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40845 }
40846 arg3 = static_cast< bool >(val3);
40847 }
40848 {
40849 PyThreadState* __tstate = wxPyBeginAllowThreads();
40850 (arg1)->SetSizer(arg2,arg3);
40851 wxPyEndAllowThreads(__tstate);
40852 if (PyErr_Occurred()) SWIG_fail;
40853 }
40854 resultobj = SWIG_Py_Void();
40855 return resultobj;
40856 fail:
40857 return NULL;
40858 }
40859
40860
40861 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40862 PyObject *resultobj = 0;
40863 wxWindow *arg1 = (wxWindow *) 0 ;
40864 wxSizer *arg2 = (wxSizer *) 0 ;
40865 bool arg3 = (bool) true ;
40866 void *argp1 = 0 ;
40867 int res1 = 0 ;
40868 int res2 = 0 ;
40869 bool val3 ;
40870 int ecode3 = 0 ;
40871 PyObject * obj0 = 0 ;
40872 PyObject * obj1 = 0 ;
40873 PyObject * obj2 = 0 ;
40874 char * kwnames[] = {
40875 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40876 };
40877
40878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40880 if (!SWIG_IsOK(res1)) {
40881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40882 }
40883 arg1 = reinterpret_cast< wxWindow * >(argp1);
40884 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40885 if (!SWIG_IsOK(res2)) {
40886 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40887 }
40888 if (obj2) {
40889 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40890 if (!SWIG_IsOK(ecode3)) {
40891 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40892 }
40893 arg3 = static_cast< bool >(val3);
40894 }
40895 {
40896 PyThreadState* __tstate = wxPyBeginAllowThreads();
40897 (arg1)->SetSizerAndFit(arg2,arg3);
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 resultobj = SWIG_Py_Void();
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40909 PyObject *resultobj = 0;
40910 wxWindow *arg1 = (wxWindow *) 0 ;
40911 wxSizer *result = 0 ;
40912 void *argp1 = 0 ;
40913 int res1 = 0 ;
40914 PyObject *swig_obj[1] ;
40915
40916 if (!args) SWIG_fail;
40917 swig_obj[0] = args;
40918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40919 if (!SWIG_IsOK(res1)) {
40920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40921 }
40922 arg1 = reinterpret_cast< wxWindow * >(argp1);
40923 {
40924 PyThreadState* __tstate = wxPyBeginAllowThreads();
40925 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40926 wxPyEndAllowThreads(__tstate);
40927 if (PyErr_Occurred()) SWIG_fail;
40928 }
40929 {
40930 resultobj = wxPyMake_wxObject(result, (bool)0);
40931 }
40932 return resultobj;
40933 fail:
40934 return NULL;
40935 }
40936
40937
40938 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40939 PyObject *resultobj = 0;
40940 wxWindow *arg1 = (wxWindow *) 0 ;
40941 wxSizer *arg2 = (wxSizer *) 0 ;
40942 void *argp1 = 0 ;
40943 int res1 = 0 ;
40944 void *argp2 = 0 ;
40945 int res2 = 0 ;
40946 PyObject * obj0 = 0 ;
40947 PyObject * obj1 = 0 ;
40948 char * kwnames[] = {
40949 (char *) "self",(char *) "sizer", NULL
40950 };
40951
40952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40954 if (!SWIG_IsOK(res1)) {
40955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40956 }
40957 arg1 = reinterpret_cast< wxWindow * >(argp1);
40958 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40959 if (!SWIG_IsOK(res2)) {
40960 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40961 }
40962 arg2 = reinterpret_cast< wxSizer * >(argp2);
40963 {
40964 PyThreadState* __tstate = wxPyBeginAllowThreads();
40965 (arg1)->SetContainingSizer(arg2);
40966 wxPyEndAllowThreads(__tstate);
40967 if (PyErr_Occurred()) SWIG_fail;
40968 }
40969 resultobj = SWIG_Py_Void();
40970 return resultobj;
40971 fail:
40972 return NULL;
40973 }
40974
40975
40976 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40977 PyObject *resultobj = 0;
40978 wxWindow *arg1 = (wxWindow *) 0 ;
40979 wxSizer *result = 0 ;
40980 void *argp1 = 0 ;
40981 int res1 = 0 ;
40982 PyObject *swig_obj[1] ;
40983
40984 if (!args) SWIG_fail;
40985 swig_obj[0] = args;
40986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40987 if (!SWIG_IsOK(res1)) {
40988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40989 }
40990 arg1 = reinterpret_cast< wxWindow * >(argp1);
40991 {
40992 PyThreadState* __tstate = wxPyBeginAllowThreads();
40993 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40994 wxPyEndAllowThreads(__tstate);
40995 if (PyErr_Occurred()) SWIG_fail;
40996 }
40997 {
40998 resultobj = wxPyMake_wxObject(result, (bool)0);
40999 }
41000 return resultobj;
41001 fail:
41002 return NULL;
41003 }
41004
41005
41006 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41007 PyObject *resultobj = 0;
41008 wxWindow *arg1 = (wxWindow *) 0 ;
41009 void *argp1 = 0 ;
41010 int res1 = 0 ;
41011 PyObject *swig_obj[1] ;
41012
41013 if (!args) SWIG_fail;
41014 swig_obj[0] = args;
41015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41016 if (!SWIG_IsOK(res1)) {
41017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41018 }
41019 arg1 = reinterpret_cast< wxWindow * >(argp1);
41020 {
41021 PyThreadState* __tstate = wxPyBeginAllowThreads();
41022 (arg1)->InheritAttributes();
41023 wxPyEndAllowThreads(__tstate);
41024 if (PyErr_Occurred()) SWIG_fail;
41025 }
41026 resultobj = SWIG_Py_Void();
41027 return resultobj;
41028 fail:
41029 return NULL;
41030 }
41031
41032
41033 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41034 PyObject *resultobj = 0;
41035 wxWindow *arg1 = (wxWindow *) 0 ;
41036 bool result;
41037 void *argp1 = 0 ;
41038 int res1 = 0 ;
41039 PyObject *swig_obj[1] ;
41040
41041 if (!args) SWIG_fail;
41042 swig_obj[0] = args;
41043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41044 if (!SWIG_IsOK(res1)) {
41045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41046 }
41047 arg1 = reinterpret_cast< wxWindow * >(argp1);
41048 {
41049 PyThreadState* __tstate = wxPyBeginAllowThreads();
41050 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41051 wxPyEndAllowThreads(__tstate);
41052 if (PyErr_Occurred()) SWIG_fail;
41053 }
41054 {
41055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41056 }
41057 return resultobj;
41058 fail:
41059 return NULL;
41060 }
41061
41062
41063 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41064 PyObject *resultobj = 0;
41065 wxWindow *arg1 = (wxWindow *) 0 ;
41066 bool result;
41067 void *argp1 = 0 ;
41068 int res1 = 0 ;
41069 PyObject *swig_obj[1] ;
41070
41071 if (!args) SWIG_fail;
41072 swig_obj[0] = args;
41073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41074 if (!SWIG_IsOK(res1)) {
41075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41076 }
41077 arg1 = reinterpret_cast< wxWindow * >(argp1);
41078 {
41079 PyThreadState* __tstate = wxPyBeginAllowThreads();
41080 result = (bool)(arg1)->CanSetTransparent();
41081 wxPyEndAllowThreads(__tstate);
41082 if (PyErr_Occurred()) SWIG_fail;
41083 }
41084 {
41085 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41086 }
41087 return resultobj;
41088 fail:
41089 return NULL;
41090 }
41091
41092
41093 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41094 PyObject *resultobj = 0;
41095 wxWindow *arg1 = (wxWindow *) 0 ;
41096 byte arg2 ;
41097 bool result;
41098 void *argp1 = 0 ;
41099 int res1 = 0 ;
41100 unsigned char val2 ;
41101 int ecode2 = 0 ;
41102 PyObject * obj0 = 0 ;
41103 PyObject * obj1 = 0 ;
41104 char * kwnames[] = {
41105 (char *) "self",(char *) "alpha", NULL
41106 };
41107
41108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41110 if (!SWIG_IsOK(res1)) {
41111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41112 }
41113 arg1 = reinterpret_cast< wxWindow * >(argp1);
41114 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41115 if (!SWIG_IsOK(ecode2)) {
41116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41117 }
41118 arg2 = static_cast< byte >(val2);
41119 {
41120 PyThreadState* __tstate = wxPyBeginAllowThreads();
41121 result = (bool)(arg1)->SetTransparent(arg2);
41122 wxPyEndAllowThreads(__tstate);
41123 if (PyErr_Occurred()) SWIG_fail;
41124 }
41125 {
41126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41127 }
41128 return resultobj;
41129 fail:
41130 return NULL;
41131 }
41132
41133
41134 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41135 PyObject *obj;
41136 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41137 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41138 return SWIG_Py_Void();
41139 }
41140
41141 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41142 return SWIG_Python_InitShadowInstance(args);
41143 }
41144
41145 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41146 PyObject *resultobj = 0;
41147 long arg1 ;
41148 wxWindow *arg2 = (wxWindow *) NULL ;
41149 wxWindow *result = 0 ;
41150 long val1 ;
41151 int ecode1 = 0 ;
41152 void *argp2 = 0 ;
41153 int res2 = 0 ;
41154 PyObject * obj0 = 0 ;
41155 PyObject * obj1 = 0 ;
41156 char * kwnames[] = {
41157 (char *) "id",(char *) "parent", NULL
41158 };
41159
41160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41161 ecode1 = SWIG_AsVal_long(obj0, &val1);
41162 if (!SWIG_IsOK(ecode1)) {
41163 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41164 }
41165 arg1 = static_cast< long >(val1);
41166 if (obj1) {
41167 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41168 if (!SWIG_IsOK(res2)) {
41169 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41170 }
41171 arg2 = reinterpret_cast< wxWindow * >(argp2);
41172 }
41173 {
41174 if (!wxPyCheckForApp()) SWIG_fail;
41175 PyThreadState* __tstate = wxPyBeginAllowThreads();
41176 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41177 wxPyEndAllowThreads(__tstate);
41178 if (PyErr_Occurred()) SWIG_fail;
41179 }
41180 {
41181 resultobj = wxPyMake_wxObject(result, 0);
41182 }
41183 return resultobj;
41184 fail:
41185 return NULL;
41186 }
41187
41188
41189 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41190 PyObject *resultobj = 0;
41191 wxString *arg1 = 0 ;
41192 wxWindow *arg2 = (wxWindow *) NULL ;
41193 wxWindow *result = 0 ;
41194 bool temp1 = false ;
41195 void *argp2 = 0 ;
41196 int res2 = 0 ;
41197 PyObject * obj0 = 0 ;
41198 PyObject * obj1 = 0 ;
41199 char * kwnames[] = {
41200 (char *) "name",(char *) "parent", NULL
41201 };
41202
41203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41204 {
41205 arg1 = wxString_in_helper(obj0);
41206 if (arg1 == NULL) SWIG_fail;
41207 temp1 = true;
41208 }
41209 if (obj1) {
41210 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41211 if (!SWIG_IsOK(res2)) {
41212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41213 }
41214 arg2 = reinterpret_cast< wxWindow * >(argp2);
41215 }
41216 {
41217 if (!wxPyCheckForApp()) SWIG_fail;
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41220 wxPyEndAllowThreads(__tstate);
41221 if (PyErr_Occurred()) SWIG_fail;
41222 }
41223 {
41224 resultobj = wxPyMake_wxObject(result, 0);
41225 }
41226 {
41227 if (temp1)
41228 delete arg1;
41229 }
41230 return resultobj;
41231 fail:
41232 {
41233 if (temp1)
41234 delete arg1;
41235 }
41236 return NULL;
41237 }
41238
41239
41240 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41241 PyObject *resultobj = 0;
41242 wxString *arg1 = 0 ;
41243 wxWindow *arg2 = (wxWindow *) NULL ;
41244 wxWindow *result = 0 ;
41245 bool temp1 = false ;
41246 void *argp2 = 0 ;
41247 int res2 = 0 ;
41248 PyObject * obj0 = 0 ;
41249 PyObject * obj1 = 0 ;
41250 char * kwnames[] = {
41251 (char *) "label",(char *) "parent", NULL
41252 };
41253
41254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41255 {
41256 arg1 = wxString_in_helper(obj0);
41257 if (arg1 == NULL) SWIG_fail;
41258 temp1 = true;
41259 }
41260 if (obj1) {
41261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41262 if (!SWIG_IsOK(res2)) {
41263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41264 }
41265 arg2 = reinterpret_cast< wxWindow * >(argp2);
41266 }
41267 {
41268 if (!wxPyCheckForApp()) SWIG_fail;
41269 PyThreadState* __tstate = wxPyBeginAllowThreads();
41270 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41271 wxPyEndAllowThreads(__tstate);
41272 if (PyErr_Occurred()) SWIG_fail;
41273 }
41274 {
41275 resultobj = wxPyMake_wxObject(result, 0);
41276 }
41277 {
41278 if (temp1)
41279 delete arg1;
41280 }
41281 return resultobj;
41282 fail:
41283 {
41284 if (temp1)
41285 delete arg1;
41286 }
41287 return NULL;
41288 }
41289
41290
41291 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41292 PyObject *resultobj = 0;
41293 wxWindow *arg1 = (wxWindow *) 0 ;
41294 unsigned long arg2 ;
41295 wxWindow *result = 0 ;
41296 void *argp1 = 0 ;
41297 int res1 = 0 ;
41298 unsigned long val2 ;
41299 int ecode2 = 0 ;
41300 PyObject * obj0 = 0 ;
41301 PyObject * obj1 = 0 ;
41302 char * kwnames[] = {
41303 (char *) "parent",(char *) "_hWnd", NULL
41304 };
41305
41306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41308 if (!SWIG_IsOK(res1)) {
41309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41310 }
41311 arg1 = reinterpret_cast< wxWindow * >(argp1);
41312 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41313 if (!SWIG_IsOK(ecode2)) {
41314 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41315 }
41316 arg2 = static_cast< unsigned long >(val2);
41317 {
41318 PyThreadState* __tstate = wxPyBeginAllowThreads();
41319 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41320 wxPyEndAllowThreads(__tstate);
41321 if (PyErr_Occurred()) SWIG_fail;
41322 }
41323 {
41324 resultobj = wxPyMake_wxObject(result, 0);
41325 }
41326 return resultobj;
41327 fail:
41328 return NULL;
41329 }
41330
41331
41332 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41333 PyObject *resultobj = 0;
41334 PyObject *result = 0 ;
41335
41336 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41337 {
41338 PyThreadState* __tstate = wxPyBeginAllowThreads();
41339 result = (PyObject *)GetTopLevelWindows();
41340 wxPyEndAllowThreads(__tstate);
41341 if (PyErr_Occurred()) SWIG_fail;
41342 }
41343 resultobj = result;
41344 return resultobj;
41345 fail:
41346 return NULL;
41347 }
41348
41349
41350 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41351 PyObject *resultobj = 0;
41352 wxValidator *result = 0 ;
41353
41354 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41355 {
41356 PyThreadState* __tstate = wxPyBeginAllowThreads();
41357 result = (wxValidator *)new wxValidator();
41358 wxPyEndAllowThreads(__tstate);
41359 if (PyErr_Occurred()) SWIG_fail;
41360 }
41361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41362 return resultobj;
41363 fail:
41364 return NULL;
41365 }
41366
41367
41368 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41369 PyObject *resultobj = 0;
41370 wxValidator *arg1 = (wxValidator *) 0 ;
41371 wxValidator *result = 0 ;
41372 void *argp1 = 0 ;
41373 int res1 = 0 ;
41374 PyObject *swig_obj[1] ;
41375
41376 if (!args) SWIG_fail;
41377 swig_obj[0] = args;
41378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41379 if (!SWIG_IsOK(res1)) {
41380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41381 }
41382 arg1 = reinterpret_cast< wxValidator * >(argp1);
41383 {
41384 PyThreadState* __tstate = wxPyBeginAllowThreads();
41385 result = (wxValidator *)(arg1)->Clone();
41386 wxPyEndAllowThreads(__tstate);
41387 if (PyErr_Occurred()) SWIG_fail;
41388 }
41389 {
41390 resultobj = wxPyMake_wxObject(result, 0);
41391 }
41392 return resultobj;
41393 fail:
41394 return NULL;
41395 }
41396
41397
41398 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41399 PyObject *resultobj = 0;
41400 wxValidator *arg1 = (wxValidator *) 0 ;
41401 wxWindow *arg2 = (wxWindow *) 0 ;
41402 bool result;
41403 void *argp1 = 0 ;
41404 int res1 = 0 ;
41405 void *argp2 = 0 ;
41406 int res2 = 0 ;
41407 PyObject * obj0 = 0 ;
41408 PyObject * obj1 = 0 ;
41409 char * kwnames[] = {
41410 (char *) "self",(char *) "parent", NULL
41411 };
41412
41413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41415 if (!SWIG_IsOK(res1)) {
41416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41417 }
41418 arg1 = reinterpret_cast< wxValidator * >(argp1);
41419 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41420 if (!SWIG_IsOK(res2)) {
41421 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41422 }
41423 arg2 = reinterpret_cast< wxWindow * >(argp2);
41424 {
41425 PyThreadState* __tstate = wxPyBeginAllowThreads();
41426 result = (bool)(arg1)->Validate(arg2);
41427 wxPyEndAllowThreads(__tstate);
41428 if (PyErr_Occurred()) SWIG_fail;
41429 }
41430 {
41431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41432 }
41433 return resultobj;
41434 fail:
41435 return NULL;
41436 }
41437
41438
41439 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41440 PyObject *resultobj = 0;
41441 wxValidator *arg1 = (wxValidator *) 0 ;
41442 bool result;
41443 void *argp1 = 0 ;
41444 int res1 = 0 ;
41445 PyObject *swig_obj[1] ;
41446
41447 if (!args) SWIG_fail;
41448 swig_obj[0] = args;
41449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41450 if (!SWIG_IsOK(res1)) {
41451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41452 }
41453 arg1 = reinterpret_cast< wxValidator * >(argp1);
41454 {
41455 PyThreadState* __tstate = wxPyBeginAllowThreads();
41456 result = (bool)(arg1)->TransferToWindow();
41457 wxPyEndAllowThreads(__tstate);
41458 if (PyErr_Occurred()) SWIG_fail;
41459 }
41460 {
41461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41462 }
41463 return resultobj;
41464 fail:
41465 return NULL;
41466 }
41467
41468
41469 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41470 PyObject *resultobj = 0;
41471 wxValidator *arg1 = (wxValidator *) 0 ;
41472 bool result;
41473 void *argp1 = 0 ;
41474 int res1 = 0 ;
41475 PyObject *swig_obj[1] ;
41476
41477 if (!args) SWIG_fail;
41478 swig_obj[0] = args;
41479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41480 if (!SWIG_IsOK(res1)) {
41481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41482 }
41483 arg1 = reinterpret_cast< wxValidator * >(argp1);
41484 {
41485 PyThreadState* __tstate = wxPyBeginAllowThreads();
41486 result = (bool)(arg1)->TransferFromWindow();
41487 wxPyEndAllowThreads(__tstate);
41488 if (PyErr_Occurred()) SWIG_fail;
41489 }
41490 {
41491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41492 }
41493 return resultobj;
41494 fail:
41495 return NULL;
41496 }
41497
41498
41499 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41500 PyObject *resultobj = 0;
41501 wxValidator *arg1 = (wxValidator *) 0 ;
41502 wxWindow *result = 0 ;
41503 void *argp1 = 0 ;
41504 int res1 = 0 ;
41505 PyObject *swig_obj[1] ;
41506
41507 if (!args) SWIG_fail;
41508 swig_obj[0] = args;
41509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41510 if (!SWIG_IsOK(res1)) {
41511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41512 }
41513 arg1 = reinterpret_cast< wxValidator * >(argp1);
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 result = (wxWindow *)(arg1)->GetWindow();
41517 wxPyEndAllowThreads(__tstate);
41518 if (PyErr_Occurred()) SWIG_fail;
41519 }
41520 {
41521 resultobj = wxPyMake_wxObject(result, 0);
41522 }
41523 return resultobj;
41524 fail:
41525 return NULL;
41526 }
41527
41528
41529 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41530 PyObject *resultobj = 0;
41531 wxValidator *arg1 = (wxValidator *) 0 ;
41532 wxWindow *arg2 = (wxWindow *) 0 ;
41533 void *argp1 = 0 ;
41534 int res1 = 0 ;
41535 void *argp2 = 0 ;
41536 int res2 = 0 ;
41537 PyObject * obj0 = 0 ;
41538 PyObject * obj1 = 0 ;
41539 char * kwnames[] = {
41540 (char *) "self",(char *) "window", NULL
41541 };
41542
41543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41545 if (!SWIG_IsOK(res1)) {
41546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41547 }
41548 arg1 = reinterpret_cast< wxValidator * >(argp1);
41549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41550 if (!SWIG_IsOK(res2)) {
41551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41552 }
41553 arg2 = reinterpret_cast< wxWindow * >(argp2);
41554 {
41555 PyThreadState* __tstate = wxPyBeginAllowThreads();
41556 (arg1)->SetWindow(arg2);
41557 wxPyEndAllowThreads(__tstate);
41558 if (PyErr_Occurred()) SWIG_fail;
41559 }
41560 resultobj = SWIG_Py_Void();
41561 return resultobj;
41562 fail:
41563 return NULL;
41564 }
41565
41566
41567 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41568 PyObject *resultobj = 0;
41569 bool result;
41570
41571 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41572 {
41573 PyThreadState* __tstate = wxPyBeginAllowThreads();
41574 result = (bool)wxValidator::IsSilent();
41575 wxPyEndAllowThreads(__tstate);
41576 if (PyErr_Occurred()) SWIG_fail;
41577 }
41578 {
41579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41580 }
41581 return resultobj;
41582 fail:
41583 return NULL;
41584 }
41585
41586
41587 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41588 PyObject *resultobj = 0;
41589 int arg1 = (int) true ;
41590 int val1 ;
41591 int ecode1 = 0 ;
41592 PyObject * obj0 = 0 ;
41593 char * kwnames[] = {
41594 (char *) "doIt", NULL
41595 };
41596
41597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41598 if (obj0) {
41599 ecode1 = SWIG_AsVal_int(obj0, &val1);
41600 if (!SWIG_IsOK(ecode1)) {
41601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41602 }
41603 arg1 = static_cast< int >(val1);
41604 }
41605 {
41606 PyThreadState* __tstate = wxPyBeginAllowThreads();
41607 wxValidator::SetBellOnError(arg1);
41608 wxPyEndAllowThreads(__tstate);
41609 if (PyErr_Occurred()) SWIG_fail;
41610 }
41611 resultobj = SWIG_Py_Void();
41612 return resultobj;
41613 fail:
41614 return NULL;
41615 }
41616
41617
41618 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41619 PyObject *obj;
41620 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41621 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41622 return SWIG_Py_Void();
41623 }
41624
41625 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41626 return SWIG_Python_InitShadowInstance(args);
41627 }
41628
41629 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41630 PyObject *resultobj = 0;
41631 wxPyValidator *result = 0 ;
41632
41633 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41634 {
41635 PyThreadState* __tstate = wxPyBeginAllowThreads();
41636 result = (wxPyValidator *)new wxPyValidator();
41637 wxPyEndAllowThreads(__tstate);
41638 if (PyErr_Occurred()) SWIG_fail;
41639 }
41640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41641 return resultobj;
41642 fail:
41643 return NULL;
41644 }
41645
41646
41647 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41648 PyObject *resultobj = 0;
41649 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41650 PyObject *arg2 = (PyObject *) 0 ;
41651 PyObject *arg3 = (PyObject *) 0 ;
41652 int arg4 = (int) true ;
41653 void *argp1 = 0 ;
41654 int res1 = 0 ;
41655 int val4 ;
41656 int ecode4 = 0 ;
41657 PyObject * obj0 = 0 ;
41658 PyObject * obj1 = 0 ;
41659 PyObject * obj2 = 0 ;
41660 PyObject * obj3 = 0 ;
41661 char * kwnames[] = {
41662 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41663 };
41664
41665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41667 if (!SWIG_IsOK(res1)) {
41668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41669 }
41670 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41671 arg2 = obj1;
41672 arg3 = obj2;
41673 if (obj3) {
41674 ecode4 = SWIG_AsVal_int(obj3, &val4);
41675 if (!SWIG_IsOK(ecode4)) {
41676 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41677 }
41678 arg4 = static_cast< int >(val4);
41679 }
41680 {
41681 PyThreadState* __tstate = wxPyBeginAllowThreads();
41682 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41683 wxPyEndAllowThreads(__tstate);
41684 if (PyErr_Occurred()) SWIG_fail;
41685 }
41686 resultobj = SWIG_Py_Void();
41687 return resultobj;
41688 fail:
41689 return NULL;
41690 }
41691
41692
41693 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41694 PyObject *obj;
41695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41696 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41697 return SWIG_Py_Void();
41698 }
41699
41700 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41701 return SWIG_Python_InitShadowInstance(args);
41702 }
41703
41704 SWIGINTERN int DefaultValidator_set(PyObject *) {
41705 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41706 return 1;
41707 }
41708
41709
41710 SWIGINTERN PyObject *DefaultValidator_get(void) {
41711 PyObject *pyobj = 0;
41712
41713 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41714 return pyobj;
41715 }
41716
41717
41718 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41719 PyObject *resultobj = 0;
41720 wxString const &arg1_defvalue = wxPyEmptyString ;
41721 wxString *arg1 = (wxString *) &arg1_defvalue ;
41722 long arg2 = (long) 0 ;
41723 wxMenu *result = 0 ;
41724 bool temp1 = false ;
41725 long val2 ;
41726 int ecode2 = 0 ;
41727 PyObject * obj0 = 0 ;
41728 PyObject * obj1 = 0 ;
41729 char * kwnames[] = {
41730 (char *) "title",(char *) "style", NULL
41731 };
41732
41733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41734 if (obj0) {
41735 {
41736 arg1 = wxString_in_helper(obj0);
41737 if (arg1 == NULL) SWIG_fail;
41738 temp1 = true;
41739 }
41740 }
41741 if (obj1) {
41742 ecode2 = SWIG_AsVal_long(obj1, &val2);
41743 if (!SWIG_IsOK(ecode2)) {
41744 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41745 }
41746 arg2 = static_cast< long >(val2);
41747 }
41748 {
41749 if (!wxPyCheckForApp()) SWIG_fail;
41750 PyThreadState* __tstate = wxPyBeginAllowThreads();
41751 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41752 wxPyEndAllowThreads(__tstate);
41753 if (PyErr_Occurred()) SWIG_fail;
41754 }
41755 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41756 {
41757 if (temp1)
41758 delete arg1;
41759 }
41760 return resultobj;
41761 fail:
41762 {
41763 if (temp1)
41764 delete arg1;
41765 }
41766 return NULL;
41767 }
41768
41769
41770 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41771 PyObject *resultobj = 0;
41772 wxMenu *arg1 = (wxMenu *) 0 ;
41773 int arg2 ;
41774 wxString const &arg3_defvalue = wxPyEmptyString ;
41775 wxString *arg3 = (wxString *) &arg3_defvalue ;
41776 wxString const &arg4_defvalue = wxPyEmptyString ;
41777 wxString *arg4 = (wxString *) &arg4_defvalue ;
41778 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41779 wxMenuItem *result = 0 ;
41780 void *argp1 = 0 ;
41781 int res1 = 0 ;
41782 int val2 ;
41783 int ecode2 = 0 ;
41784 bool temp3 = false ;
41785 bool temp4 = false ;
41786 int val5 ;
41787 int ecode5 = 0 ;
41788 PyObject * obj0 = 0 ;
41789 PyObject * obj1 = 0 ;
41790 PyObject * obj2 = 0 ;
41791 PyObject * obj3 = 0 ;
41792 PyObject * obj4 = 0 ;
41793 char * kwnames[] = {
41794 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41795 };
41796
41797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41799 if (!SWIG_IsOK(res1)) {
41800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41801 }
41802 arg1 = reinterpret_cast< wxMenu * >(argp1);
41803 ecode2 = SWIG_AsVal_int(obj1, &val2);
41804 if (!SWIG_IsOK(ecode2)) {
41805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41806 }
41807 arg2 = static_cast< int >(val2);
41808 if (obj2) {
41809 {
41810 arg3 = wxString_in_helper(obj2);
41811 if (arg3 == NULL) SWIG_fail;
41812 temp3 = true;
41813 }
41814 }
41815 if (obj3) {
41816 {
41817 arg4 = wxString_in_helper(obj3);
41818 if (arg4 == NULL) SWIG_fail;
41819 temp4 = true;
41820 }
41821 }
41822 if (obj4) {
41823 ecode5 = SWIG_AsVal_int(obj4, &val5);
41824 if (!SWIG_IsOK(ecode5)) {
41825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41826 }
41827 arg5 = static_cast< wxItemKind >(val5);
41828 }
41829 {
41830 PyThreadState* __tstate = wxPyBeginAllowThreads();
41831 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41832 wxPyEndAllowThreads(__tstate);
41833 if (PyErr_Occurred()) SWIG_fail;
41834 }
41835 {
41836 resultobj = wxPyMake_wxObject(result, (bool)0);
41837 }
41838 {
41839 if (temp3)
41840 delete arg3;
41841 }
41842 {
41843 if (temp4)
41844 delete arg4;
41845 }
41846 return resultobj;
41847 fail:
41848 {
41849 if (temp3)
41850 delete arg3;
41851 }
41852 {
41853 if (temp4)
41854 delete arg4;
41855 }
41856 return NULL;
41857 }
41858
41859
41860 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41861 PyObject *resultobj = 0;
41862 wxMenu *arg1 = (wxMenu *) 0 ;
41863 wxMenuItem *result = 0 ;
41864 void *argp1 = 0 ;
41865 int res1 = 0 ;
41866 PyObject *swig_obj[1] ;
41867
41868 if (!args) SWIG_fail;
41869 swig_obj[0] = args;
41870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41871 if (!SWIG_IsOK(res1)) {
41872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41873 }
41874 arg1 = reinterpret_cast< wxMenu * >(argp1);
41875 {
41876 PyThreadState* __tstate = wxPyBeginAllowThreads();
41877 result = (wxMenuItem *)(arg1)->AppendSeparator();
41878 wxPyEndAllowThreads(__tstate);
41879 if (PyErr_Occurred()) SWIG_fail;
41880 }
41881 {
41882 resultobj = wxPyMake_wxObject(result, (bool)0);
41883 }
41884 return resultobj;
41885 fail:
41886 return NULL;
41887 }
41888
41889
41890 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41891 PyObject *resultobj = 0;
41892 wxMenu *arg1 = (wxMenu *) 0 ;
41893 int arg2 ;
41894 wxString *arg3 = 0 ;
41895 wxString const &arg4_defvalue = wxPyEmptyString ;
41896 wxString *arg4 = (wxString *) &arg4_defvalue ;
41897 wxMenuItem *result = 0 ;
41898 void *argp1 = 0 ;
41899 int res1 = 0 ;
41900 int val2 ;
41901 int ecode2 = 0 ;
41902 bool temp3 = false ;
41903 bool temp4 = false ;
41904 PyObject * obj0 = 0 ;
41905 PyObject * obj1 = 0 ;
41906 PyObject * obj2 = 0 ;
41907 PyObject * obj3 = 0 ;
41908 char * kwnames[] = {
41909 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41910 };
41911
41912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41914 if (!SWIG_IsOK(res1)) {
41915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41916 }
41917 arg1 = reinterpret_cast< wxMenu * >(argp1);
41918 ecode2 = SWIG_AsVal_int(obj1, &val2);
41919 if (!SWIG_IsOK(ecode2)) {
41920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41921 }
41922 arg2 = static_cast< int >(val2);
41923 {
41924 arg3 = wxString_in_helper(obj2);
41925 if (arg3 == NULL) SWIG_fail;
41926 temp3 = true;
41927 }
41928 if (obj3) {
41929 {
41930 arg4 = wxString_in_helper(obj3);
41931 if (arg4 == NULL) SWIG_fail;
41932 temp4 = true;
41933 }
41934 }
41935 {
41936 PyThreadState* __tstate = wxPyBeginAllowThreads();
41937 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41938 wxPyEndAllowThreads(__tstate);
41939 if (PyErr_Occurred()) SWIG_fail;
41940 }
41941 {
41942 resultobj = wxPyMake_wxObject(result, (bool)0);
41943 }
41944 {
41945 if (temp3)
41946 delete arg3;
41947 }
41948 {
41949 if (temp4)
41950 delete arg4;
41951 }
41952 return resultobj;
41953 fail:
41954 {
41955 if (temp3)
41956 delete arg3;
41957 }
41958 {
41959 if (temp4)
41960 delete arg4;
41961 }
41962 return NULL;
41963 }
41964
41965
41966 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41967 PyObject *resultobj = 0;
41968 wxMenu *arg1 = (wxMenu *) 0 ;
41969 int arg2 ;
41970 wxString *arg3 = 0 ;
41971 wxString const &arg4_defvalue = wxPyEmptyString ;
41972 wxString *arg4 = (wxString *) &arg4_defvalue ;
41973 wxMenuItem *result = 0 ;
41974 void *argp1 = 0 ;
41975 int res1 = 0 ;
41976 int val2 ;
41977 int ecode2 = 0 ;
41978 bool temp3 = false ;
41979 bool temp4 = false ;
41980 PyObject * obj0 = 0 ;
41981 PyObject * obj1 = 0 ;
41982 PyObject * obj2 = 0 ;
41983 PyObject * obj3 = 0 ;
41984 char * kwnames[] = {
41985 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41986 };
41987
41988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41990 if (!SWIG_IsOK(res1)) {
41991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41992 }
41993 arg1 = reinterpret_cast< wxMenu * >(argp1);
41994 ecode2 = SWIG_AsVal_int(obj1, &val2);
41995 if (!SWIG_IsOK(ecode2)) {
41996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41997 }
41998 arg2 = static_cast< int >(val2);
41999 {
42000 arg3 = wxString_in_helper(obj2);
42001 if (arg3 == NULL) SWIG_fail;
42002 temp3 = true;
42003 }
42004 if (obj3) {
42005 {
42006 arg4 = wxString_in_helper(obj3);
42007 if (arg4 == NULL) SWIG_fail;
42008 temp4 = true;
42009 }
42010 }
42011 {
42012 PyThreadState* __tstate = wxPyBeginAllowThreads();
42013 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42014 wxPyEndAllowThreads(__tstate);
42015 if (PyErr_Occurred()) SWIG_fail;
42016 }
42017 {
42018 resultobj = wxPyMake_wxObject(result, (bool)0);
42019 }
42020 {
42021 if (temp3)
42022 delete arg3;
42023 }
42024 {
42025 if (temp4)
42026 delete arg4;
42027 }
42028 return resultobj;
42029 fail:
42030 {
42031 if (temp3)
42032 delete arg3;
42033 }
42034 {
42035 if (temp4)
42036 delete arg4;
42037 }
42038 return NULL;
42039 }
42040
42041
42042 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42043 PyObject *resultobj = 0;
42044 wxMenu *arg1 = (wxMenu *) 0 ;
42045 int arg2 ;
42046 wxString *arg3 = 0 ;
42047 wxMenu *arg4 = (wxMenu *) 0 ;
42048 wxString const &arg5_defvalue = wxPyEmptyString ;
42049 wxString *arg5 = (wxString *) &arg5_defvalue ;
42050 wxMenuItem *result = 0 ;
42051 void *argp1 = 0 ;
42052 int res1 = 0 ;
42053 int val2 ;
42054 int ecode2 = 0 ;
42055 bool temp3 = false ;
42056 void *argp4 = 0 ;
42057 int res4 = 0 ;
42058 bool temp5 = false ;
42059 PyObject * obj0 = 0 ;
42060 PyObject * obj1 = 0 ;
42061 PyObject * obj2 = 0 ;
42062 PyObject * obj3 = 0 ;
42063 PyObject * obj4 = 0 ;
42064 char * kwnames[] = {
42065 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42066 };
42067
42068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42070 if (!SWIG_IsOK(res1)) {
42071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42072 }
42073 arg1 = reinterpret_cast< wxMenu * >(argp1);
42074 ecode2 = SWIG_AsVal_int(obj1, &val2);
42075 if (!SWIG_IsOK(ecode2)) {
42076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42077 }
42078 arg2 = static_cast< int >(val2);
42079 {
42080 arg3 = wxString_in_helper(obj2);
42081 if (arg3 == NULL) SWIG_fail;
42082 temp3 = true;
42083 }
42084 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42085 if (!SWIG_IsOK(res4)) {
42086 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42087 }
42088 arg4 = reinterpret_cast< wxMenu * >(argp4);
42089 if (obj4) {
42090 {
42091 arg5 = wxString_in_helper(obj4);
42092 if (arg5 == NULL) SWIG_fail;
42093 temp5 = true;
42094 }
42095 }
42096 {
42097 PyThreadState* __tstate = wxPyBeginAllowThreads();
42098 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42099 wxPyEndAllowThreads(__tstate);
42100 if (PyErr_Occurred()) SWIG_fail;
42101 }
42102 {
42103 resultobj = wxPyMake_wxObject(result, (bool)0);
42104 }
42105 {
42106 if (temp3)
42107 delete arg3;
42108 }
42109 {
42110 if (temp5)
42111 delete arg5;
42112 }
42113 return resultobj;
42114 fail:
42115 {
42116 if (temp3)
42117 delete arg3;
42118 }
42119 {
42120 if (temp5)
42121 delete arg5;
42122 }
42123 return NULL;
42124 }
42125
42126
42127 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42128 PyObject *resultobj = 0;
42129 wxMenu *arg1 = (wxMenu *) 0 ;
42130 wxMenu *arg2 = (wxMenu *) 0 ;
42131 wxString *arg3 = 0 ;
42132 wxString const &arg4_defvalue = wxPyEmptyString ;
42133 wxString *arg4 = (wxString *) &arg4_defvalue ;
42134 wxMenuItem *result = 0 ;
42135 void *argp1 = 0 ;
42136 int res1 = 0 ;
42137 void *argp2 = 0 ;
42138 int res2 = 0 ;
42139 bool temp3 = false ;
42140 bool temp4 = false ;
42141 PyObject * obj0 = 0 ;
42142 PyObject * obj1 = 0 ;
42143 PyObject * obj2 = 0 ;
42144 PyObject * obj3 = 0 ;
42145 char * kwnames[] = {
42146 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42147 };
42148
42149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42151 if (!SWIG_IsOK(res1)) {
42152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42153 }
42154 arg1 = reinterpret_cast< wxMenu * >(argp1);
42155 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42156 if (!SWIG_IsOK(res2)) {
42157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42158 }
42159 arg2 = reinterpret_cast< wxMenu * >(argp2);
42160 {
42161 arg3 = wxString_in_helper(obj2);
42162 if (arg3 == NULL) SWIG_fail;
42163 temp3 = true;
42164 }
42165 if (obj3) {
42166 {
42167 arg4 = wxString_in_helper(obj3);
42168 if (arg4 == NULL) SWIG_fail;
42169 temp4 = true;
42170 }
42171 }
42172 {
42173 PyThreadState* __tstate = wxPyBeginAllowThreads();
42174 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42175 wxPyEndAllowThreads(__tstate);
42176 if (PyErr_Occurred()) SWIG_fail;
42177 }
42178 {
42179 resultobj = wxPyMake_wxObject(result, (bool)0);
42180 }
42181 {
42182 if (temp3)
42183 delete arg3;
42184 }
42185 {
42186 if (temp4)
42187 delete arg4;
42188 }
42189 return resultobj;
42190 fail:
42191 {
42192 if (temp3)
42193 delete arg3;
42194 }
42195 {
42196 if (temp4)
42197 delete arg4;
42198 }
42199 return NULL;
42200 }
42201
42202
42203 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42204 PyObject *resultobj = 0;
42205 wxMenu *arg1 = (wxMenu *) 0 ;
42206 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42207 wxMenuItem *result = 0 ;
42208 void *argp1 = 0 ;
42209 int res1 = 0 ;
42210 int res2 = 0 ;
42211 PyObject * obj0 = 0 ;
42212 PyObject * obj1 = 0 ;
42213 char * kwnames[] = {
42214 (char *) "self",(char *) "item", NULL
42215 };
42216
42217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42219 if (!SWIG_IsOK(res1)) {
42220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42221 }
42222 arg1 = reinterpret_cast< wxMenu * >(argp1);
42223 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42224 if (!SWIG_IsOK(res2)) {
42225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42226 }
42227 {
42228 PyThreadState* __tstate = wxPyBeginAllowThreads();
42229 result = (wxMenuItem *)(arg1)->Append(arg2);
42230 wxPyEndAllowThreads(__tstate);
42231 if (PyErr_Occurred()) SWIG_fail;
42232 }
42233 {
42234 resultobj = wxPyMake_wxObject(result, (bool)0);
42235 }
42236 return resultobj;
42237 fail:
42238 return NULL;
42239 }
42240
42241
42242 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42243 PyObject *resultobj = 0;
42244 wxMenu *arg1 = (wxMenu *) 0 ;
42245 size_t arg2 ;
42246 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42247 wxMenuItem *result = 0 ;
42248 void *argp1 = 0 ;
42249 int res1 = 0 ;
42250 size_t val2 ;
42251 int ecode2 = 0 ;
42252 int res3 = 0 ;
42253 PyObject * obj0 = 0 ;
42254 PyObject * obj1 = 0 ;
42255 PyObject * obj2 = 0 ;
42256 char * kwnames[] = {
42257 (char *) "self",(char *) "pos",(char *) "item", NULL
42258 };
42259
42260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42262 if (!SWIG_IsOK(res1)) {
42263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42264 }
42265 arg1 = reinterpret_cast< wxMenu * >(argp1);
42266 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42267 if (!SWIG_IsOK(ecode2)) {
42268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42269 }
42270 arg2 = static_cast< size_t >(val2);
42271 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42272 if (!SWIG_IsOK(res3)) {
42273 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42274 }
42275 {
42276 PyThreadState* __tstate = wxPyBeginAllowThreads();
42277 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42278 wxPyEndAllowThreads(__tstate);
42279 if (PyErr_Occurred()) SWIG_fail;
42280 }
42281 {
42282 resultobj = wxPyMake_wxObject(result, (bool)0);
42283 }
42284 return resultobj;
42285 fail:
42286 return NULL;
42287 }
42288
42289
42290 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42291 PyObject *resultobj = 0;
42292 wxMenu *arg1 = (wxMenu *) 0 ;
42293 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42294 wxMenuItem *result = 0 ;
42295 void *argp1 = 0 ;
42296 int res1 = 0 ;
42297 int res2 = 0 ;
42298 PyObject * obj0 = 0 ;
42299 PyObject * obj1 = 0 ;
42300 char * kwnames[] = {
42301 (char *) "self",(char *) "item", NULL
42302 };
42303
42304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42306 if (!SWIG_IsOK(res1)) {
42307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42308 }
42309 arg1 = reinterpret_cast< wxMenu * >(argp1);
42310 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42311 if (!SWIG_IsOK(res2)) {
42312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42313 }
42314 {
42315 PyThreadState* __tstate = wxPyBeginAllowThreads();
42316 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42317 wxPyEndAllowThreads(__tstate);
42318 if (PyErr_Occurred()) SWIG_fail;
42319 }
42320 {
42321 resultobj = wxPyMake_wxObject(result, (bool)0);
42322 }
42323 return resultobj;
42324 fail:
42325 return NULL;
42326 }
42327
42328
42329 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42330 PyObject *resultobj = 0;
42331 wxMenu *arg1 = (wxMenu *) 0 ;
42332 void *argp1 = 0 ;
42333 int res1 = 0 ;
42334 PyObject *swig_obj[1] ;
42335
42336 if (!args) SWIG_fail;
42337 swig_obj[0] = args;
42338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42339 if (!SWIG_IsOK(res1)) {
42340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42341 }
42342 arg1 = reinterpret_cast< wxMenu * >(argp1);
42343 {
42344 PyThreadState* __tstate = wxPyBeginAllowThreads();
42345 (arg1)->Break();
42346 wxPyEndAllowThreads(__tstate);
42347 if (PyErr_Occurred()) SWIG_fail;
42348 }
42349 resultobj = SWIG_Py_Void();
42350 return resultobj;
42351 fail:
42352 return NULL;
42353 }
42354
42355
42356 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42357 PyObject *resultobj = 0;
42358 wxMenu *arg1 = (wxMenu *) 0 ;
42359 size_t arg2 ;
42360 int arg3 ;
42361 wxString const &arg4_defvalue = wxPyEmptyString ;
42362 wxString *arg4 = (wxString *) &arg4_defvalue ;
42363 wxString const &arg5_defvalue = wxPyEmptyString ;
42364 wxString *arg5 = (wxString *) &arg5_defvalue ;
42365 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42366 wxMenuItem *result = 0 ;
42367 void *argp1 = 0 ;
42368 int res1 = 0 ;
42369 size_t val2 ;
42370 int ecode2 = 0 ;
42371 int val3 ;
42372 int ecode3 = 0 ;
42373 bool temp4 = false ;
42374 bool temp5 = false ;
42375 int val6 ;
42376 int ecode6 = 0 ;
42377 PyObject * obj0 = 0 ;
42378 PyObject * obj1 = 0 ;
42379 PyObject * obj2 = 0 ;
42380 PyObject * obj3 = 0 ;
42381 PyObject * obj4 = 0 ;
42382 PyObject * obj5 = 0 ;
42383 char * kwnames[] = {
42384 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42385 };
42386
42387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42389 if (!SWIG_IsOK(res1)) {
42390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42391 }
42392 arg1 = reinterpret_cast< wxMenu * >(argp1);
42393 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42394 if (!SWIG_IsOK(ecode2)) {
42395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42396 }
42397 arg2 = static_cast< size_t >(val2);
42398 ecode3 = SWIG_AsVal_int(obj2, &val3);
42399 if (!SWIG_IsOK(ecode3)) {
42400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42401 }
42402 arg3 = static_cast< int >(val3);
42403 if (obj3) {
42404 {
42405 arg4 = wxString_in_helper(obj3);
42406 if (arg4 == NULL) SWIG_fail;
42407 temp4 = true;
42408 }
42409 }
42410 if (obj4) {
42411 {
42412 arg5 = wxString_in_helper(obj4);
42413 if (arg5 == NULL) SWIG_fail;
42414 temp5 = true;
42415 }
42416 }
42417 if (obj5) {
42418 ecode6 = SWIG_AsVal_int(obj5, &val6);
42419 if (!SWIG_IsOK(ecode6)) {
42420 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42421 }
42422 arg6 = static_cast< wxItemKind >(val6);
42423 }
42424 {
42425 PyThreadState* __tstate = wxPyBeginAllowThreads();
42426 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42427 wxPyEndAllowThreads(__tstate);
42428 if (PyErr_Occurred()) SWIG_fail;
42429 }
42430 {
42431 resultobj = wxPyMake_wxObject(result, (bool)0);
42432 }
42433 {
42434 if (temp4)
42435 delete arg4;
42436 }
42437 {
42438 if (temp5)
42439 delete arg5;
42440 }
42441 return resultobj;
42442 fail:
42443 {
42444 if (temp4)
42445 delete arg4;
42446 }
42447 {
42448 if (temp5)
42449 delete arg5;
42450 }
42451 return NULL;
42452 }
42453
42454
42455 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42456 PyObject *resultobj = 0;
42457 wxMenu *arg1 = (wxMenu *) 0 ;
42458 size_t arg2 ;
42459 wxMenuItem *result = 0 ;
42460 void *argp1 = 0 ;
42461 int res1 = 0 ;
42462 size_t val2 ;
42463 int ecode2 = 0 ;
42464 PyObject * obj0 = 0 ;
42465 PyObject * obj1 = 0 ;
42466 char * kwnames[] = {
42467 (char *) "self",(char *) "pos", NULL
42468 };
42469
42470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42472 if (!SWIG_IsOK(res1)) {
42473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42474 }
42475 arg1 = reinterpret_cast< wxMenu * >(argp1);
42476 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42477 if (!SWIG_IsOK(ecode2)) {
42478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42479 }
42480 arg2 = static_cast< size_t >(val2);
42481 {
42482 PyThreadState* __tstate = wxPyBeginAllowThreads();
42483 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42484 wxPyEndAllowThreads(__tstate);
42485 if (PyErr_Occurred()) SWIG_fail;
42486 }
42487 {
42488 resultobj = wxPyMake_wxObject(result, (bool)0);
42489 }
42490 return resultobj;
42491 fail:
42492 return NULL;
42493 }
42494
42495
42496 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42497 PyObject *resultobj = 0;
42498 wxMenu *arg1 = (wxMenu *) 0 ;
42499 size_t arg2 ;
42500 int arg3 ;
42501 wxString *arg4 = 0 ;
42502 wxString const &arg5_defvalue = wxPyEmptyString ;
42503 wxString *arg5 = (wxString *) &arg5_defvalue ;
42504 wxMenuItem *result = 0 ;
42505 void *argp1 = 0 ;
42506 int res1 = 0 ;
42507 size_t val2 ;
42508 int ecode2 = 0 ;
42509 int val3 ;
42510 int ecode3 = 0 ;
42511 bool temp4 = false ;
42512 bool temp5 = false ;
42513 PyObject * obj0 = 0 ;
42514 PyObject * obj1 = 0 ;
42515 PyObject * obj2 = 0 ;
42516 PyObject * obj3 = 0 ;
42517 PyObject * obj4 = 0 ;
42518 char * kwnames[] = {
42519 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42520 };
42521
42522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42524 if (!SWIG_IsOK(res1)) {
42525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42526 }
42527 arg1 = reinterpret_cast< wxMenu * >(argp1);
42528 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42529 if (!SWIG_IsOK(ecode2)) {
42530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42531 }
42532 arg2 = static_cast< size_t >(val2);
42533 ecode3 = SWIG_AsVal_int(obj2, &val3);
42534 if (!SWIG_IsOK(ecode3)) {
42535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42536 }
42537 arg3 = static_cast< int >(val3);
42538 {
42539 arg4 = wxString_in_helper(obj3);
42540 if (arg4 == NULL) SWIG_fail;
42541 temp4 = true;
42542 }
42543 if (obj4) {
42544 {
42545 arg5 = wxString_in_helper(obj4);
42546 if (arg5 == NULL) SWIG_fail;
42547 temp5 = true;
42548 }
42549 }
42550 {
42551 PyThreadState* __tstate = wxPyBeginAllowThreads();
42552 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42553 wxPyEndAllowThreads(__tstate);
42554 if (PyErr_Occurred()) SWIG_fail;
42555 }
42556 {
42557 resultobj = wxPyMake_wxObject(result, (bool)0);
42558 }
42559 {
42560 if (temp4)
42561 delete arg4;
42562 }
42563 {
42564 if (temp5)
42565 delete arg5;
42566 }
42567 return resultobj;
42568 fail:
42569 {
42570 if (temp4)
42571 delete arg4;
42572 }
42573 {
42574 if (temp5)
42575 delete arg5;
42576 }
42577 return NULL;
42578 }
42579
42580
42581 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42582 PyObject *resultobj = 0;
42583 wxMenu *arg1 = (wxMenu *) 0 ;
42584 size_t arg2 ;
42585 int arg3 ;
42586 wxString *arg4 = 0 ;
42587 wxString const &arg5_defvalue = wxPyEmptyString ;
42588 wxString *arg5 = (wxString *) &arg5_defvalue ;
42589 wxMenuItem *result = 0 ;
42590 void *argp1 = 0 ;
42591 int res1 = 0 ;
42592 size_t val2 ;
42593 int ecode2 = 0 ;
42594 int val3 ;
42595 int ecode3 = 0 ;
42596 bool temp4 = false ;
42597 bool temp5 = false ;
42598 PyObject * obj0 = 0 ;
42599 PyObject * obj1 = 0 ;
42600 PyObject * obj2 = 0 ;
42601 PyObject * obj3 = 0 ;
42602 PyObject * obj4 = 0 ;
42603 char * kwnames[] = {
42604 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42605 };
42606
42607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42609 if (!SWIG_IsOK(res1)) {
42610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42611 }
42612 arg1 = reinterpret_cast< wxMenu * >(argp1);
42613 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42614 if (!SWIG_IsOK(ecode2)) {
42615 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42616 }
42617 arg2 = static_cast< size_t >(val2);
42618 ecode3 = SWIG_AsVal_int(obj2, &val3);
42619 if (!SWIG_IsOK(ecode3)) {
42620 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42621 }
42622 arg3 = static_cast< int >(val3);
42623 {
42624 arg4 = wxString_in_helper(obj3);
42625 if (arg4 == NULL) SWIG_fail;
42626 temp4 = true;
42627 }
42628 if (obj4) {
42629 {
42630 arg5 = wxString_in_helper(obj4);
42631 if (arg5 == NULL) SWIG_fail;
42632 temp5 = true;
42633 }
42634 }
42635 {
42636 PyThreadState* __tstate = wxPyBeginAllowThreads();
42637 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42638 wxPyEndAllowThreads(__tstate);
42639 if (PyErr_Occurred()) SWIG_fail;
42640 }
42641 {
42642 resultobj = wxPyMake_wxObject(result, (bool)0);
42643 }
42644 {
42645 if (temp4)
42646 delete arg4;
42647 }
42648 {
42649 if (temp5)
42650 delete arg5;
42651 }
42652 return resultobj;
42653 fail:
42654 {
42655 if (temp4)
42656 delete arg4;
42657 }
42658 {
42659 if (temp5)
42660 delete arg5;
42661 }
42662 return NULL;
42663 }
42664
42665
42666 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42667 PyObject *resultobj = 0;
42668 wxMenu *arg1 = (wxMenu *) 0 ;
42669 size_t arg2 ;
42670 int arg3 ;
42671 wxString *arg4 = 0 ;
42672 wxMenu *arg5 = (wxMenu *) 0 ;
42673 wxString const &arg6_defvalue = wxPyEmptyString ;
42674 wxString *arg6 = (wxString *) &arg6_defvalue ;
42675 wxMenuItem *result = 0 ;
42676 void *argp1 = 0 ;
42677 int res1 = 0 ;
42678 size_t val2 ;
42679 int ecode2 = 0 ;
42680 int val3 ;
42681 int ecode3 = 0 ;
42682 bool temp4 = false ;
42683 void *argp5 = 0 ;
42684 int res5 = 0 ;
42685 bool temp6 = false ;
42686 PyObject * obj0 = 0 ;
42687 PyObject * obj1 = 0 ;
42688 PyObject * obj2 = 0 ;
42689 PyObject * obj3 = 0 ;
42690 PyObject * obj4 = 0 ;
42691 PyObject * obj5 = 0 ;
42692 char * kwnames[] = {
42693 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42694 };
42695
42696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42698 if (!SWIG_IsOK(res1)) {
42699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42700 }
42701 arg1 = reinterpret_cast< wxMenu * >(argp1);
42702 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42703 if (!SWIG_IsOK(ecode2)) {
42704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42705 }
42706 arg2 = static_cast< size_t >(val2);
42707 ecode3 = SWIG_AsVal_int(obj2, &val3);
42708 if (!SWIG_IsOK(ecode3)) {
42709 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42710 }
42711 arg3 = static_cast< int >(val3);
42712 {
42713 arg4 = wxString_in_helper(obj3);
42714 if (arg4 == NULL) SWIG_fail;
42715 temp4 = true;
42716 }
42717 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42718 if (!SWIG_IsOK(res5)) {
42719 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42720 }
42721 arg5 = reinterpret_cast< wxMenu * >(argp5);
42722 if (obj5) {
42723 {
42724 arg6 = wxString_in_helper(obj5);
42725 if (arg6 == NULL) SWIG_fail;
42726 temp6 = true;
42727 }
42728 }
42729 {
42730 PyThreadState* __tstate = wxPyBeginAllowThreads();
42731 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42732 wxPyEndAllowThreads(__tstate);
42733 if (PyErr_Occurred()) SWIG_fail;
42734 }
42735 {
42736 resultobj = wxPyMake_wxObject(result, (bool)0);
42737 }
42738 {
42739 if (temp4)
42740 delete arg4;
42741 }
42742 {
42743 if (temp6)
42744 delete arg6;
42745 }
42746 return resultobj;
42747 fail:
42748 {
42749 if (temp4)
42750 delete arg4;
42751 }
42752 {
42753 if (temp6)
42754 delete arg6;
42755 }
42756 return NULL;
42757 }
42758
42759
42760 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42761 PyObject *resultobj = 0;
42762 wxMenu *arg1 = (wxMenu *) 0 ;
42763 int arg2 ;
42764 wxString const &arg3_defvalue = wxPyEmptyString ;
42765 wxString *arg3 = (wxString *) &arg3_defvalue ;
42766 wxString const &arg4_defvalue = wxPyEmptyString ;
42767 wxString *arg4 = (wxString *) &arg4_defvalue ;
42768 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42769 wxMenuItem *result = 0 ;
42770 void *argp1 = 0 ;
42771 int res1 = 0 ;
42772 int val2 ;
42773 int ecode2 = 0 ;
42774 bool temp3 = false ;
42775 bool temp4 = false ;
42776 int val5 ;
42777 int ecode5 = 0 ;
42778 PyObject * obj0 = 0 ;
42779 PyObject * obj1 = 0 ;
42780 PyObject * obj2 = 0 ;
42781 PyObject * obj3 = 0 ;
42782 PyObject * obj4 = 0 ;
42783 char * kwnames[] = {
42784 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42785 };
42786
42787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42789 if (!SWIG_IsOK(res1)) {
42790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42791 }
42792 arg1 = reinterpret_cast< wxMenu * >(argp1);
42793 ecode2 = SWIG_AsVal_int(obj1, &val2);
42794 if (!SWIG_IsOK(ecode2)) {
42795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42796 }
42797 arg2 = static_cast< int >(val2);
42798 if (obj2) {
42799 {
42800 arg3 = wxString_in_helper(obj2);
42801 if (arg3 == NULL) SWIG_fail;
42802 temp3 = true;
42803 }
42804 }
42805 if (obj3) {
42806 {
42807 arg4 = wxString_in_helper(obj3);
42808 if (arg4 == NULL) SWIG_fail;
42809 temp4 = true;
42810 }
42811 }
42812 if (obj4) {
42813 ecode5 = SWIG_AsVal_int(obj4, &val5);
42814 if (!SWIG_IsOK(ecode5)) {
42815 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42816 }
42817 arg5 = static_cast< wxItemKind >(val5);
42818 }
42819 {
42820 PyThreadState* __tstate = wxPyBeginAllowThreads();
42821 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42822 wxPyEndAllowThreads(__tstate);
42823 if (PyErr_Occurred()) SWIG_fail;
42824 }
42825 {
42826 resultobj = wxPyMake_wxObject(result, (bool)0);
42827 }
42828 {
42829 if (temp3)
42830 delete arg3;
42831 }
42832 {
42833 if (temp4)
42834 delete arg4;
42835 }
42836 return resultobj;
42837 fail:
42838 {
42839 if (temp3)
42840 delete arg3;
42841 }
42842 {
42843 if (temp4)
42844 delete arg4;
42845 }
42846 return NULL;
42847 }
42848
42849
42850 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42851 PyObject *resultobj = 0;
42852 wxMenu *arg1 = (wxMenu *) 0 ;
42853 wxMenuItem *result = 0 ;
42854 void *argp1 = 0 ;
42855 int res1 = 0 ;
42856 PyObject *swig_obj[1] ;
42857
42858 if (!args) SWIG_fail;
42859 swig_obj[0] = args;
42860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42861 if (!SWIG_IsOK(res1)) {
42862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42863 }
42864 arg1 = reinterpret_cast< wxMenu * >(argp1);
42865 {
42866 PyThreadState* __tstate = wxPyBeginAllowThreads();
42867 result = (wxMenuItem *)(arg1)->PrependSeparator();
42868 wxPyEndAllowThreads(__tstate);
42869 if (PyErr_Occurred()) SWIG_fail;
42870 }
42871 {
42872 resultobj = wxPyMake_wxObject(result, (bool)0);
42873 }
42874 return resultobj;
42875 fail:
42876 return NULL;
42877 }
42878
42879
42880 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42881 PyObject *resultobj = 0;
42882 wxMenu *arg1 = (wxMenu *) 0 ;
42883 int arg2 ;
42884 wxString *arg3 = 0 ;
42885 wxString const &arg4_defvalue = wxPyEmptyString ;
42886 wxString *arg4 = (wxString *) &arg4_defvalue ;
42887 wxMenuItem *result = 0 ;
42888 void *argp1 = 0 ;
42889 int res1 = 0 ;
42890 int val2 ;
42891 int ecode2 = 0 ;
42892 bool temp3 = false ;
42893 bool temp4 = false ;
42894 PyObject * obj0 = 0 ;
42895 PyObject * obj1 = 0 ;
42896 PyObject * obj2 = 0 ;
42897 PyObject * obj3 = 0 ;
42898 char * kwnames[] = {
42899 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42900 };
42901
42902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42904 if (!SWIG_IsOK(res1)) {
42905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42906 }
42907 arg1 = reinterpret_cast< wxMenu * >(argp1);
42908 ecode2 = SWIG_AsVal_int(obj1, &val2);
42909 if (!SWIG_IsOK(ecode2)) {
42910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42911 }
42912 arg2 = static_cast< int >(val2);
42913 {
42914 arg3 = wxString_in_helper(obj2);
42915 if (arg3 == NULL) SWIG_fail;
42916 temp3 = true;
42917 }
42918 if (obj3) {
42919 {
42920 arg4 = wxString_in_helper(obj3);
42921 if (arg4 == NULL) SWIG_fail;
42922 temp4 = true;
42923 }
42924 }
42925 {
42926 PyThreadState* __tstate = wxPyBeginAllowThreads();
42927 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42928 wxPyEndAllowThreads(__tstate);
42929 if (PyErr_Occurred()) SWIG_fail;
42930 }
42931 {
42932 resultobj = wxPyMake_wxObject(result, (bool)0);
42933 }
42934 {
42935 if (temp3)
42936 delete arg3;
42937 }
42938 {
42939 if (temp4)
42940 delete arg4;
42941 }
42942 return resultobj;
42943 fail:
42944 {
42945 if (temp3)
42946 delete arg3;
42947 }
42948 {
42949 if (temp4)
42950 delete arg4;
42951 }
42952 return NULL;
42953 }
42954
42955
42956 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42957 PyObject *resultobj = 0;
42958 wxMenu *arg1 = (wxMenu *) 0 ;
42959 int arg2 ;
42960 wxString *arg3 = 0 ;
42961 wxString const &arg4_defvalue = wxPyEmptyString ;
42962 wxString *arg4 = (wxString *) &arg4_defvalue ;
42963 wxMenuItem *result = 0 ;
42964 void *argp1 = 0 ;
42965 int res1 = 0 ;
42966 int val2 ;
42967 int ecode2 = 0 ;
42968 bool temp3 = false ;
42969 bool temp4 = false ;
42970 PyObject * obj0 = 0 ;
42971 PyObject * obj1 = 0 ;
42972 PyObject * obj2 = 0 ;
42973 PyObject * obj3 = 0 ;
42974 char * kwnames[] = {
42975 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42976 };
42977
42978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42980 if (!SWIG_IsOK(res1)) {
42981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42982 }
42983 arg1 = reinterpret_cast< wxMenu * >(argp1);
42984 ecode2 = SWIG_AsVal_int(obj1, &val2);
42985 if (!SWIG_IsOK(ecode2)) {
42986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42987 }
42988 arg2 = static_cast< int >(val2);
42989 {
42990 arg3 = wxString_in_helper(obj2);
42991 if (arg3 == NULL) SWIG_fail;
42992 temp3 = true;
42993 }
42994 if (obj3) {
42995 {
42996 arg4 = wxString_in_helper(obj3);
42997 if (arg4 == NULL) SWIG_fail;
42998 temp4 = true;
42999 }
43000 }
43001 {
43002 PyThreadState* __tstate = wxPyBeginAllowThreads();
43003 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43004 wxPyEndAllowThreads(__tstate);
43005 if (PyErr_Occurred()) SWIG_fail;
43006 }
43007 {
43008 resultobj = wxPyMake_wxObject(result, (bool)0);
43009 }
43010 {
43011 if (temp3)
43012 delete arg3;
43013 }
43014 {
43015 if (temp4)
43016 delete arg4;
43017 }
43018 return resultobj;
43019 fail:
43020 {
43021 if (temp3)
43022 delete arg3;
43023 }
43024 {
43025 if (temp4)
43026 delete arg4;
43027 }
43028 return NULL;
43029 }
43030
43031
43032 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43033 PyObject *resultobj = 0;
43034 wxMenu *arg1 = (wxMenu *) 0 ;
43035 int arg2 ;
43036 wxString *arg3 = 0 ;
43037 wxMenu *arg4 = (wxMenu *) 0 ;
43038 wxString const &arg5_defvalue = wxPyEmptyString ;
43039 wxString *arg5 = (wxString *) &arg5_defvalue ;
43040 wxMenuItem *result = 0 ;
43041 void *argp1 = 0 ;
43042 int res1 = 0 ;
43043 int val2 ;
43044 int ecode2 = 0 ;
43045 bool temp3 = false ;
43046 void *argp4 = 0 ;
43047 int res4 = 0 ;
43048 bool temp5 = false ;
43049 PyObject * obj0 = 0 ;
43050 PyObject * obj1 = 0 ;
43051 PyObject * obj2 = 0 ;
43052 PyObject * obj3 = 0 ;
43053 PyObject * obj4 = 0 ;
43054 char * kwnames[] = {
43055 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43056 };
43057
43058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43060 if (!SWIG_IsOK(res1)) {
43061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43062 }
43063 arg1 = reinterpret_cast< wxMenu * >(argp1);
43064 ecode2 = SWIG_AsVal_int(obj1, &val2);
43065 if (!SWIG_IsOK(ecode2)) {
43066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43067 }
43068 arg2 = static_cast< int >(val2);
43069 {
43070 arg3 = wxString_in_helper(obj2);
43071 if (arg3 == NULL) SWIG_fail;
43072 temp3 = true;
43073 }
43074 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43075 if (!SWIG_IsOK(res4)) {
43076 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43077 }
43078 arg4 = reinterpret_cast< wxMenu * >(argp4);
43079 if (obj4) {
43080 {
43081 arg5 = wxString_in_helper(obj4);
43082 if (arg5 == NULL) SWIG_fail;
43083 temp5 = true;
43084 }
43085 }
43086 {
43087 PyThreadState* __tstate = wxPyBeginAllowThreads();
43088 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43089 wxPyEndAllowThreads(__tstate);
43090 if (PyErr_Occurred()) SWIG_fail;
43091 }
43092 {
43093 resultobj = wxPyMake_wxObject(result, (bool)0);
43094 }
43095 {
43096 if (temp3)
43097 delete arg3;
43098 }
43099 {
43100 if (temp5)
43101 delete arg5;
43102 }
43103 return resultobj;
43104 fail:
43105 {
43106 if (temp3)
43107 delete arg3;
43108 }
43109 {
43110 if (temp5)
43111 delete arg5;
43112 }
43113 return NULL;
43114 }
43115
43116
43117 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43118 PyObject *resultobj = 0;
43119 wxMenu *arg1 = (wxMenu *) 0 ;
43120 int arg2 ;
43121 wxMenuItem *result = 0 ;
43122 void *argp1 = 0 ;
43123 int res1 = 0 ;
43124 int val2 ;
43125 int ecode2 = 0 ;
43126 PyObject * obj0 = 0 ;
43127 PyObject * obj1 = 0 ;
43128 char * kwnames[] = {
43129 (char *) "self",(char *) "id", NULL
43130 };
43131
43132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43134 if (!SWIG_IsOK(res1)) {
43135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43136 }
43137 arg1 = reinterpret_cast< wxMenu * >(argp1);
43138 ecode2 = SWIG_AsVal_int(obj1, &val2);
43139 if (!SWIG_IsOK(ecode2)) {
43140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43141 }
43142 arg2 = static_cast< int >(val2);
43143 {
43144 PyThreadState* __tstate = wxPyBeginAllowThreads();
43145 result = (wxMenuItem *)(arg1)->Remove(arg2);
43146 wxPyEndAllowThreads(__tstate);
43147 if (PyErr_Occurred()) SWIG_fail;
43148 }
43149 {
43150 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43151 }
43152 return resultobj;
43153 fail:
43154 return NULL;
43155 }
43156
43157
43158 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43159 PyObject *resultobj = 0;
43160 wxMenu *arg1 = (wxMenu *) 0 ;
43161 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43162 wxMenuItem *result = 0 ;
43163 void *argp1 = 0 ;
43164 int res1 = 0 ;
43165 void *argp2 = 0 ;
43166 int res2 = 0 ;
43167 PyObject * obj0 = 0 ;
43168 PyObject * obj1 = 0 ;
43169 char * kwnames[] = {
43170 (char *) "self",(char *) "item", NULL
43171 };
43172
43173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43175 if (!SWIG_IsOK(res1)) {
43176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43177 }
43178 arg1 = reinterpret_cast< wxMenu * >(argp1);
43179 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43180 if (!SWIG_IsOK(res2)) {
43181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43182 }
43183 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43184 {
43185 PyThreadState* __tstate = wxPyBeginAllowThreads();
43186 result = (wxMenuItem *)(arg1)->Remove(arg2);
43187 wxPyEndAllowThreads(__tstate);
43188 if (PyErr_Occurred()) SWIG_fail;
43189 }
43190 {
43191 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43192 }
43193 return resultobj;
43194 fail:
43195 return NULL;
43196 }
43197
43198
43199 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43200 PyObject *resultobj = 0;
43201 wxMenu *arg1 = (wxMenu *) 0 ;
43202 int arg2 ;
43203 bool result;
43204 void *argp1 = 0 ;
43205 int res1 = 0 ;
43206 int val2 ;
43207 int ecode2 = 0 ;
43208 PyObject * obj0 = 0 ;
43209 PyObject * obj1 = 0 ;
43210 char * kwnames[] = {
43211 (char *) "self",(char *) "id", NULL
43212 };
43213
43214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43216 if (!SWIG_IsOK(res1)) {
43217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43218 }
43219 arg1 = reinterpret_cast< wxMenu * >(argp1);
43220 ecode2 = SWIG_AsVal_int(obj1, &val2);
43221 if (!SWIG_IsOK(ecode2)) {
43222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43223 }
43224 arg2 = static_cast< int >(val2);
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 result = (bool)(arg1)->Delete(arg2);
43228 wxPyEndAllowThreads(__tstate);
43229 if (PyErr_Occurred()) SWIG_fail;
43230 }
43231 {
43232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43233 }
43234 return resultobj;
43235 fail:
43236 return NULL;
43237 }
43238
43239
43240 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43241 PyObject *resultobj = 0;
43242 wxMenu *arg1 = (wxMenu *) 0 ;
43243 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43244 bool result;
43245 void *argp1 = 0 ;
43246 int res1 = 0 ;
43247 void *argp2 = 0 ;
43248 int res2 = 0 ;
43249 PyObject * obj0 = 0 ;
43250 PyObject * obj1 = 0 ;
43251 char * kwnames[] = {
43252 (char *) "self",(char *) "item", NULL
43253 };
43254
43255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43257 if (!SWIG_IsOK(res1)) {
43258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43259 }
43260 arg1 = reinterpret_cast< wxMenu * >(argp1);
43261 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43262 if (!SWIG_IsOK(res2)) {
43263 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43264 }
43265 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43266 {
43267 PyThreadState* __tstate = wxPyBeginAllowThreads();
43268 result = (bool)(arg1)->Delete(arg2);
43269 wxPyEndAllowThreads(__tstate);
43270 if (PyErr_Occurred()) SWIG_fail;
43271 }
43272 {
43273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43274 }
43275 return resultobj;
43276 fail:
43277 return NULL;
43278 }
43279
43280
43281 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43282 PyObject *resultobj = 0;
43283 wxMenu *arg1 = (wxMenu *) 0 ;
43284 void *argp1 = 0 ;
43285 int res1 = 0 ;
43286 PyObject *swig_obj[1] ;
43287
43288 if (!args) SWIG_fail;
43289 swig_obj[0] = args;
43290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43291 if (!SWIG_IsOK(res1)) {
43292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43293 }
43294 arg1 = reinterpret_cast< wxMenu * >(argp1);
43295 {
43296 PyThreadState* __tstate = wxPyBeginAllowThreads();
43297 wxMenu_Destroy(arg1);
43298 wxPyEndAllowThreads(__tstate);
43299 if (PyErr_Occurred()) SWIG_fail;
43300 }
43301 resultobj = SWIG_Py_Void();
43302 return resultobj;
43303 fail:
43304 return NULL;
43305 }
43306
43307
43308 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43309 PyObject *resultobj = 0;
43310 wxMenu *arg1 = (wxMenu *) 0 ;
43311 int arg2 ;
43312 bool result;
43313 void *argp1 = 0 ;
43314 int res1 = 0 ;
43315 int val2 ;
43316 int ecode2 = 0 ;
43317 PyObject * obj0 = 0 ;
43318 PyObject * obj1 = 0 ;
43319 char * kwnames[] = {
43320 (char *) "self",(char *) "id", NULL
43321 };
43322
43323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) 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_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43327 }
43328 arg1 = reinterpret_cast< wxMenu * >(argp1);
43329 ecode2 = SWIG_AsVal_int(obj1, &val2);
43330 if (!SWIG_IsOK(ecode2)) {
43331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43332 }
43333 arg2 = static_cast< int >(val2);
43334 {
43335 PyThreadState* __tstate = wxPyBeginAllowThreads();
43336 result = (bool)(arg1)->Destroy(arg2);
43337 wxPyEndAllowThreads(__tstate);
43338 if (PyErr_Occurred()) SWIG_fail;
43339 }
43340 {
43341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43342 }
43343 return resultobj;
43344 fail:
43345 return NULL;
43346 }
43347
43348
43349 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43350 PyObject *resultobj = 0;
43351 wxMenu *arg1 = (wxMenu *) 0 ;
43352 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43353 bool result;
43354 void *argp1 = 0 ;
43355 int res1 = 0 ;
43356 void *argp2 = 0 ;
43357 int res2 = 0 ;
43358 PyObject * obj0 = 0 ;
43359 PyObject * obj1 = 0 ;
43360 char * kwnames[] = {
43361 (char *) "self",(char *) "item", NULL
43362 };
43363
43364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43366 if (!SWIG_IsOK(res1)) {
43367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43368 }
43369 arg1 = reinterpret_cast< wxMenu * >(argp1);
43370 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43371 if (!SWIG_IsOK(res2)) {
43372 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43373 }
43374 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 result = (bool)(arg1)->Destroy(arg2);
43378 wxPyEndAllowThreads(__tstate);
43379 if (PyErr_Occurred()) SWIG_fail;
43380 }
43381 {
43382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43383 }
43384 return resultobj;
43385 fail:
43386 return NULL;
43387 }
43388
43389
43390 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43391 PyObject *resultobj = 0;
43392 wxMenu *arg1 = (wxMenu *) 0 ;
43393 size_t result;
43394 void *argp1 = 0 ;
43395 int res1 = 0 ;
43396 PyObject *swig_obj[1] ;
43397
43398 if (!args) SWIG_fail;
43399 swig_obj[0] = args;
43400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43401 if (!SWIG_IsOK(res1)) {
43402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43403 }
43404 arg1 = reinterpret_cast< wxMenu * >(argp1);
43405 {
43406 PyThreadState* __tstate = wxPyBeginAllowThreads();
43407 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43408 wxPyEndAllowThreads(__tstate);
43409 if (PyErr_Occurred()) SWIG_fail;
43410 }
43411 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43412 return resultobj;
43413 fail:
43414 return NULL;
43415 }
43416
43417
43418 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43419 PyObject *resultobj = 0;
43420 wxMenu *arg1 = (wxMenu *) 0 ;
43421 PyObject *result = 0 ;
43422 void *argp1 = 0 ;
43423 int res1 = 0 ;
43424 PyObject *swig_obj[1] ;
43425
43426 if (!args) SWIG_fail;
43427 swig_obj[0] = args;
43428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43429 if (!SWIG_IsOK(res1)) {
43430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43431 }
43432 arg1 = reinterpret_cast< wxMenu * >(argp1);
43433 {
43434 PyThreadState* __tstate = wxPyBeginAllowThreads();
43435 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43436 wxPyEndAllowThreads(__tstate);
43437 if (PyErr_Occurred()) SWIG_fail;
43438 }
43439 resultobj = result;
43440 return resultobj;
43441 fail:
43442 return NULL;
43443 }
43444
43445
43446 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43447 PyObject *resultobj = 0;
43448 wxMenu *arg1 = (wxMenu *) 0 ;
43449 wxString *arg2 = 0 ;
43450 int result;
43451 void *argp1 = 0 ;
43452 int res1 = 0 ;
43453 bool temp2 = false ;
43454 PyObject * obj0 = 0 ;
43455 PyObject * obj1 = 0 ;
43456 char * kwnames[] = {
43457 (char *) "self",(char *) "item", NULL
43458 };
43459
43460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43462 if (!SWIG_IsOK(res1)) {
43463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43464 }
43465 arg1 = reinterpret_cast< wxMenu * >(argp1);
43466 {
43467 arg2 = wxString_in_helper(obj1);
43468 if (arg2 == NULL) SWIG_fail;
43469 temp2 = true;
43470 }
43471 {
43472 PyThreadState* __tstate = wxPyBeginAllowThreads();
43473 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43474 wxPyEndAllowThreads(__tstate);
43475 if (PyErr_Occurred()) SWIG_fail;
43476 }
43477 resultobj = SWIG_From_int(static_cast< int >(result));
43478 {
43479 if (temp2)
43480 delete arg2;
43481 }
43482 return resultobj;
43483 fail:
43484 {
43485 if (temp2)
43486 delete arg2;
43487 }
43488 return NULL;
43489 }
43490
43491
43492 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43493 PyObject *resultobj = 0;
43494 wxMenu *arg1 = (wxMenu *) 0 ;
43495 int arg2 ;
43496 wxMenuItem *result = 0 ;
43497 void *argp1 = 0 ;
43498 int res1 = 0 ;
43499 int val2 ;
43500 int ecode2 = 0 ;
43501 PyObject * obj0 = 0 ;
43502 PyObject * obj1 = 0 ;
43503 char * kwnames[] = {
43504 (char *) "self",(char *) "id", NULL
43505 };
43506
43507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43509 if (!SWIG_IsOK(res1)) {
43510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43511 }
43512 arg1 = reinterpret_cast< wxMenu * >(argp1);
43513 ecode2 = SWIG_AsVal_int(obj1, &val2);
43514 if (!SWIG_IsOK(ecode2)) {
43515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43516 }
43517 arg2 = static_cast< int >(val2);
43518 {
43519 PyThreadState* __tstate = wxPyBeginAllowThreads();
43520 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43521 wxPyEndAllowThreads(__tstate);
43522 if (PyErr_Occurred()) SWIG_fail;
43523 }
43524 {
43525 resultobj = wxPyMake_wxObject(result, (bool)0);
43526 }
43527 return resultobj;
43528 fail:
43529 return NULL;
43530 }
43531
43532
43533 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43534 PyObject *resultobj = 0;
43535 wxMenu *arg1 = (wxMenu *) 0 ;
43536 size_t arg2 ;
43537 wxMenuItem *result = 0 ;
43538 void *argp1 = 0 ;
43539 int res1 = 0 ;
43540 size_t val2 ;
43541 int ecode2 = 0 ;
43542 PyObject * obj0 = 0 ;
43543 PyObject * obj1 = 0 ;
43544 char * kwnames[] = {
43545 (char *) "self",(char *) "position", NULL
43546 };
43547
43548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43550 if (!SWIG_IsOK(res1)) {
43551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43552 }
43553 arg1 = reinterpret_cast< wxMenu * >(argp1);
43554 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43555 if (!SWIG_IsOK(ecode2)) {
43556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43557 }
43558 arg2 = static_cast< size_t >(val2);
43559 {
43560 PyThreadState* __tstate = wxPyBeginAllowThreads();
43561 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43562 wxPyEndAllowThreads(__tstate);
43563 if (PyErr_Occurred()) SWIG_fail;
43564 }
43565 {
43566 resultobj = wxPyMake_wxObject(result, (bool)0);
43567 }
43568 return resultobj;
43569 fail:
43570 return NULL;
43571 }
43572
43573
43574 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43575 PyObject *resultobj = 0;
43576 wxMenu *arg1 = (wxMenu *) 0 ;
43577 int arg2 ;
43578 bool arg3 ;
43579 void *argp1 = 0 ;
43580 int res1 = 0 ;
43581 int val2 ;
43582 int ecode2 = 0 ;
43583 bool val3 ;
43584 int ecode3 = 0 ;
43585 PyObject * obj0 = 0 ;
43586 PyObject * obj1 = 0 ;
43587 PyObject * obj2 = 0 ;
43588 char * kwnames[] = {
43589 (char *) "self",(char *) "id",(char *) "enable", NULL
43590 };
43591
43592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43594 if (!SWIG_IsOK(res1)) {
43595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43596 }
43597 arg1 = reinterpret_cast< wxMenu * >(argp1);
43598 ecode2 = SWIG_AsVal_int(obj1, &val2);
43599 if (!SWIG_IsOK(ecode2)) {
43600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43601 }
43602 arg2 = static_cast< int >(val2);
43603 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43604 if (!SWIG_IsOK(ecode3)) {
43605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43606 }
43607 arg3 = static_cast< bool >(val3);
43608 {
43609 PyThreadState* __tstate = wxPyBeginAllowThreads();
43610 (arg1)->Enable(arg2,arg3);
43611 wxPyEndAllowThreads(__tstate);
43612 if (PyErr_Occurred()) SWIG_fail;
43613 }
43614 resultobj = SWIG_Py_Void();
43615 return resultobj;
43616 fail:
43617 return NULL;
43618 }
43619
43620
43621 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43622 PyObject *resultobj = 0;
43623 wxMenu *arg1 = (wxMenu *) 0 ;
43624 int arg2 ;
43625 bool result;
43626 void *argp1 = 0 ;
43627 int res1 = 0 ;
43628 int val2 ;
43629 int ecode2 = 0 ;
43630 PyObject * obj0 = 0 ;
43631 PyObject * obj1 = 0 ;
43632 char * kwnames[] = {
43633 (char *) "self",(char *) "id", NULL
43634 };
43635
43636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43638 if (!SWIG_IsOK(res1)) {
43639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43640 }
43641 arg1 = reinterpret_cast< wxMenu * >(argp1);
43642 ecode2 = SWIG_AsVal_int(obj1, &val2);
43643 if (!SWIG_IsOK(ecode2)) {
43644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43645 }
43646 arg2 = static_cast< int >(val2);
43647 {
43648 PyThreadState* __tstate = wxPyBeginAllowThreads();
43649 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43650 wxPyEndAllowThreads(__tstate);
43651 if (PyErr_Occurred()) SWIG_fail;
43652 }
43653 {
43654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43655 }
43656 return resultobj;
43657 fail:
43658 return NULL;
43659 }
43660
43661
43662 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43663 PyObject *resultobj = 0;
43664 wxMenu *arg1 = (wxMenu *) 0 ;
43665 int arg2 ;
43666 bool arg3 ;
43667 void *argp1 = 0 ;
43668 int res1 = 0 ;
43669 int val2 ;
43670 int ecode2 = 0 ;
43671 bool val3 ;
43672 int ecode3 = 0 ;
43673 PyObject * obj0 = 0 ;
43674 PyObject * obj1 = 0 ;
43675 PyObject * obj2 = 0 ;
43676 char * kwnames[] = {
43677 (char *) "self",(char *) "id",(char *) "check", NULL
43678 };
43679
43680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43682 if (!SWIG_IsOK(res1)) {
43683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43684 }
43685 arg1 = reinterpret_cast< wxMenu * >(argp1);
43686 ecode2 = SWIG_AsVal_int(obj1, &val2);
43687 if (!SWIG_IsOK(ecode2)) {
43688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43689 }
43690 arg2 = static_cast< int >(val2);
43691 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43692 if (!SWIG_IsOK(ecode3)) {
43693 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43694 }
43695 arg3 = static_cast< bool >(val3);
43696 {
43697 PyThreadState* __tstate = wxPyBeginAllowThreads();
43698 (arg1)->Check(arg2,arg3);
43699 wxPyEndAllowThreads(__tstate);
43700 if (PyErr_Occurred()) SWIG_fail;
43701 }
43702 resultobj = SWIG_Py_Void();
43703 return resultobj;
43704 fail:
43705 return NULL;
43706 }
43707
43708
43709 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43710 PyObject *resultobj = 0;
43711 wxMenu *arg1 = (wxMenu *) 0 ;
43712 int arg2 ;
43713 bool result;
43714 void *argp1 = 0 ;
43715 int res1 = 0 ;
43716 int val2 ;
43717 int ecode2 = 0 ;
43718 PyObject * obj0 = 0 ;
43719 PyObject * obj1 = 0 ;
43720 char * kwnames[] = {
43721 (char *) "self",(char *) "id", NULL
43722 };
43723
43724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43726 if (!SWIG_IsOK(res1)) {
43727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43728 }
43729 arg1 = reinterpret_cast< wxMenu * >(argp1);
43730 ecode2 = SWIG_AsVal_int(obj1, &val2);
43731 if (!SWIG_IsOK(ecode2)) {
43732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43733 }
43734 arg2 = static_cast< int >(val2);
43735 {
43736 PyThreadState* __tstate = wxPyBeginAllowThreads();
43737 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43738 wxPyEndAllowThreads(__tstate);
43739 if (PyErr_Occurred()) SWIG_fail;
43740 }
43741 {
43742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43743 }
43744 return resultobj;
43745 fail:
43746 return NULL;
43747 }
43748
43749
43750 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43751 PyObject *resultobj = 0;
43752 wxMenu *arg1 = (wxMenu *) 0 ;
43753 int arg2 ;
43754 wxString *arg3 = 0 ;
43755 void *argp1 = 0 ;
43756 int res1 = 0 ;
43757 int val2 ;
43758 int ecode2 = 0 ;
43759 bool temp3 = false ;
43760 PyObject * obj0 = 0 ;
43761 PyObject * obj1 = 0 ;
43762 PyObject * obj2 = 0 ;
43763 char * kwnames[] = {
43764 (char *) "self",(char *) "id",(char *) "label", NULL
43765 };
43766
43767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43769 if (!SWIG_IsOK(res1)) {
43770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43771 }
43772 arg1 = reinterpret_cast< wxMenu * >(argp1);
43773 ecode2 = SWIG_AsVal_int(obj1, &val2);
43774 if (!SWIG_IsOK(ecode2)) {
43775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43776 }
43777 arg2 = static_cast< int >(val2);
43778 {
43779 arg3 = wxString_in_helper(obj2);
43780 if (arg3 == NULL) SWIG_fail;
43781 temp3 = true;
43782 }
43783 {
43784 PyThreadState* __tstate = wxPyBeginAllowThreads();
43785 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43786 wxPyEndAllowThreads(__tstate);
43787 if (PyErr_Occurred()) SWIG_fail;
43788 }
43789 resultobj = SWIG_Py_Void();
43790 {
43791 if (temp3)
43792 delete arg3;
43793 }
43794 return resultobj;
43795 fail:
43796 {
43797 if (temp3)
43798 delete arg3;
43799 }
43800 return NULL;
43801 }
43802
43803
43804 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43805 PyObject *resultobj = 0;
43806 wxMenu *arg1 = (wxMenu *) 0 ;
43807 int arg2 ;
43808 wxString result;
43809 void *argp1 = 0 ;
43810 int res1 = 0 ;
43811 int val2 ;
43812 int ecode2 = 0 ;
43813 PyObject * obj0 = 0 ;
43814 PyObject * obj1 = 0 ;
43815 char * kwnames[] = {
43816 (char *) "self",(char *) "id", NULL
43817 };
43818
43819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43821 if (!SWIG_IsOK(res1)) {
43822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43823 }
43824 arg1 = reinterpret_cast< wxMenu * >(argp1);
43825 ecode2 = SWIG_AsVal_int(obj1, &val2);
43826 if (!SWIG_IsOK(ecode2)) {
43827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43828 }
43829 arg2 = static_cast< int >(val2);
43830 {
43831 PyThreadState* __tstate = wxPyBeginAllowThreads();
43832 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43833 wxPyEndAllowThreads(__tstate);
43834 if (PyErr_Occurred()) SWIG_fail;
43835 }
43836 {
43837 #if wxUSE_UNICODE
43838 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43839 #else
43840 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43841 #endif
43842 }
43843 return resultobj;
43844 fail:
43845 return NULL;
43846 }
43847
43848
43849 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43850 PyObject *resultobj = 0;
43851 wxMenu *arg1 = (wxMenu *) 0 ;
43852 int arg2 ;
43853 wxString *arg3 = 0 ;
43854 void *argp1 = 0 ;
43855 int res1 = 0 ;
43856 int val2 ;
43857 int ecode2 = 0 ;
43858 bool temp3 = false ;
43859 PyObject * obj0 = 0 ;
43860 PyObject * obj1 = 0 ;
43861 PyObject * obj2 = 0 ;
43862 char * kwnames[] = {
43863 (char *) "self",(char *) "id",(char *) "helpString", NULL
43864 };
43865
43866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43868 if (!SWIG_IsOK(res1)) {
43869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43870 }
43871 arg1 = reinterpret_cast< wxMenu * >(argp1);
43872 ecode2 = SWIG_AsVal_int(obj1, &val2);
43873 if (!SWIG_IsOK(ecode2)) {
43874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43875 }
43876 arg2 = static_cast< int >(val2);
43877 {
43878 arg3 = wxString_in_helper(obj2);
43879 if (arg3 == NULL) SWIG_fail;
43880 temp3 = true;
43881 }
43882 {
43883 PyThreadState* __tstate = wxPyBeginAllowThreads();
43884 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43885 wxPyEndAllowThreads(__tstate);
43886 if (PyErr_Occurred()) SWIG_fail;
43887 }
43888 resultobj = SWIG_Py_Void();
43889 {
43890 if (temp3)
43891 delete arg3;
43892 }
43893 return resultobj;
43894 fail:
43895 {
43896 if (temp3)
43897 delete arg3;
43898 }
43899 return NULL;
43900 }
43901
43902
43903 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43904 PyObject *resultobj = 0;
43905 wxMenu *arg1 = (wxMenu *) 0 ;
43906 int arg2 ;
43907 wxString result;
43908 void *argp1 = 0 ;
43909 int res1 = 0 ;
43910 int val2 ;
43911 int ecode2 = 0 ;
43912 PyObject * obj0 = 0 ;
43913 PyObject * obj1 = 0 ;
43914 char * kwnames[] = {
43915 (char *) "self",(char *) "id", NULL
43916 };
43917
43918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43920 if (!SWIG_IsOK(res1)) {
43921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43922 }
43923 arg1 = reinterpret_cast< wxMenu * >(argp1);
43924 ecode2 = SWIG_AsVal_int(obj1, &val2);
43925 if (!SWIG_IsOK(ecode2)) {
43926 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43927 }
43928 arg2 = static_cast< int >(val2);
43929 {
43930 PyThreadState* __tstate = wxPyBeginAllowThreads();
43931 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43932 wxPyEndAllowThreads(__tstate);
43933 if (PyErr_Occurred()) SWIG_fail;
43934 }
43935 {
43936 #if wxUSE_UNICODE
43937 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43938 #else
43939 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43940 #endif
43941 }
43942 return resultobj;
43943 fail:
43944 return NULL;
43945 }
43946
43947
43948 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43949 PyObject *resultobj = 0;
43950 wxMenu *arg1 = (wxMenu *) 0 ;
43951 wxString *arg2 = 0 ;
43952 void *argp1 = 0 ;
43953 int res1 = 0 ;
43954 bool temp2 = false ;
43955 PyObject * obj0 = 0 ;
43956 PyObject * obj1 = 0 ;
43957 char * kwnames[] = {
43958 (char *) "self",(char *) "title", NULL
43959 };
43960
43961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43963 if (!SWIG_IsOK(res1)) {
43964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43965 }
43966 arg1 = reinterpret_cast< wxMenu * >(argp1);
43967 {
43968 arg2 = wxString_in_helper(obj1);
43969 if (arg2 == NULL) SWIG_fail;
43970 temp2 = true;
43971 }
43972 {
43973 PyThreadState* __tstate = wxPyBeginAllowThreads();
43974 (arg1)->SetTitle((wxString const &)*arg2);
43975 wxPyEndAllowThreads(__tstate);
43976 if (PyErr_Occurred()) SWIG_fail;
43977 }
43978 resultobj = SWIG_Py_Void();
43979 {
43980 if (temp2)
43981 delete arg2;
43982 }
43983 return resultobj;
43984 fail:
43985 {
43986 if (temp2)
43987 delete arg2;
43988 }
43989 return NULL;
43990 }
43991
43992
43993 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43994 PyObject *resultobj = 0;
43995 wxMenu *arg1 = (wxMenu *) 0 ;
43996 wxString result;
43997 void *argp1 = 0 ;
43998 int res1 = 0 ;
43999 PyObject *swig_obj[1] ;
44000
44001 if (!args) SWIG_fail;
44002 swig_obj[0] = args;
44003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44004 if (!SWIG_IsOK(res1)) {
44005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44006 }
44007 arg1 = reinterpret_cast< wxMenu * >(argp1);
44008 {
44009 PyThreadState* __tstate = wxPyBeginAllowThreads();
44010 result = ((wxMenu const *)arg1)->GetTitle();
44011 wxPyEndAllowThreads(__tstate);
44012 if (PyErr_Occurred()) SWIG_fail;
44013 }
44014 {
44015 #if wxUSE_UNICODE
44016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44017 #else
44018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44019 #endif
44020 }
44021 return resultobj;
44022 fail:
44023 return NULL;
44024 }
44025
44026
44027 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44028 PyObject *resultobj = 0;
44029 wxMenu *arg1 = (wxMenu *) 0 ;
44030 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44031 void *argp1 = 0 ;
44032 int res1 = 0 ;
44033 void *argp2 = 0 ;
44034 int res2 = 0 ;
44035 PyObject * obj0 = 0 ;
44036 PyObject * obj1 = 0 ;
44037 char * kwnames[] = {
44038 (char *) "self",(char *) "handler", NULL
44039 };
44040
44041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44043 if (!SWIG_IsOK(res1)) {
44044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44045 }
44046 arg1 = reinterpret_cast< wxMenu * >(argp1);
44047 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44048 if (!SWIG_IsOK(res2)) {
44049 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44050 }
44051 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44052 {
44053 PyThreadState* __tstate = wxPyBeginAllowThreads();
44054 (arg1)->SetEventHandler(arg2);
44055 wxPyEndAllowThreads(__tstate);
44056 if (PyErr_Occurred()) SWIG_fail;
44057 }
44058 resultobj = SWIG_Py_Void();
44059 return resultobj;
44060 fail:
44061 return NULL;
44062 }
44063
44064
44065 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44066 PyObject *resultobj = 0;
44067 wxMenu *arg1 = (wxMenu *) 0 ;
44068 wxEvtHandler *result = 0 ;
44069 void *argp1 = 0 ;
44070 int res1 = 0 ;
44071 PyObject *swig_obj[1] ;
44072
44073 if (!args) SWIG_fail;
44074 swig_obj[0] = args;
44075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44076 if (!SWIG_IsOK(res1)) {
44077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44078 }
44079 arg1 = reinterpret_cast< wxMenu * >(argp1);
44080 {
44081 PyThreadState* __tstate = wxPyBeginAllowThreads();
44082 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44083 wxPyEndAllowThreads(__tstate);
44084 if (PyErr_Occurred()) SWIG_fail;
44085 }
44086 {
44087 resultobj = wxPyMake_wxObject(result, 0);
44088 }
44089 return resultobj;
44090 fail:
44091 return NULL;
44092 }
44093
44094
44095 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44096 PyObject *resultobj = 0;
44097 wxMenu *arg1 = (wxMenu *) 0 ;
44098 wxWindow *arg2 = (wxWindow *) 0 ;
44099 void *argp1 = 0 ;
44100 int res1 = 0 ;
44101 void *argp2 = 0 ;
44102 int res2 = 0 ;
44103 PyObject * obj0 = 0 ;
44104 PyObject * obj1 = 0 ;
44105 char * kwnames[] = {
44106 (char *) "self",(char *) "win", NULL
44107 };
44108
44109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44111 if (!SWIG_IsOK(res1)) {
44112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44113 }
44114 arg1 = reinterpret_cast< wxMenu * >(argp1);
44115 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44116 if (!SWIG_IsOK(res2)) {
44117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44118 }
44119 arg2 = reinterpret_cast< wxWindow * >(argp2);
44120 {
44121 PyThreadState* __tstate = wxPyBeginAllowThreads();
44122 (arg1)->SetInvokingWindow(arg2);
44123 wxPyEndAllowThreads(__tstate);
44124 if (PyErr_Occurred()) SWIG_fail;
44125 }
44126 resultobj = SWIG_Py_Void();
44127 return resultobj;
44128 fail:
44129 return NULL;
44130 }
44131
44132
44133 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44134 PyObject *resultobj = 0;
44135 wxMenu *arg1 = (wxMenu *) 0 ;
44136 wxWindow *result = 0 ;
44137 void *argp1 = 0 ;
44138 int res1 = 0 ;
44139 PyObject *swig_obj[1] ;
44140
44141 if (!args) SWIG_fail;
44142 swig_obj[0] = args;
44143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44144 if (!SWIG_IsOK(res1)) {
44145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44146 }
44147 arg1 = reinterpret_cast< wxMenu * >(argp1);
44148 {
44149 PyThreadState* __tstate = wxPyBeginAllowThreads();
44150 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44151 wxPyEndAllowThreads(__tstate);
44152 if (PyErr_Occurred()) SWIG_fail;
44153 }
44154 {
44155 resultobj = wxPyMake_wxObject(result, 0);
44156 }
44157 return resultobj;
44158 fail:
44159 return NULL;
44160 }
44161
44162
44163 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44164 PyObject *resultobj = 0;
44165 wxMenu *arg1 = (wxMenu *) 0 ;
44166 long result;
44167 void *argp1 = 0 ;
44168 int res1 = 0 ;
44169 PyObject *swig_obj[1] ;
44170
44171 if (!args) SWIG_fail;
44172 swig_obj[0] = args;
44173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44174 if (!SWIG_IsOK(res1)) {
44175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44176 }
44177 arg1 = reinterpret_cast< wxMenu * >(argp1);
44178 {
44179 PyThreadState* __tstate = wxPyBeginAllowThreads();
44180 result = (long)((wxMenu const *)arg1)->GetStyle();
44181 wxPyEndAllowThreads(__tstate);
44182 if (PyErr_Occurred()) SWIG_fail;
44183 }
44184 resultobj = SWIG_From_long(static_cast< long >(result));
44185 return resultobj;
44186 fail:
44187 return NULL;
44188 }
44189
44190
44191 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44192 PyObject *resultobj = 0;
44193 wxMenu *arg1 = (wxMenu *) 0 ;
44194 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44195 void *argp1 = 0 ;
44196 int res1 = 0 ;
44197 void *argp2 = 0 ;
44198 int res2 = 0 ;
44199 PyObject * obj0 = 0 ;
44200 PyObject * obj1 = 0 ;
44201 char * kwnames[] = {
44202 (char *) "self",(char *) "source", NULL
44203 };
44204
44205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44207 if (!SWIG_IsOK(res1)) {
44208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44209 }
44210 arg1 = reinterpret_cast< wxMenu * >(argp1);
44211 if (obj1) {
44212 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44213 if (!SWIG_IsOK(res2)) {
44214 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44215 }
44216 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44217 }
44218 {
44219 PyThreadState* __tstate = wxPyBeginAllowThreads();
44220 (arg1)->UpdateUI(arg2);
44221 wxPyEndAllowThreads(__tstate);
44222 if (PyErr_Occurred()) SWIG_fail;
44223 }
44224 resultobj = SWIG_Py_Void();
44225 return resultobj;
44226 fail:
44227 return NULL;
44228 }
44229
44230
44231 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44232 PyObject *resultobj = 0;
44233 wxMenu *arg1 = (wxMenu *) 0 ;
44234 wxMenuBar *result = 0 ;
44235 void *argp1 = 0 ;
44236 int res1 = 0 ;
44237 PyObject *swig_obj[1] ;
44238
44239 if (!args) SWIG_fail;
44240 swig_obj[0] = args;
44241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44242 if (!SWIG_IsOK(res1)) {
44243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44244 }
44245 arg1 = reinterpret_cast< wxMenu * >(argp1);
44246 {
44247 PyThreadState* __tstate = wxPyBeginAllowThreads();
44248 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44249 wxPyEndAllowThreads(__tstate);
44250 if (PyErr_Occurred()) SWIG_fail;
44251 }
44252 {
44253 resultobj = wxPyMake_wxObject(result, (bool)0);
44254 }
44255 return resultobj;
44256 fail:
44257 return NULL;
44258 }
44259
44260
44261 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44262 PyObject *resultobj = 0;
44263 wxMenu *arg1 = (wxMenu *) 0 ;
44264 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44265 void *argp1 = 0 ;
44266 int res1 = 0 ;
44267 void *argp2 = 0 ;
44268 int res2 = 0 ;
44269 PyObject * obj0 = 0 ;
44270 PyObject * obj1 = 0 ;
44271 char * kwnames[] = {
44272 (char *) "self",(char *) "menubar", NULL
44273 };
44274
44275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44277 if (!SWIG_IsOK(res1)) {
44278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44279 }
44280 arg1 = reinterpret_cast< wxMenu * >(argp1);
44281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44282 if (!SWIG_IsOK(res2)) {
44283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44284 }
44285 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44286 {
44287 PyThreadState* __tstate = wxPyBeginAllowThreads();
44288 (arg1)->Attach(arg2);
44289 wxPyEndAllowThreads(__tstate);
44290 if (PyErr_Occurred()) SWIG_fail;
44291 }
44292 resultobj = SWIG_Py_Void();
44293 return resultobj;
44294 fail:
44295 return NULL;
44296 }
44297
44298
44299 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44300 PyObject *resultobj = 0;
44301 wxMenu *arg1 = (wxMenu *) 0 ;
44302 void *argp1 = 0 ;
44303 int res1 = 0 ;
44304 PyObject *swig_obj[1] ;
44305
44306 if (!args) SWIG_fail;
44307 swig_obj[0] = args;
44308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44309 if (!SWIG_IsOK(res1)) {
44310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44311 }
44312 arg1 = reinterpret_cast< wxMenu * >(argp1);
44313 {
44314 PyThreadState* __tstate = wxPyBeginAllowThreads();
44315 (arg1)->Detach();
44316 wxPyEndAllowThreads(__tstate);
44317 if (PyErr_Occurred()) SWIG_fail;
44318 }
44319 resultobj = SWIG_Py_Void();
44320 return resultobj;
44321 fail:
44322 return NULL;
44323 }
44324
44325
44326 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44327 PyObject *resultobj = 0;
44328 wxMenu *arg1 = (wxMenu *) 0 ;
44329 bool result;
44330 void *argp1 = 0 ;
44331 int res1 = 0 ;
44332 PyObject *swig_obj[1] ;
44333
44334 if (!args) SWIG_fail;
44335 swig_obj[0] = args;
44336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44337 if (!SWIG_IsOK(res1)) {
44338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44339 }
44340 arg1 = reinterpret_cast< wxMenu * >(argp1);
44341 {
44342 PyThreadState* __tstate = wxPyBeginAllowThreads();
44343 result = (bool)((wxMenu const *)arg1)->IsAttached();
44344 wxPyEndAllowThreads(__tstate);
44345 if (PyErr_Occurred()) SWIG_fail;
44346 }
44347 {
44348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44349 }
44350 return resultobj;
44351 fail:
44352 return NULL;
44353 }
44354
44355
44356 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44357 PyObject *resultobj = 0;
44358 wxMenu *arg1 = (wxMenu *) 0 ;
44359 wxMenu *arg2 = (wxMenu *) 0 ;
44360 void *argp1 = 0 ;
44361 int res1 = 0 ;
44362 void *argp2 = 0 ;
44363 int res2 = 0 ;
44364 PyObject * obj0 = 0 ;
44365 PyObject * obj1 = 0 ;
44366 char * kwnames[] = {
44367 (char *) "self",(char *) "parent", NULL
44368 };
44369
44370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44372 if (!SWIG_IsOK(res1)) {
44373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44374 }
44375 arg1 = reinterpret_cast< wxMenu * >(argp1);
44376 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44377 if (!SWIG_IsOK(res2)) {
44378 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44379 }
44380 arg2 = reinterpret_cast< wxMenu * >(argp2);
44381 {
44382 PyThreadState* __tstate = wxPyBeginAllowThreads();
44383 (arg1)->SetParent(arg2);
44384 wxPyEndAllowThreads(__tstate);
44385 if (PyErr_Occurred()) SWIG_fail;
44386 }
44387 resultobj = SWIG_Py_Void();
44388 return resultobj;
44389 fail:
44390 return NULL;
44391 }
44392
44393
44394 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44395 PyObject *resultobj = 0;
44396 wxMenu *arg1 = (wxMenu *) 0 ;
44397 wxMenu *result = 0 ;
44398 void *argp1 = 0 ;
44399 int res1 = 0 ;
44400 PyObject *swig_obj[1] ;
44401
44402 if (!args) SWIG_fail;
44403 swig_obj[0] = args;
44404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44405 if (!SWIG_IsOK(res1)) {
44406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44407 }
44408 arg1 = reinterpret_cast< wxMenu * >(argp1);
44409 {
44410 PyThreadState* __tstate = wxPyBeginAllowThreads();
44411 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44412 wxPyEndAllowThreads(__tstate);
44413 if (PyErr_Occurred()) SWIG_fail;
44414 }
44415 {
44416 resultobj = wxPyMake_wxObject(result, 0);
44417 }
44418 return resultobj;
44419 fail:
44420 return NULL;
44421 }
44422
44423
44424 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44425 PyObject *obj;
44426 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44427 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44428 return SWIG_Py_Void();
44429 }
44430
44431 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44432 return SWIG_Python_InitShadowInstance(args);
44433 }
44434
44435 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44436 PyObject *resultobj = 0;
44437 long arg1 = (long) 0 ;
44438 wxMenuBar *result = 0 ;
44439 long val1 ;
44440 int ecode1 = 0 ;
44441 PyObject * obj0 = 0 ;
44442 char * kwnames[] = {
44443 (char *) "style", NULL
44444 };
44445
44446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44447 if (obj0) {
44448 ecode1 = SWIG_AsVal_long(obj0, &val1);
44449 if (!SWIG_IsOK(ecode1)) {
44450 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44451 }
44452 arg1 = static_cast< long >(val1);
44453 }
44454 {
44455 if (!wxPyCheckForApp()) SWIG_fail;
44456 PyThreadState* __tstate = wxPyBeginAllowThreads();
44457 result = (wxMenuBar *)new wxMenuBar(arg1);
44458 wxPyEndAllowThreads(__tstate);
44459 if (PyErr_Occurred()) SWIG_fail;
44460 }
44461 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44462 return resultobj;
44463 fail:
44464 return NULL;
44465 }
44466
44467
44468 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44469 PyObject *resultobj = 0;
44470 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44471 wxMenu *arg2 = (wxMenu *) 0 ;
44472 wxString *arg3 = 0 ;
44473 bool result;
44474 void *argp1 = 0 ;
44475 int res1 = 0 ;
44476 void *argp2 = 0 ;
44477 int res2 = 0 ;
44478 bool temp3 = false ;
44479 PyObject * obj0 = 0 ;
44480 PyObject * obj1 = 0 ;
44481 PyObject * obj2 = 0 ;
44482 char * kwnames[] = {
44483 (char *) "self",(char *) "menu",(char *) "title", NULL
44484 };
44485
44486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44488 if (!SWIG_IsOK(res1)) {
44489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44490 }
44491 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44492 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44493 if (!SWIG_IsOK(res2)) {
44494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44495 }
44496 arg2 = reinterpret_cast< wxMenu * >(argp2);
44497 {
44498 arg3 = wxString_in_helper(obj2);
44499 if (arg3 == NULL) SWIG_fail;
44500 temp3 = true;
44501 }
44502 {
44503 PyThreadState* __tstate = wxPyBeginAllowThreads();
44504 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44505 wxPyEndAllowThreads(__tstate);
44506 if (PyErr_Occurred()) SWIG_fail;
44507 }
44508 {
44509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44510 }
44511 {
44512 if (temp3)
44513 delete arg3;
44514 }
44515 return resultobj;
44516 fail:
44517 {
44518 if (temp3)
44519 delete arg3;
44520 }
44521 return NULL;
44522 }
44523
44524
44525 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44526 PyObject *resultobj = 0;
44527 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44528 size_t arg2 ;
44529 wxMenu *arg3 = (wxMenu *) 0 ;
44530 wxString *arg4 = 0 ;
44531 bool result;
44532 void *argp1 = 0 ;
44533 int res1 = 0 ;
44534 size_t val2 ;
44535 int ecode2 = 0 ;
44536 void *argp3 = 0 ;
44537 int res3 = 0 ;
44538 bool temp4 = false ;
44539 PyObject * obj0 = 0 ;
44540 PyObject * obj1 = 0 ;
44541 PyObject * obj2 = 0 ;
44542 PyObject * obj3 = 0 ;
44543 char * kwnames[] = {
44544 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44545 };
44546
44547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44549 if (!SWIG_IsOK(res1)) {
44550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44551 }
44552 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44553 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44554 if (!SWIG_IsOK(ecode2)) {
44555 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44556 }
44557 arg2 = static_cast< size_t >(val2);
44558 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44559 if (!SWIG_IsOK(res3)) {
44560 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44561 }
44562 arg3 = reinterpret_cast< wxMenu * >(argp3);
44563 {
44564 arg4 = wxString_in_helper(obj3);
44565 if (arg4 == NULL) SWIG_fail;
44566 temp4 = true;
44567 }
44568 {
44569 PyThreadState* __tstate = wxPyBeginAllowThreads();
44570 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44571 wxPyEndAllowThreads(__tstate);
44572 if (PyErr_Occurred()) SWIG_fail;
44573 }
44574 {
44575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44576 }
44577 {
44578 if (temp4)
44579 delete arg4;
44580 }
44581 return resultobj;
44582 fail:
44583 {
44584 if (temp4)
44585 delete arg4;
44586 }
44587 return NULL;
44588 }
44589
44590
44591 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44592 PyObject *resultobj = 0;
44593 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44594 size_t result;
44595 void *argp1 = 0 ;
44596 int res1 = 0 ;
44597 PyObject *swig_obj[1] ;
44598
44599 if (!args) SWIG_fail;
44600 swig_obj[0] = args;
44601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44602 if (!SWIG_IsOK(res1)) {
44603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44604 }
44605 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44606 {
44607 PyThreadState* __tstate = wxPyBeginAllowThreads();
44608 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44609 wxPyEndAllowThreads(__tstate);
44610 if (PyErr_Occurred()) SWIG_fail;
44611 }
44612 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44613 return resultobj;
44614 fail:
44615 return NULL;
44616 }
44617
44618
44619 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44620 PyObject *resultobj = 0;
44621 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44622 size_t arg2 ;
44623 wxMenu *result = 0 ;
44624 void *argp1 = 0 ;
44625 int res1 = 0 ;
44626 size_t val2 ;
44627 int ecode2 = 0 ;
44628 PyObject * obj0 = 0 ;
44629 PyObject * obj1 = 0 ;
44630 char * kwnames[] = {
44631 (char *) "self",(char *) "pos", NULL
44632 };
44633
44634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44636 if (!SWIG_IsOK(res1)) {
44637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44638 }
44639 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44640 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44641 if (!SWIG_IsOK(ecode2)) {
44642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44643 }
44644 arg2 = static_cast< size_t >(val2);
44645 {
44646 PyThreadState* __tstate = wxPyBeginAllowThreads();
44647 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44648 wxPyEndAllowThreads(__tstate);
44649 if (PyErr_Occurred()) SWIG_fail;
44650 }
44651 {
44652 resultobj = wxPyMake_wxObject(result, 0);
44653 }
44654 return resultobj;
44655 fail:
44656 return NULL;
44657 }
44658
44659
44660 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44661 PyObject *resultobj = 0;
44662 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44663 size_t arg2 ;
44664 wxMenu *arg3 = (wxMenu *) 0 ;
44665 wxString *arg4 = 0 ;
44666 wxMenu *result = 0 ;
44667 void *argp1 = 0 ;
44668 int res1 = 0 ;
44669 size_t val2 ;
44670 int ecode2 = 0 ;
44671 void *argp3 = 0 ;
44672 int res3 = 0 ;
44673 bool temp4 = false ;
44674 PyObject * obj0 = 0 ;
44675 PyObject * obj1 = 0 ;
44676 PyObject * obj2 = 0 ;
44677 PyObject * obj3 = 0 ;
44678 char * kwnames[] = {
44679 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44680 };
44681
44682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44684 if (!SWIG_IsOK(res1)) {
44685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44686 }
44687 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44688 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44689 if (!SWIG_IsOK(ecode2)) {
44690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44691 }
44692 arg2 = static_cast< size_t >(val2);
44693 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44694 if (!SWIG_IsOK(res3)) {
44695 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44696 }
44697 arg3 = reinterpret_cast< wxMenu * >(argp3);
44698 {
44699 arg4 = wxString_in_helper(obj3);
44700 if (arg4 == NULL) SWIG_fail;
44701 temp4 = true;
44702 }
44703 {
44704 PyThreadState* __tstate = wxPyBeginAllowThreads();
44705 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44706 wxPyEndAllowThreads(__tstate);
44707 if (PyErr_Occurred()) SWIG_fail;
44708 }
44709 {
44710 resultobj = wxPyMake_wxObject(result, 0);
44711 }
44712 {
44713 if (temp4)
44714 delete arg4;
44715 }
44716 return resultobj;
44717 fail:
44718 {
44719 if (temp4)
44720 delete arg4;
44721 }
44722 return NULL;
44723 }
44724
44725
44726 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44727 PyObject *resultobj = 0;
44728 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44729 size_t arg2 ;
44730 wxMenu *result = 0 ;
44731 void *argp1 = 0 ;
44732 int res1 = 0 ;
44733 size_t val2 ;
44734 int ecode2 = 0 ;
44735 PyObject * obj0 = 0 ;
44736 PyObject * obj1 = 0 ;
44737 char * kwnames[] = {
44738 (char *) "self",(char *) "pos", NULL
44739 };
44740
44741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44743 if (!SWIG_IsOK(res1)) {
44744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44745 }
44746 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44747 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44748 if (!SWIG_IsOK(ecode2)) {
44749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44750 }
44751 arg2 = static_cast< size_t >(val2);
44752 {
44753 PyThreadState* __tstate = wxPyBeginAllowThreads();
44754 result = (wxMenu *)(arg1)->Remove(arg2);
44755 wxPyEndAllowThreads(__tstate);
44756 if (PyErr_Occurred()) SWIG_fail;
44757 }
44758 {
44759 resultobj = wxPyMake_wxObject(result, 0);
44760 }
44761 return resultobj;
44762 fail:
44763 return NULL;
44764 }
44765
44766
44767 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44768 PyObject *resultobj = 0;
44769 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44770 size_t arg2 ;
44771 bool arg3 ;
44772 void *argp1 = 0 ;
44773 int res1 = 0 ;
44774 size_t val2 ;
44775 int ecode2 = 0 ;
44776 bool val3 ;
44777 int ecode3 = 0 ;
44778 PyObject * obj0 = 0 ;
44779 PyObject * obj1 = 0 ;
44780 PyObject * obj2 = 0 ;
44781 char * kwnames[] = {
44782 (char *) "self",(char *) "pos",(char *) "enable", NULL
44783 };
44784
44785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44787 if (!SWIG_IsOK(res1)) {
44788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44789 }
44790 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44791 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44792 if (!SWIG_IsOK(ecode2)) {
44793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44794 }
44795 arg2 = static_cast< size_t >(val2);
44796 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44797 if (!SWIG_IsOK(ecode3)) {
44798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44799 }
44800 arg3 = static_cast< bool >(val3);
44801 {
44802 PyThreadState* __tstate = wxPyBeginAllowThreads();
44803 (arg1)->EnableTop(arg2,arg3);
44804 wxPyEndAllowThreads(__tstate);
44805 if (PyErr_Occurred()) SWIG_fail;
44806 }
44807 resultobj = SWIG_Py_Void();
44808 return resultobj;
44809 fail:
44810 return NULL;
44811 }
44812
44813
44814 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44815 PyObject *resultobj = 0;
44816 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44817 size_t arg2 ;
44818 bool result;
44819 void *argp1 = 0 ;
44820 int res1 = 0 ;
44821 size_t val2 ;
44822 int ecode2 = 0 ;
44823 PyObject * obj0 = 0 ;
44824 PyObject * obj1 = 0 ;
44825 char * kwnames[] = {
44826 (char *) "self",(char *) "pos", NULL
44827 };
44828
44829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44831 if (!SWIG_IsOK(res1)) {
44832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44833 }
44834 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44835 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44836 if (!SWIG_IsOK(ecode2)) {
44837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44838 }
44839 arg2 = static_cast< size_t >(val2);
44840 {
44841 PyThreadState* __tstate = wxPyBeginAllowThreads();
44842 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44843 wxPyEndAllowThreads(__tstate);
44844 if (PyErr_Occurred()) SWIG_fail;
44845 }
44846 {
44847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44848 }
44849 return resultobj;
44850 fail:
44851 return NULL;
44852 }
44853
44854
44855 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44856 PyObject *resultobj = 0;
44857 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44858 size_t arg2 ;
44859 wxString *arg3 = 0 ;
44860 void *argp1 = 0 ;
44861 int res1 = 0 ;
44862 size_t val2 ;
44863 int ecode2 = 0 ;
44864 bool temp3 = false ;
44865 PyObject * obj0 = 0 ;
44866 PyObject * obj1 = 0 ;
44867 PyObject * obj2 = 0 ;
44868 char * kwnames[] = {
44869 (char *) "self",(char *) "pos",(char *) "label", NULL
44870 };
44871
44872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44873 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44874 if (!SWIG_IsOK(res1)) {
44875 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44876 }
44877 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44878 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44879 if (!SWIG_IsOK(ecode2)) {
44880 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44881 }
44882 arg2 = static_cast< size_t >(val2);
44883 {
44884 arg3 = wxString_in_helper(obj2);
44885 if (arg3 == NULL) SWIG_fail;
44886 temp3 = true;
44887 }
44888 {
44889 PyThreadState* __tstate = wxPyBeginAllowThreads();
44890 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44891 wxPyEndAllowThreads(__tstate);
44892 if (PyErr_Occurred()) SWIG_fail;
44893 }
44894 resultobj = SWIG_Py_Void();
44895 {
44896 if (temp3)
44897 delete arg3;
44898 }
44899 return resultobj;
44900 fail:
44901 {
44902 if (temp3)
44903 delete arg3;
44904 }
44905 return NULL;
44906 }
44907
44908
44909 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44910 PyObject *resultobj = 0;
44911 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44912 size_t arg2 ;
44913 wxString result;
44914 void *argp1 = 0 ;
44915 int res1 = 0 ;
44916 size_t val2 ;
44917 int ecode2 = 0 ;
44918 PyObject * obj0 = 0 ;
44919 PyObject * obj1 = 0 ;
44920 char * kwnames[] = {
44921 (char *) "self",(char *) "pos", NULL
44922 };
44923
44924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44926 if (!SWIG_IsOK(res1)) {
44927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44928 }
44929 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44930 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44931 if (!SWIG_IsOK(ecode2)) {
44932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44933 }
44934 arg2 = static_cast< size_t >(val2);
44935 {
44936 PyThreadState* __tstate = wxPyBeginAllowThreads();
44937 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44938 wxPyEndAllowThreads(__tstate);
44939 if (PyErr_Occurred()) SWIG_fail;
44940 }
44941 {
44942 #if wxUSE_UNICODE
44943 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44944 #else
44945 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44946 #endif
44947 }
44948 return resultobj;
44949 fail:
44950 return NULL;
44951 }
44952
44953
44954 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44955 PyObject *resultobj = 0;
44956 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44957 wxString *arg2 = 0 ;
44958 wxString *arg3 = 0 ;
44959 int result;
44960 void *argp1 = 0 ;
44961 int res1 = 0 ;
44962 bool temp2 = false ;
44963 bool temp3 = false ;
44964 PyObject * obj0 = 0 ;
44965 PyObject * obj1 = 0 ;
44966 PyObject * obj2 = 0 ;
44967 char * kwnames[] = {
44968 (char *) "self",(char *) "menu",(char *) "item", NULL
44969 };
44970
44971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44973 if (!SWIG_IsOK(res1)) {
44974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44975 }
44976 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44977 {
44978 arg2 = wxString_in_helper(obj1);
44979 if (arg2 == NULL) SWIG_fail;
44980 temp2 = true;
44981 }
44982 {
44983 arg3 = wxString_in_helper(obj2);
44984 if (arg3 == NULL) SWIG_fail;
44985 temp3 = true;
44986 }
44987 {
44988 PyThreadState* __tstate = wxPyBeginAllowThreads();
44989 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44990 wxPyEndAllowThreads(__tstate);
44991 if (PyErr_Occurred()) SWIG_fail;
44992 }
44993 resultobj = SWIG_From_int(static_cast< int >(result));
44994 {
44995 if (temp2)
44996 delete arg2;
44997 }
44998 {
44999 if (temp3)
45000 delete arg3;
45001 }
45002 return resultobj;
45003 fail:
45004 {
45005 if (temp2)
45006 delete arg2;
45007 }
45008 {
45009 if (temp3)
45010 delete arg3;
45011 }
45012 return NULL;
45013 }
45014
45015
45016 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45017 PyObject *resultobj = 0;
45018 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45019 int arg2 ;
45020 wxMenuItem *result = 0 ;
45021 void *argp1 = 0 ;
45022 int res1 = 0 ;
45023 int val2 ;
45024 int ecode2 = 0 ;
45025 PyObject * obj0 = 0 ;
45026 PyObject * obj1 = 0 ;
45027 char * kwnames[] = {
45028 (char *) "self",(char *) "id", NULL
45029 };
45030
45031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45033 if (!SWIG_IsOK(res1)) {
45034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45035 }
45036 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45037 ecode2 = SWIG_AsVal_int(obj1, &val2);
45038 if (!SWIG_IsOK(ecode2)) {
45039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45040 }
45041 arg2 = static_cast< int >(val2);
45042 {
45043 PyThreadState* __tstate = wxPyBeginAllowThreads();
45044 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45045 wxPyEndAllowThreads(__tstate);
45046 if (PyErr_Occurred()) SWIG_fail;
45047 }
45048 {
45049 resultobj = wxPyMake_wxObject(result, (bool)0);
45050 }
45051 return resultobj;
45052 fail:
45053 return NULL;
45054 }
45055
45056
45057 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45058 PyObject *resultobj = 0;
45059 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45060 wxString *arg2 = 0 ;
45061 int result;
45062 void *argp1 = 0 ;
45063 int res1 = 0 ;
45064 bool temp2 = false ;
45065 PyObject * obj0 = 0 ;
45066 PyObject * obj1 = 0 ;
45067 char * kwnames[] = {
45068 (char *) "self",(char *) "title", NULL
45069 };
45070
45071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45073 if (!SWIG_IsOK(res1)) {
45074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45075 }
45076 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45077 {
45078 arg2 = wxString_in_helper(obj1);
45079 if (arg2 == NULL) SWIG_fail;
45080 temp2 = true;
45081 }
45082 {
45083 PyThreadState* __tstate = wxPyBeginAllowThreads();
45084 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45085 wxPyEndAllowThreads(__tstate);
45086 if (PyErr_Occurred()) SWIG_fail;
45087 }
45088 resultobj = SWIG_From_int(static_cast< int >(result));
45089 {
45090 if (temp2)
45091 delete arg2;
45092 }
45093 return resultobj;
45094 fail:
45095 {
45096 if (temp2)
45097 delete arg2;
45098 }
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj = 0;
45105 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45106 int arg2 ;
45107 bool arg3 ;
45108 void *argp1 = 0 ;
45109 int res1 = 0 ;
45110 int val2 ;
45111 int ecode2 = 0 ;
45112 bool val3 ;
45113 int ecode3 = 0 ;
45114 PyObject * obj0 = 0 ;
45115 PyObject * obj1 = 0 ;
45116 PyObject * obj2 = 0 ;
45117 char * kwnames[] = {
45118 (char *) "self",(char *) "id",(char *) "enable", NULL
45119 };
45120
45121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45123 if (!SWIG_IsOK(res1)) {
45124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45125 }
45126 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45127 ecode2 = SWIG_AsVal_int(obj1, &val2);
45128 if (!SWIG_IsOK(ecode2)) {
45129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45130 }
45131 arg2 = static_cast< int >(val2);
45132 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45133 if (!SWIG_IsOK(ecode3)) {
45134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45135 }
45136 arg3 = static_cast< bool >(val3);
45137 {
45138 PyThreadState* __tstate = wxPyBeginAllowThreads();
45139 (arg1)->Enable(arg2,arg3);
45140 wxPyEndAllowThreads(__tstate);
45141 if (PyErr_Occurred()) SWIG_fail;
45142 }
45143 resultobj = SWIG_Py_Void();
45144 return resultobj;
45145 fail:
45146 return NULL;
45147 }
45148
45149
45150 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45151 PyObject *resultobj = 0;
45152 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45153 int arg2 ;
45154 bool arg3 ;
45155 void *argp1 = 0 ;
45156 int res1 = 0 ;
45157 int val2 ;
45158 int ecode2 = 0 ;
45159 bool val3 ;
45160 int ecode3 = 0 ;
45161 PyObject * obj0 = 0 ;
45162 PyObject * obj1 = 0 ;
45163 PyObject * obj2 = 0 ;
45164 char * kwnames[] = {
45165 (char *) "self",(char *) "id",(char *) "check", NULL
45166 };
45167
45168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45170 if (!SWIG_IsOK(res1)) {
45171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45172 }
45173 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45174 ecode2 = SWIG_AsVal_int(obj1, &val2);
45175 if (!SWIG_IsOK(ecode2)) {
45176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45177 }
45178 arg2 = static_cast< int >(val2);
45179 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45180 if (!SWIG_IsOK(ecode3)) {
45181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45182 }
45183 arg3 = static_cast< bool >(val3);
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 (arg1)->Check(arg2,arg3);
45187 wxPyEndAllowThreads(__tstate);
45188 if (PyErr_Occurred()) SWIG_fail;
45189 }
45190 resultobj = SWIG_Py_Void();
45191 return resultobj;
45192 fail:
45193 return NULL;
45194 }
45195
45196
45197 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45198 PyObject *resultobj = 0;
45199 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45200 int arg2 ;
45201 bool result;
45202 void *argp1 = 0 ;
45203 int res1 = 0 ;
45204 int val2 ;
45205 int ecode2 = 0 ;
45206 PyObject * obj0 = 0 ;
45207 PyObject * obj1 = 0 ;
45208 char * kwnames[] = {
45209 (char *) "self",(char *) "id", NULL
45210 };
45211
45212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45214 if (!SWIG_IsOK(res1)) {
45215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45216 }
45217 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45218 ecode2 = SWIG_AsVal_int(obj1, &val2);
45219 if (!SWIG_IsOK(ecode2)) {
45220 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45221 }
45222 arg2 = static_cast< int >(val2);
45223 {
45224 PyThreadState* __tstate = wxPyBeginAllowThreads();
45225 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45226 wxPyEndAllowThreads(__tstate);
45227 if (PyErr_Occurred()) SWIG_fail;
45228 }
45229 {
45230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45231 }
45232 return resultobj;
45233 fail:
45234 return NULL;
45235 }
45236
45237
45238 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45239 PyObject *resultobj = 0;
45240 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45241 int arg2 ;
45242 bool result;
45243 void *argp1 = 0 ;
45244 int res1 = 0 ;
45245 int val2 ;
45246 int ecode2 = 0 ;
45247 PyObject * obj0 = 0 ;
45248 PyObject * obj1 = 0 ;
45249 char * kwnames[] = {
45250 (char *) "self",(char *) "id", NULL
45251 };
45252
45253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45255 if (!SWIG_IsOK(res1)) {
45256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45257 }
45258 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45259 ecode2 = SWIG_AsVal_int(obj1, &val2);
45260 if (!SWIG_IsOK(ecode2)) {
45261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45262 }
45263 arg2 = static_cast< int >(val2);
45264 {
45265 PyThreadState* __tstate = wxPyBeginAllowThreads();
45266 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45267 wxPyEndAllowThreads(__tstate);
45268 if (PyErr_Occurred()) SWIG_fail;
45269 }
45270 {
45271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45272 }
45273 return resultobj;
45274 fail:
45275 return NULL;
45276 }
45277
45278
45279 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45280 PyObject *resultobj = 0;
45281 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45282 int arg2 ;
45283 wxString *arg3 = 0 ;
45284 void *argp1 = 0 ;
45285 int res1 = 0 ;
45286 int val2 ;
45287 int ecode2 = 0 ;
45288 bool temp3 = false ;
45289 PyObject * obj0 = 0 ;
45290 PyObject * obj1 = 0 ;
45291 PyObject * obj2 = 0 ;
45292 char * kwnames[] = {
45293 (char *) "self",(char *) "id",(char *) "label", NULL
45294 };
45295
45296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45298 if (!SWIG_IsOK(res1)) {
45299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45300 }
45301 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45302 ecode2 = SWIG_AsVal_int(obj1, &val2);
45303 if (!SWIG_IsOK(ecode2)) {
45304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45305 }
45306 arg2 = static_cast< int >(val2);
45307 {
45308 arg3 = wxString_in_helper(obj2);
45309 if (arg3 == NULL) SWIG_fail;
45310 temp3 = true;
45311 }
45312 {
45313 PyThreadState* __tstate = wxPyBeginAllowThreads();
45314 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45315 wxPyEndAllowThreads(__tstate);
45316 if (PyErr_Occurred()) SWIG_fail;
45317 }
45318 resultobj = SWIG_Py_Void();
45319 {
45320 if (temp3)
45321 delete arg3;
45322 }
45323 return resultobj;
45324 fail:
45325 {
45326 if (temp3)
45327 delete arg3;
45328 }
45329 return NULL;
45330 }
45331
45332
45333 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45334 PyObject *resultobj = 0;
45335 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45336 int arg2 ;
45337 wxString result;
45338 void *argp1 = 0 ;
45339 int res1 = 0 ;
45340 int val2 ;
45341 int ecode2 = 0 ;
45342 PyObject * obj0 = 0 ;
45343 PyObject * obj1 = 0 ;
45344 char * kwnames[] = {
45345 (char *) "self",(char *) "id", NULL
45346 };
45347
45348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) 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_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45352 }
45353 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45354 ecode2 = SWIG_AsVal_int(obj1, &val2);
45355 if (!SWIG_IsOK(ecode2)) {
45356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45357 }
45358 arg2 = static_cast< int >(val2);
45359 {
45360 PyThreadState* __tstate = wxPyBeginAllowThreads();
45361 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45362 wxPyEndAllowThreads(__tstate);
45363 if (PyErr_Occurred()) SWIG_fail;
45364 }
45365 {
45366 #if wxUSE_UNICODE
45367 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45368 #else
45369 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45370 #endif
45371 }
45372 return resultobj;
45373 fail:
45374 return NULL;
45375 }
45376
45377
45378 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45379 PyObject *resultobj = 0;
45380 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45381 int arg2 ;
45382 wxString *arg3 = 0 ;
45383 void *argp1 = 0 ;
45384 int res1 = 0 ;
45385 int val2 ;
45386 int ecode2 = 0 ;
45387 bool temp3 = false ;
45388 PyObject * obj0 = 0 ;
45389 PyObject * obj1 = 0 ;
45390 PyObject * obj2 = 0 ;
45391 char * kwnames[] = {
45392 (char *) "self",(char *) "id",(char *) "helpString", NULL
45393 };
45394
45395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45397 if (!SWIG_IsOK(res1)) {
45398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45399 }
45400 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45401 ecode2 = SWIG_AsVal_int(obj1, &val2);
45402 if (!SWIG_IsOK(ecode2)) {
45403 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45404 }
45405 arg2 = static_cast< int >(val2);
45406 {
45407 arg3 = wxString_in_helper(obj2);
45408 if (arg3 == NULL) SWIG_fail;
45409 temp3 = true;
45410 }
45411 {
45412 PyThreadState* __tstate = wxPyBeginAllowThreads();
45413 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45414 wxPyEndAllowThreads(__tstate);
45415 if (PyErr_Occurred()) SWIG_fail;
45416 }
45417 resultobj = SWIG_Py_Void();
45418 {
45419 if (temp3)
45420 delete arg3;
45421 }
45422 return resultobj;
45423 fail:
45424 {
45425 if (temp3)
45426 delete arg3;
45427 }
45428 return NULL;
45429 }
45430
45431
45432 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45433 PyObject *resultobj = 0;
45434 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45435 int arg2 ;
45436 wxString result;
45437 void *argp1 = 0 ;
45438 int res1 = 0 ;
45439 int val2 ;
45440 int ecode2 = 0 ;
45441 PyObject * obj0 = 0 ;
45442 PyObject * obj1 = 0 ;
45443 char * kwnames[] = {
45444 (char *) "self",(char *) "id", NULL
45445 };
45446
45447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45449 if (!SWIG_IsOK(res1)) {
45450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45451 }
45452 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45453 ecode2 = SWIG_AsVal_int(obj1, &val2);
45454 if (!SWIG_IsOK(ecode2)) {
45455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45456 }
45457 arg2 = static_cast< int >(val2);
45458 {
45459 PyThreadState* __tstate = wxPyBeginAllowThreads();
45460 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45461 wxPyEndAllowThreads(__tstate);
45462 if (PyErr_Occurred()) SWIG_fail;
45463 }
45464 {
45465 #if wxUSE_UNICODE
45466 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45467 #else
45468 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45469 #endif
45470 }
45471 return resultobj;
45472 fail:
45473 return NULL;
45474 }
45475
45476
45477 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45478 PyObject *resultobj = 0;
45479 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45480 wxFrame *result = 0 ;
45481 void *argp1 = 0 ;
45482 int res1 = 0 ;
45483 PyObject *swig_obj[1] ;
45484
45485 if (!args) SWIG_fail;
45486 swig_obj[0] = args;
45487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45488 if (!SWIG_IsOK(res1)) {
45489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45490 }
45491 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45492 {
45493 PyThreadState* __tstate = wxPyBeginAllowThreads();
45494 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45495 wxPyEndAllowThreads(__tstate);
45496 if (PyErr_Occurred()) SWIG_fail;
45497 }
45498 {
45499 resultobj = wxPyMake_wxObject(result, (bool)0);
45500 }
45501 return resultobj;
45502 fail:
45503 return NULL;
45504 }
45505
45506
45507 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45508 PyObject *resultobj = 0;
45509 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45510 bool result;
45511 void *argp1 = 0 ;
45512 int res1 = 0 ;
45513 PyObject *swig_obj[1] ;
45514
45515 if (!args) SWIG_fail;
45516 swig_obj[0] = args;
45517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45518 if (!SWIG_IsOK(res1)) {
45519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45520 }
45521 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45522 {
45523 PyThreadState* __tstate = wxPyBeginAllowThreads();
45524 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45525 wxPyEndAllowThreads(__tstate);
45526 if (PyErr_Occurred()) SWIG_fail;
45527 }
45528 {
45529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45530 }
45531 return resultobj;
45532 fail:
45533 return NULL;
45534 }
45535
45536
45537 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45538 PyObject *resultobj = 0;
45539 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45540 wxFrame *arg2 = (wxFrame *) 0 ;
45541 void *argp1 = 0 ;
45542 int res1 = 0 ;
45543 void *argp2 = 0 ;
45544 int res2 = 0 ;
45545 PyObject * obj0 = 0 ;
45546 PyObject * obj1 = 0 ;
45547 char * kwnames[] = {
45548 (char *) "self",(char *) "frame", NULL
45549 };
45550
45551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45553 if (!SWIG_IsOK(res1)) {
45554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45555 }
45556 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45557 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45558 if (!SWIG_IsOK(res2)) {
45559 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45560 }
45561 arg2 = reinterpret_cast< wxFrame * >(argp2);
45562 {
45563 PyThreadState* __tstate = wxPyBeginAllowThreads();
45564 (arg1)->Attach(arg2);
45565 wxPyEndAllowThreads(__tstate);
45566 if (PyErr_Occurred()) SWIG_fail;
45567 }
45568 resultobj = SWIG_Py_Void();
45569 return resultobj;
45570 fail:
45571 return NULL;
45572 }
45573
45574
45575 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45576 PyObject *resultobj = 0;
45577 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45578 void *argp1 = 0 ;
45579 int res1 = 0 ;
45580 PyObject *swig_obj[1] ;
45581
45582 if (!args) SWIG_fail;
45583 swig_obj[0] = args;
45584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45585 if (!SWIG_IsOK(res1)) {
45586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45587 }
45588 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45589 {
45590 PyThreadState* __tstate = wxPyBeginAllowThreads();
45591 (arg1)->Detach();
45592 wxPyEndAllowThreads(__tstate);
45593 if (PyErr_Occurred()) SWIG_fail;
45594 }
45595 resultobj = SWIG_Py_Void();
45596 return resultobj;
45597 fail:
45598 return NULL;
45599 }
45600
45601
45602 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45603 PyObject *resultobj = 0;
45604 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45605 void *argp1 = 0 ;
45606 int res1 = 0 ;
45607 PyObject *swig_obj[1] ;
45608
45609 if (!args) SWIG_fail;
45610 swig_obj[0] = args;
45611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45612 if (!SWIG_IsOK(res1)) {
45613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45614 }
45615 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45616 {
45617 PyThreadState* __tstate = wxPyBeginAllowThreads();
45618 (arg1)->UpdateMenus();
45619 wxPyEndAllowThreads(__tstate);
45620 if (PyErr_Occurred()) SWIG_fail;
45621 }
45622 resultobj = SWIG_Py_Void();
45623 return resultobj;
45624 fail:
45625 return NULL;
45626 }
45627
45628
45629 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45630 PyObject *resultobj = 0;
45631 bool arg1 ;
45632 bool val1 ;
45633 int ecode1 = 0 ;
45634 PyObject * obj0 = 0 ;
45635 char * kwnames[] = {
45636 (char *) "enable", NULL
45637 };
45638
45639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45640 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45641 if (!SWIG_IsOK(ecode1)) {
45642 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45643 }
45644 arg1 = static_cast< bool >(val1);
45645 {
45646 PyThreadState* __tstate = wxPyBeginAllowThreads();
45647 wxMenuBar_SetAutoWindowMenu(arg1);
45648 wxPyEndAllowThreads(__tstate);
45649 if (PyErr_Occurred()) SWIG_fail;
45650 }
45651 resultobj = SWIG_Py_Void();
45652 return resultobj;
45653 fail:
45654 return NULL;
45655 }
45656
45657
45658 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45659 PyObject *resultobj = 0;
45660 bool result;
45661
45662 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 result = (bool)wxMenuBar_GetAutoWindowMenu();
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 {
45670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45671 }
45672 return resultobj;
45673 fail:
45674 return NULL;
45675 }
45676
45677
45678 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45679 PyObject *obj;
45680 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45681 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45682 return SWIG_Py_Void();
45683 }
45684
45685 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45686 return SWIG_Python_InitShadowInstance(args);
45687 }
45688
45689 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45690 PyObject *resultobj = 0;
45691 wxMenu *arg1 = (wxMenu *) NULL ;
45692 int arg2 = (int) wxID_ANY ;
45693 wxString const &arg3_defvalue = wxPyEmptyString ;
45694 wxString *arg3 = (wxString *) &arg3_defvalue ;
45695 wxString const &arg4_defvalue = wxPyEmptyString ;
45696 wxString *arg4 = (wxString *) &arg4_defvalue ;
45697 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45698 wxMenu *arg6 = (wxMenu *) NULL ;
45699 wxMenuItem *result = 0 ;
45700 void *argp1 = 0 ;
45701 int res1 = 0 ;
45702 int val2 ;
45703 int ecode2 = 0 ;
45704 bool temp3 = false ;
45705 bool temp4 = false ;
45706 int val5 ;
45707 int ecode5 = 0 ;
45708 void *argp6 = 0 ;
45709 int res6 = 0 ;
45710 PyObject * obj0 = 0 ;
45711 PyObject * obj1 = 0 ;
45712 PyObject * obj2 = 0 ;
45713 PyObject * obj3 = 0 ;
45714 PyObject * obj4 = 0 ;
45715 PyObject * obj5 = 0 ;
45716 char * kwnames[] = {
45717 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45718 };
45719
45720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45721 if (obj0) {
45722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45723 if (!SWIG_IsOK(res1)) {
45724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45725 }
45726 arg1 = reinterpret_cast< wxMenu * >(argp1);
45727 }
45728 if (obj1) {
45729 ecode2 = SWIG_AsVal_int(obj1, &val2);
45730 if (!SWIG_IsOK(ecode2)) {
45731 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45732 }
45733 arg2 = static_cast< int >(val2);
45734 }
45735 if (obj2) {
45736 {
45737 arg3 = wxString_in_helper(obj2);
45738 if (arg3 == NULL) SWIG_fail;
45739 temp3 = true;
45740 }
45741 }
45742 if (obj3) {
45743 {
45744 arg4 = wxString_in_helper(obj3);
45745 if (arg4 == NULL) SWIG_fail;
45746 temp4 = true;
45747 }
45748 }
45749 if (obj4) {
45750 ecode5 = SWIG_AsVal_int(obj4, &val5);
45751 if (!SWIG_IsOK(ecode5)) {
45752 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45753 }
45754 arg5 = static_cast< wxItemKind >(val5);
45755 }
45756 if (obj5) {
45757 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45758 if (!SWIG_IsOK(res6)) {
45759 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45760 }
45761 arg6 = reinterpret_cast< wxMenu * >(argp6);
45762 }
45763 {
45764 PyThreadState* __tstate = wxPyBeginAllowThreads();
45765 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45766 wxPyEndAllowThreads(__tstate);
45767 if (PyErr_Occurred()) SWIG_fail;
45768 }
45769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45770 {
45771 if (temp3)
45772 delete arg3;
45773 }
45774 {
45775 if (temp4)
45776 delete arg4;
45777 }
45778 return resultobj;
45779 fail:
45780 {
45781 if (temp3)
45782 delete arg3;
45783 }
45784 {
45785 if (temp4)
45786 delete arg4;
45787 }
45788 return NULL;
45789 }
45790
45791
45792 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45793 PyObject *resultobj = 0;
45794 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45795 void *argp1 = 0 ;
45796 int res1 = 0 ;
45797 PyObject *swig_obj[1] ;
45798
45799 if (!args) SWIG_fail;
45800 swig_obj[0] = args;
45801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45802 if (!SWIG_IsOK(res1)) {
45803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45804 }
45805 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45806 {
45807 PyThreadState* __tstate = wxPyBeginAllowThreads();
45808 delete arg1;
45809
45810 wxPyEndAllowThreads(__tstate);
45811 if (PyErr_Occurred()) SWIG_fail;
45812 }
45813 resultobj = SWIG_Py_Void();
45814 return resultobj;
45815 fail:
45816 return NULL;
45817 }
45818
45819
45820 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45821 PyObject *resultobj = 0;
45822 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45823 wxMenu *result = 0 ;
45824 void *argp1 = 0 ;
45825 int res1 = 0 ;
45826 PyObject *swig_obj[1] ;
45827
45828 if (!args) SWIG_fail;
45829 swig_obj[0] = args;
45830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45831 if (!SWIG_IsOK(res1)) {
45832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45833 }
45834 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45835 {
45836 PyThreadState* __tstate = wxPyBeginAllowThreads();
45837 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45838 wxPyEndAllowThreads(__tstate);
45839 if (PyErr_Occurred()) SWIG_fail;
45840 }
45841 {
45842 resultobj = wxPyMake_wxObject(result, 0);
45843 }
45844 return resultobj;
45845 fail:
45846 return NULL;
45847 }
45848
45849
45850 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45851 PyObject *resultobj = 0;
45852 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45853 wxMenu *arg2 = (wxMenu *) 0 ;
45854 void *argp1 = 0 ;
45855 int res1 = 0 ;
45856 void *argp2 = 0 ;
45857 int res2 = 0 ;
45858 PyObject * obj0 = 0 ;
45859 PyObject * obj1 = 0 ;
45860 char * kwnames[] = {
45861 (char *) "self",(char *) "menu", NULL
45862 };
45863
45864 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45865 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45866 if (!SWIG_IsOK(res1)) {
45867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45868 }
45869 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45870 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45871 if (!SWIG_IsOK(res2)) {
45872 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45873 }
45874 arg2 = reinterpret_cast< wxMenu * >(argp2);
45875 {
45876 PyThreadState* __tstate = wxPyBeginAllowThreads();
45877 (arg1)->SetMenu(arg2);
45878 wxPyEndAllowThreads(__tstate);
45879 if (PyErr_Occurred()) SWIG_fail;
45880 }
45881 resultobj = SWIG_Py_Void();
45882 return resultobj;
45883 fail:
45884 return NULL;
45885 }
45886
45887
45888 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45889 PyObject *resultobj = 0;
45890 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45891 int arg2 ;
45892 void *argp1 = 0 ;
45893 int res1 = 0 ;
45894 int val2 ;
45895 int ecode2 = 0 ;
45896 PyObject * obj0 = 0 ;
45897 PyObject * obj1 = 0 ;
45898 char * kwnames[] = {
45899 (char *) "self",(char *) "id", NULL
45900 };
45901
45902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45904 if (!SWIG_IsOK(res1)) {
45905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45906 }
45907 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45908 ecode2 = SWIG_AsVal_int(obj1, &val2);
45909 if (!SWIG_IsOK(ecode2)) {
45910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45911 }
45912 arg2 = static_cast< int >(val2);
45913 {
45914 PyThreadState* __tstate = wxPyBeginAllowThreads();
45915 (arg1)->SetId(arg2);
45916 wxPyEndAllowThreads(__tstate);
45917 if (PyErr_Occurred()) SWIG_fail;
45918 }
45919 resultobj = SWIG_Py_Void();
45920 return resultobj;
45921 fail:
45922 return NULL;
45923 }
45924
45925
45926 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45927 PyObject *resultobj = 0;
45928 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45929 int result;
45930 void *argp1 = 0 ;
45931 int res1 = 0 ;
45932 PyObject *swig_obj[1] ;
45933
45934 if (!args) SWIG_fail;
45935 swig_obj[0] = args;
45936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45937 if (!SWIG_IsOK(res1)) {
45938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45939 }
45940 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45941 {
45942 PyThreadState* __tstate = wxPyBeginAllowThreads();
45943 result = (int)((wxMenuItem const *)arg1)->GetId();
45944 wxPyEndAllowThreads(__tstate);
45945 if (PyErr_Occurred()) SWIG_fail;
45946 }
45947 resultobj = SWIG_From_int(static_cast< int >(result));
45948 return resultobj;
45949 fail:
45950 return NULL;
45951 }
45952
45953
45954 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45955 PyObject *resultobj = 0;
45956 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45957 bool result;
45958 void *argp1 = 0 ;
45959 int res1 = 0 ;
45960 PyObject *swig_obj[1] ;
45961
45962 if (!args) SWIG_fail;
45963 swig_obj[0] = args;
45964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45965 if (!SWIG_IsOK(res1)) {
45966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45967 }
45968 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45969 {
45970 PyThreadState* __tstate = wxPyBeginAllowThreads();
45971 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45972 wxPyEndAllowThreads(__tstate);
45973 if (PyErr_Occurred()) SWIG_fail;
45974 }
45975 {
45976 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45977 }
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45985 PyObject *resultobj = 0;
45986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45987 wxString *arg2 = 0 ;
45988 void *argp1 = 0 ;
45989 int res1 = 0 ;
45990 bool temp2 = false ;
45991 PyObject * obj0 = 0 ;
45992 PyObject * obj1 = 0 ;
45993 char * kwnames[] = {
45994 (char *) "self",(char *) "str", NULL
45995 };
45996
45997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45999 if (!SWIG_IsOK(res1)) {
46000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46001 }
46002 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46003 {
46004 arg2 = wxString_in_helper(obj1);
46005 if (arg2 == NULL) SWIG_fail;
46006 temp2 = true;
46007 }
46008 {
46009 PyThreadState* __tstate = wxPyBeginAllowThreads();
46010 (arg1)->SetText((wxString const &)*arg2);
46011 wxPyEndAllowThreads(__tstate);
46012 if (PyErr_Occurred()) SWIG_fail;
46013 }
46014 resultobj = SWIG_Py_Void();
46015 {
46016 if (temp2)
46017 delete arg2;
46018 }
46019 return resultobj;
46020 fail:
46021 {
46022 if (temp2)
46023 delete arg2;
46024 }
46025 return NULL;
46026 }
46027
46028
46029 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46030 PyObject *resultobj = 0;
46031 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46032 wxString result;
46033 void *argp1 = 0 ;
46034 int res1 = 0 ;
46035 PyObject *swig_obj[1] ;
46036
46037 if (!args) SWIG_fail;
46038 swig_obj[0] = args;
46039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46040 if (!SWIG_IsOK(res1)) {
46041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46042 }
46043 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46044 {
46045 PyThreadState* __tstate = wxPyBeginAllowThreads();
46046 result = ((wxMenuItem const *)arg1)->GetLabel();
46047 wxPyEndAllowThreads(__tstate);
46048 if (PyErr_Occurred()) SWIG_fail;
46049 }
46050 {
46051 #if wxUSE_UNICODE
46052 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46053 #else
46054 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46055 #endif
46056 }
46057 return resultobj;
46058 fail:
46059 return NULL;
46060 }
46061
46062
46063 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46064 PyObject *resultobj = 0;
46065 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46066 wxString *result = 0 ;
46067 void *argp1 = 0 ;
46068 int res1 = 0 ;
46069 PyObject *swig_obj[1] ;
46070
46071 if (!args) SWIG_fail;
46072 swig_obj[0] = args;
46073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46074 if (!SWIG_IsOK(res1)) {
46075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46076 }
46077 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46078 {
46079 PyThreadState* __tstate = wxPyBeginAllowThreads();
46080 {
46081 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46082 result = (wxString *) &_result_ref;
46083 }
46084 wxPyEndAllowThreads(__tstate);
46085 if (PyErr_Occurred()) SWIG_fail;
46086 }
46087 {
46088 #if wxUSE_UNICODE
46089 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46090 #else
46091 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46092 #endif
46093 }
46094 return resultobj;
46095 fail:
46096 return NULL;
46097 }
46098
46099
46100 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46101 PyObject *resultobj = 0;
46102 wxString *arg1 = 0 ;
46103 wxString result;
46104 bool temp1 = false ;
46105 PyObject * obj0 = 0 ;
46106 char * kwnames[] = {
46107 (char *) "text", NULL
46108 };
46109
46110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46111 {
46112 arg1 = wxString_in_helper(obj0);
46113 if (arg1 == NULL) SWIG_fail;
46114 temp1 = true;
46115 }
46116 {
46117 PyThreadState* __tstate = wxPyBeginAllowThreads();
46118 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46119 wxPyEndAllowThreads(__tstate);
46120 if (PyErr_Occurred()) SWIG_fail;
46121 }
46122 {
46123 #if wxUSE_UNICODE
46124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46125 #else
46126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46127 #endif
46128 }
46129 {
46130 if (temp1)
46131 delete arg1;
46132 }
46133 return resultobj;
46134 fail:
46135 {
46136 if (temp1)
46137 delete arg1;
46138 }
46139 return NULL;
46140 }
46141
46142
46143 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46144 PyObject *resultobj = 0;
46145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46146 wxItemKind result;
46147 void *argp1 = 0 ;
46148 int res1 = 0 ;
46149 PyObject *swig_obj[1] ;
46150
46151 if (!args) SWIG_fail;
46152 swig_obj[0] = args;
46153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46154 if (!SWIG_IsOK(res1)) {
46155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46156 }
46157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46158 {
46159 PyThreadState* __tstate = wxPyBeginAllowThreads();
46160 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46161 wxPyEndAllowThreads(__tstate);
46162 if (PyErr_Occurred()) SWIG_fail;
46163 }
46164 resultobj = SWIG_From_int(static_cast< int >(result));
46165 return resultobj;
46166 fail:
46167 return NULL;
46168 }
46169
46170
46171 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46172 PyObject *resultobj = 0;
46173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46174 wxItemKind arg2 ;
46175 void *argp1 = 0 ;
46176 int res1 = 0 ;
46177 int val2 ;
46178 int ecode2 = 0 ;
46179 PyObject * obj0 = 0 ;
46180 PyObject * obj1 = 0 ;
46181 char * kwnames[] = {
46182 (char *) "self",(char *) "kind", NULL
46183 };
46184
46185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46187 if (!SWIG_IsOK(res1)) {
46188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46189 }
46190 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46191 ecode2 = SWIG_AsVal_int(obj1, &val2);
46192 if (!SWIG_IsOK(ecode2)) {
46193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46194 }
46195 arg2 = static_cast< wxItemKind >(val2);
46196 {
46197 PyThreadState* __tstate = wxPyBeginAllowThreads();
46198 (arg1)->SetKind(arg2);
46199 wxPyEndAllowThreads(__tstate);
46200 if (PyErr_Occurred()) SWIG_fail;
46201 }
46202 resultobj = SWIG_Py_Void();
46203 return resultobj;
46204 fail:
46205 return NULL;
46206 }
46207
46208
46209 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46210 PyObject *resultobj = 0;
46211 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46212 bool arg2 ;
46213 void *argp1 = 0 ;
46214 int res1 = 0 ;
46215 bool val2 ;
46216 int ecode2 = 0 ;
46217 PyObject * obj0 = 0 ;
46218 PyObject * obj1 = 0 ;
46219 char * kwnames[] = {
46220 (char *) "self",(char *) "checkable", NULL
46221 };
46222
46223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46225 if (!SWIG_IsOK(res1)) {
46226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46227 }
46228 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46229 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46230 if (!SWIG_IsOK(ecode2)) {
46231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46232 }
46233 arg2 = static_cast< bool >(val2);
46234 {
46235 PyThreadState* __tstate = wxPyBeginAllowThreads();
46236 (arg1)->SetCheckable(arg2);
46237 wxPyEndAllowThreads(__tstate);
46238 if (PyErr_Occurred()) SWIG_fail;
46239 }
46240 resultobj = SWIG_Py_Void();
46241 return resultobj;
46242 fail:
46243 return NULL;
46244 }
46245
46246
46247 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46248 PyObject *resultobj = 0;
46249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46250 bool result;
46251 void *argp1 = 0 ;
46252 int res1 = 0 ;
46253 PyObject *swig_obj[1] ;
46254
46255 if (!args) SWIG_fail;
46256 swig_obj[0] = args;
46257 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46258 if (!SWIG_IsOK(res1)) {
46259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46260 }
46261 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46262 {
46263 PyThreadState* __tstate = wxPyBeginAllowThreads();
46264 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46265 wxPyEndAllowThreads(__tstate);
46266 if (PyErr_Occurred()) SWIG_fail;
46267 }
46268 {
46269 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46270 }
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46278 PyObject *resultobj = 0;
46279 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46280 bool result;
46281 void *argp1 = 0 ;
46282 int res1 = 0 ;
46283 PyObject *swig_obj[1] ;
46284
46285 if (!args) SWIG_fail;
46286 swig_obj[0] = args;
46287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46288 if (!SWIG_IsOK(res1)) {
46289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46290 }
46291 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46292 {
46293 PyThreadState* __tstate = wxPyBeginAllowThreads();
46294 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46295 wxPyEndAllowThreads(__tstate);
46296 if (PyErr_Occurred()) SWIG_fail;
46297 }
46298 {
46299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46300 }
46301 return resultobj;
46302 fail:
46303 return NULL;
46304 }
46305
46306
46307 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46308 PyObject *resultobj = 0;
46309 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46310 wxMenu *arg2 = (wxMenu *) 0 ;
46311 void *argp1 = 0 ;
46312 int res1 = 0 ;
46313 void *argp2 = 0 ;
46314 int res2 = 0 ;
46315 PyObject * obj0 = 0 ;
46316 PyObject * obj1 = 0 ;
46317 char * kwnames[] = {
46318 (char *) "self",(char *) "menu", NULL
46319 };
46320
46321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46322 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46323 if (!SWIG_IsOK(res1)) {
46324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46325 }
46326 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46327 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46328 if (!SWIG_IsOK(res2)) {
46329 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46330 }
46331 arg2 = reinterpret_cast< wxMenu * >(argp2);
46332 {
46333 PyThreadState* __tstate = wxPyBeginAllowThreads();
46334 (arg1)->SetSubMenu(arg2);
46335 wxPyEndAllowThreads(__tstate);
46336 if (PyErr_Occurred()) SWIG_fail;
46337 }
46338 resultobj = SWIG_Py_Void();
46339 return resultobj;
46340 fail:
46341 return NULL;
46342 }
46343
46344
46345 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46346 PyObject *resultobj = 0;
46347 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46348 wxMenu *result = 0 ;
46349 void *argp1 = 0 ;
46350 int res1 = 0 ;
46351 PyObject *swig_obj[1] ;
46352
46353 if (!args) SWIG_fail;
46354 swig_obj[0] = args;
46355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46356 if (!SWIG_IsOK(res1)) {
46357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46358 }
46359 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46360 {
46361 PyThreadState* __tstate = wxPyBeginAllowThreads();
46362 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46363 wxPyEndAllowThreads(__tstate);
46364 if (PyErr_Occurred()) SWIG_fail;
46365 }
46366 {
46367 resultobj = wxPyMake_wxObject(result, 0);
46368 }
46369 return resultobj;
46370 fail:
46371 return NULL;
46372 }
46373
46374
46375 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46376 PyObject *resultobj = 0;
46377 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46378 bool arg2 = (bool) true ;
46379 void *argp1 = 0 ;
46380 int res1 = 0 ;
46381 bool val2 ;
46382 int ecode2 = 0 ;
46383 PyObject * obj0 = 0 ;
46384 PyObject * obj1 = 0 ;
46385 char * kwnames[] = {
46386 (char *) "self",(char *) "enable", NULL
46387 };
46388
46389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46391 if (!SWIG_IsOK(res1)) {
46392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46393 }
46394 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46395 if (obj1) {
46396 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46397 if (!SWIG_IsOK(ecode2)) {
46398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46399 }
46400 arg2 = static_cast< bool >(val2);
46401 }
46402 {
46403 PyThreadState* __tstate = wxPyBeginAllowThreads();
46404 (arg1)->Enable(arg2);
46405 wxPyEndAllowThreads(__tstate);
46406 if (PyErr_Occurred()) SWIG_fail;
46407 }
46408 resultobj = SWIG_Py_Void();
46409 return resultobj;
46410 fail:
46411 return NULL;
46412 }
46413
46414
46415 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46416 PyObject *resultobj = 0;
46417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46418 bool result;
46419 void *argp1 = 0 ;
46420 int res1 = 0 ;
46421 PyObject *swig_obj[1] ;
46422
46423 if (!args) SWIG_fail;
46424 swig_obj[0] = args;
46425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46426 if (!SWIG_IsOK(res1)) {
46427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46428 }
46429 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46430 {
46431 PyThreadState* __tstate = wxPyBeginAllowThreads();
46432 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46433 wxPyEndAllowThreads(__tstate);
46434 if (PyErr_Occurred()) SWIG_fail;
46435 }
46436 {
46437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46438 }
46439 return resultobj;
46440 fail:
46441 return NULL;
46442 }
46443
46444
46445 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46446 PyObject *resultobj = 0;
46447 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46448 bool arg2 = (bool) true ;
46449 void *argp1 = 0 ;
46450 int res1 = 0 ;
46451 bool val2 ;
46452 int ecode2 = 0 ;
46453 PyObject * obj0 = 0 ;
46454 PyObject * obj1 = 0 ;
46455 char * kwnames[] = {
46456 (char *) "self",(char *) "check", NULL
46457 };
46458
46459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46461 if (!SWIG_IsOK(res1)) {
46462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46463 }
46464 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46465 if (obj1) {
46466 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46467 if (!SWIG_IsOK(ecode2)) {
46468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46469 }
46470 arg2 = static_cast< bool >(val2);
46471 }
46472 {
46473 PyThreadState* __tstate = wxPyBeginAllowThreads();
46474 (arg1)->Check(arg2);
46475 wxPyEndAllowThreads(__tstate);
46476 if (PyErr_Occurred()) SWIG_fail;
46477 }
46478 resultobj = SWIG_Py_Void();
46479 return resultobj;
46480 fail:
46481 return NULL;
46482 }
46483
46484
46485 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46486 PyObject *resultobj = 0;
46487 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46488 bool result;
46489 void *argp1 = 0 ;
46490 int res1 = 0 ;
46491 PyObject *swig_obj[1] ;
46492
46493 if (!args) SWIG_fail;
46494 swig_obj[0] = args;
46495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46496 if (!SWIG_IsOK(res1)) {
46497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46498 }
46499 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46500 {
46501 PyThreadState* __tstate = wxPyBeginAllowThreads();
46502 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46503 wxPyEndAllowThreads(__tstate);
46504 if (PyErr_Occurred()) SWIG_fail;
46505 }
46506 {
46507 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46508 }
46509 return resultobj;
46510 fail:
46511 return NULL;
46512 }
46513
46514
46515 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46516 PyObject *resultobj = 0;
46517 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46518 void *argp1 = 0 ;
46519 int res1 = 0 ;
46520 PyObject *swig_obj[1] ;
46521
46522 if (!args) SWIG_fail;
46523 swig_obj[0] = args;
46524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46525 if (!SWIG_IsOK(res1)) {
46526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46527 }
46528 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46529 {
46530 PyThreadState* __tstate = wxPyBeginAllowThreads();
46531 (arg1)->Toggle();
46532 wxPyEndAllowThreads(__tstate);
46533 if (PyErr_Occurred()) SWIG_fail;
46534 }
46535 resultobj = SWIG_Py_Void();
46536 return resultobj;
46537 fail:
46538 return NULL;
46539 }
46540
46541
46542 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46543 PyObject *resultobj = 0;
46544 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46545 wxString *arg2 = 0 ;
46546 void *argp1 = 0 ;
46547 int res1 = 0 ;
46548 bool temp2 = false ;
46549 PyObject * obj0 = 0 ;
46550 PyObject * obj1 = 0 ;
46551 char * kwnames[] = {
46552 (char *) "self",(char *) "str", NULL
46553 };
46554
46555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46557 if (!SWIG_IsOK(res1)) {
46558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46559 }
46560 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46561 {
46562 arg2 = wxString_in_helper(obj1);
46563 if (arg2 == NULL) SWIG_fail;
46564 temp2 = true;
46565 }
46566 {
46567 PyThreadState* __tstate = wxPyBeginAllowThreads();
46568 (arg1)->SetHelp((wxString const &)*arg2);
46569 wxPyEndAllowThreads(__tstate);
46570 if (PyErr_Occurred()) SWIG_fail;
46571 }
46572 resultobj = SWIG_Py_Void();
46573 {
46574 if (temp2)
46575 delete arg2;
46576 }
46577 return resultobj;
46578 fail:
46579 {
46580 if (temp2)
46581 delete arg2;
46582 }
46583 return NULL;
46584 }
46585
46586
46587 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46588 PyObject *resultobj = 0;
46589 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46590 wxString *result = 0 ;
46591 void *argp1 = 0 ;
46592 int res1 = 0 ;
46593 PyObject *swig_obj[1] ;
46594
46595 if (!args) SWIG_fail;
46596 swig_obj[0] = args;
46597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46598 if (!SWIG_IsOK(res1)) {
46599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46600 }
46601 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46602 {
46603 PyThreadState* __tstate = wxPyBeginAllowThreads();
46604 {
46605 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46606 result = (wxString *) &_result_ref;
46607 }
46608 wxPyEndAllowThreads(__tstate);
46609 if (PyErr_Occurred()) SWIG_fail;
46610 }
46611 {
46612 #if wxUSE_UNICODE
46613 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46614 #else
46615 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46616 #endif
46617 }
46618 return resultobj;
46619 fail:
46620 return NULL;
46621 }
46622
46623
46624 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46625 PyObject *resultobj = 0;
46626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46627 wxAcceleratorEntry *result = 0 ;
46628 void *argp1 = 0 ;
46629 int res1 = 0 ;
46630 PyObject *swig_obj[1] ;
46631
46632 if (!args) SWIG_fail;
46633 swig_obj[0] = args;
46634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46635 if (!SWIG_IsOK(res1)) {
46636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46637 }
46638 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46639 {
46640 PyThreadState* __tstate = wxPyBeginAllowThreads();
46641 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46642 wxPyEndAllowThreads(__tstate);
46643 if (PyErr_Occurred()) SWIG_fail;
46644 }
46645 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46646 return resultobj;
46647 fail:
46648 return NULL;
46649 }
46650
46651
46652 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46653 PyObject *resultobj = 0;
46654 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46655 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46656 void *argp1 = 0 ;
46657 int res1 = 0 ;
46658 void *argp2 = 0 ;
46659 int res2 = 0 ;
46660 PyObject * obj0 = 0 ;
46661 PyObject * obj1 = 0 ;
46662 char * kwnames[] = {
46663 (char *) "self",(char *) "accel", NULL
46664 };
46665
46666 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46667 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46668 if (!SWIG_IsOK(res1)) {
46669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46670 }
46671 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46672 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46673 if (!SWIG_IsOK(res2)) {
46674 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46675 }
46676 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46677 {
46678 PyThreadState* __tstate = wxPyBeginAllowThreads();
46679 (arg1)->SetAccel(arg2);
46680 wxPyEndAllowThreads(__tstate);
46681 if (PyErr_Occurred()) SWIG_fail;
46682 }
46683 resultobj = SWIG_Py_Void();
46684 return resultobj;
46685 fail:
46686 return NULL;
46687 }
46688
46689
46690 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46691 PyObject *resultobj = 0;
46692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46693 wxBitmap *arg2 = 0 ;
46694 void *argp1 = 0 ;
46695 int res1 = 0 ;
46696 void *argp2 = 0 ;
46697 int res2 = 0 ;
46698 PyObject * obj0 = 0 ;
46699 PyObject * obj1 = 0 ;
46700 char * kwnames[] = {
46701 (char *) "self",(char *) "bitmap", NULL
46702 };
46703
46704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46706 if (!SWIG_IsOK(res1)) {
46707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46708 }
46709 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46710 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46711 if (!SWIG_IsOK(res2)) {
46712 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46713 }
46714 if (!argp2) {
46715 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46716 }
46717 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46718 {
46719 PyThreadState* __tstate = wxPyBeginAllowThreads();
46720 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46721 wxPyEndAllowThreads(__tstate);
46722 if (PyErr_Occurred()) SWIG_fail;
46723 }
46724 resultobj = SWIG_Py_Void();
46725 return resultobj;
46726 fail:
46727 return NULL;
46728 }
46729
46730
46731 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46732 PyObject *resultobj = 0;
46733 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46734 wxBitmap *result = 0 ;
46735 void *argp1 = 0 ;
46736 int res1 = 0 ;
46737 PyObject *swig_obj[1] ;
46738
46739 if (!args) SWIG_fail;
46740 swig_obj[0] = args;
46741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46742 if (!SWIG_IsOK(res1)) {
46743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46744 }
46745 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46746 {
46747 PyThreadState* __tstate = wxPyBeginAllowThreads();
46748 {
46749 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46750 result = (wxBitmap *) &_result_ref;
46751 }
46752 wxPyEndAllowThreads(__tstate);
46753 if (PyErr_Occurred()) SWIG_fail;
46754 }
46755 {
46756 wxBitmap* resultptr = new wxBitmap(*result);
46757 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46758 }
46759 return resultobj;
46760 fail:
46761 return NULL;
46762 }
46763
46764
46765 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46766 PyObject *resultobj = 0;
46767 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46768 wxFont *arg2 = 0 ;
46769 void *argp1 = 0 ;
46770 int res1 = 0 ;
46771 void *argp2 = 0 ;
46772 int res2 = 0 ;
46773 PyObject * obj0 = 0 ;
46774 PyObject * obj1 = 0 ;
46775 char * kwnames[] = {
46776 (char *) "self",(char *) "font", NULL
46777 };
46778
46779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46781 if (!SWIG_IsOK(res1)) {
46782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46783 }
46784 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46785 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46786 if (!SWIG_IsOK(res2)) {
46787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46788 }
46789 if (!argp2) {
46790 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46791 }
46792 arg2 = reinterpret_cast< wxFont * >(argp2);
46793 {
46794 PyThreadState* __tstate = wxPyBeginAllowThreads();
46795 (arg1)->SetFont((wxFont const &)*arg2);
46796 wxPyEndAllowThreads(__tstate);
46797 if (PyErr_Occurred()) SWIG_fail;
46798 }
46799 resultobj = SWIG_Py_Void();
46800 return resultobj;
46801 fail:
46802 return NULL;
46803 }
46804
46805
46806 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46807 PyObject *resultobj = 0;
46808 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46809 wxFont result;
46810 void *argp1 = 0 ;
46811 int res1 = 0 ;
46812 PyObject *swig_obj[1] ;
46813
46814 if (!args) SWIG_fail;
46815 swig_obj[0] = args;
46816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46817 if (!SWIG_IsOK(res1)) {
46818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46819 }
46820 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46821 {
46822 PyThreadState* __tstate = wxPyBeginAllowThreads();
46823 result = (arg1)->GetFont();
46824 wxPyEndAllowThreads(__tstate);
46825 if (PyErr_Occurred()) SWIG_fail;
46826 }
46827 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46828 return resultobj;
46829 fail:
46830 return NULL;
46831 }
46832
46833
46834 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46835 PyObject *resultobj = 0;
46836 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46837 wxColour *arg2 = 0 ;
46838 void *argp1 = 0 ;
46839 int res1 = 0 ;
46840 wxColour temp2 ;
46841 PyObject * obj0 = 0 ;
46842 PyObject * obj1 = 0 ;
46843 char * kwnames[] = {
46844 (char *) "self",(char *) "colText", NULL
46845 };
46846
46847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46849 if (!SWIG_IsOK(res1)) {
46850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46851 }
46852 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46853 {
46854 arg2 = &temp2;
46855 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46856 }
46857 {
46858 PyThreadState* __tstate = wxPyBeginAllowThreads();
46859 (arg1)->SetTextColour((wxColour const &)*arg2);
46860 wxPyEndAllowThreads(__tstate);
46861 if (PyErr_Occurred()) SWIG_fail;
46862 }
46863 resultobj = SWIG_Py_Void();
46864 return resultobj;
46865 fail:
46866 return NULL;
46867 }
46868
46869
46870 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46871 PyObject *resultobj = 0;
46872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46873 wxColour result;
46874 void *argp1 = 0 ;
46875 int res1 = 0 ;
46876 PyObject *swig_obj[1] ;
46877
46878 if (!args) SWIG_fail;
46879 swig_obj[0] = args;
46880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46881 if (!SWIG_IsOK(res1)) {
46882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46883 }
46884 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46885 {
46886 PyThreadState* __tstate = wxPyBeginAllowThreads();
46887 result = (arg1)->GetTextColour();
46888 wxPyEndAllowThreads(__tstate);
46889 if (PyErr_Occurred()) SWIG_fail;
46890 }
46891 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46892 return resultobj;
46893 fail:
46894 return NULL;
46895 }
46896
46897
46898 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46899 PyObject *resultobj = 0;
46900 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46901 wxColour *arg2 = 0 ;
46902 void *argp1 = 0 ;
46903 int res1 = 0 ;
46904 wxColour temp2 ;
46905 PyObject * obj0 = 0 ;
46906 PyObject * obj1 = 0 ;
46907 char * kwnames[] = {
46908 (char *) "self",(char *) "colBack", NULL
46909 };
46910
46911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46913 if (!SWIG_IsOK(res1)) {
46914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46915 }
46916 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46917 {
46918 arg2 = &temp2;
46919 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46920 }
46921 {
46922 PyThreadState* __tstate = wxPyBeginAllowThreads();
46923 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
46924 wxPyEndAllowThreads(__tstate);
46925 if (PyErr_Occurred()) SWIG_fail;
46926 }
46927 resultobj = SWIG_Py_Void();
46928 return resultobj;
46929 fail:
46930 return NULL;
46931 }
46932
46933
46934 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46935 PyObject *resultobj = 0;
46936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46937 wxColour result;
46938 void *argp1 = 0 ;
46939 int res1 = 0 ;
46940 PyObject *swig_obj[1] ;
46941
46942 if (!args) SWIG_fail;
46943 swig_obj[0] = args;
46944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46945 if (!SWIG_IsOK(res1)) {
46946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46947 }
46948 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46949 {
46950 PyThreadState* __tstate = wxPyBeginAllowThreads();
46951 result = (arg1)->GetBackgroundColour();
46952 wxPyEndAllowThreads(__tstate);
46953 if (PyErr_Occurred()) SWIG_fail;
46954 }
46955 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46956 return resultobj;
46957 fail:
46958 return NULL;
46959 }
46960
46961
46962 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46963 PyObject *resultobj = 0;
46964 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46965 wxBitmap *arg2 = 0 ;
46966 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46967 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46968 void *argp1 = 0 ;
46969 int res1 = 0 ;
46970 void *argp2 = 0 ;
46971 int res2 = 0 ;
46972 void *argp3 = 0 ;
46973 int res3 = 0 ;
46974 PyObject * obj0 = 0 ;
46975 PyObject * obj1 = 0 ;
46976 PyObject * obj2 = 0 ;
46977 char * kwnames[] = {
46978 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46979 };
46980
46981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46983 if (!SWIG_IsOK(res1)) {
46984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46985 }
46986 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46987 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46988 if (!SWIG_IsOK(res2)) {
46989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46990 }
46991 if (!argp2) {
46992 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46993 }
46994 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46995 if (obj2) {
46996 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46997 if (!SWIG_IsOK(res3)) {
46998 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46999 }
47000 if (!argp3) {
47001 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47002 }
47003 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47004 }
47005 {
47006 PyThreadState* __tstate = wxPyBeginAllowThreads();
47007 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47008 wxPyEndAllowThreads(__tstate);
47009 if (PyErr_Occurred()) SWIG_fail;
47010 }
47011 resultobj = SWIG_Py_Void();
47012 return resultobj;
47013 fail:
47014 return NULL;
47015 }
47016
47017
47018 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47019 PyObject *resultobj = 0;
47020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47021 wxBitmap *arg2 = 0 ;
47022 void *argp1 = 0 ;
47023 int res1 = 0 ;
47024 void *argp2 = 0 ;
47025 int res2 = 0 ;
47026 PyObject * obj0 = 0 ;
47027 PyObject * obj1 = 0 ;
47028 char * kwnames[] = {
47029 (char *) "self",(char *) "bmpDisabled", NULL
47030 };
47031
47032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47034 if (!SWIG_IsOK(res1)) {
47035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47036 }
47037 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47038 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47039 if (!SWIG_IsOK(res2)) {
47040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47041 }
47042 if (!argp2) {
47043 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47044 }
47045 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47046 {
47047 PyThreadState* __tstate = wxPyBeginAllowThreads();
47048 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47049 wxPyEndAllowThreads(__tstate);
47050 if (PyErr_Occurred()) SWIG_fail;
47051 }
47052 resultobj = SWIG_Py_Void();
47053 return resultobj;
47054 fail:
47055 return NULL;
47056 }
47057
47058
47059 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47060 PyObject *resultobj = 0;
47061 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47062 wxBitmap *result = 0 ;
47063 void *argp1 = 0 ;
47064 int res1 = 0 ;
47065 PyObject *swig_obj[1] ;
47066
47067 if (!args) SWIG_fail;
47068 swig_obj[0] = args;
47069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47070 if (!SWIG_IsOK(res1)) {
47071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47072 }
47073 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47074 {
47075 PyThreadState* __tstate = wxPyBeginAllowThreads();
47076 {
47077 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47078 result = (wxBitmap *) &_result_ref;
47079 }
47080 wxPyEndAllowThreads(__tstate);
47081 if (PyErr_Occurred()) SWIG_fail;
47082 }
47083 {
47084 wxBitmap* resultptr = new wxBitmap(*result);
47085 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47086 }
47087 return resultobj;
47088 fail:
47089 return NULL;
47090 }
47091
47092
47093 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47094 PyObject *resultobj = 0;
47095 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47096 int arg2 ;
47097 void *argp1 = 0 ;
47098 int res1 = 0 ;
47099 int val2 ;
47100 int ecode2 = 0 ;
47101 PyObject * obj0 = 0 ;
47102 PyObject * obj1 = 0 ;
47103 char * kwnames[] = {
47104 (char *) "self",(char *) "nWidth", NULL
47105 };
47106
47107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47109 if (!SWIG_IsOK(res1)) {
47110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47111 }
47112 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47113 ecode2 = SWIG_AsVal_int(obj1, &val2);
47114 if (!SWIG_IsOK(ecode2)) {
47115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47116 }
47117 arg2 = static_cast< int >(val2);
47118 {
47119 PyThreadState* __tstate = wxPyBeginAllowThreads();
47120 (arg1)->SetMarginWidth(arg2);
47121 wxPyEndAllowThreads(__tstate);
47122 if (PyErr_Occurred()) SWIG_fail;
47123 }
47124 resultobj = SWIG_Py_Void();
47125 return resultobj;
47126 fail:
47127 return NULL;
47128 }
47129
47130
47131 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47132 PyObject *resultobj = 0;
47133 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47134 int result;
47135 void *argp1 = 0 ;
47136 int res1 = 0 ;
47137 PyObject *swig_obj[1] ;
47138
47139 if (!args) SWIG_fail;
47140 swig_obj[0] = args;
47141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47142 if (!SWIG_IsOK(res1)) {
47143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47144 }
47145 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47146 {
47147 PyThreadState* __tstate = wxPyBeginAllowThreads();
47148 result = (int)(arg1)->GetMarginWidth();
47149 wxPyEndAllowThreads(__tstate);
47150 if (PyErr_Occurred()) SWIG_fail;
47151 }
47152 resultobj = SWIG_From_int(static_cast< int >(result));
47153 return resultobj;
47154 fail:
47155 return NULL;
47156 }
47157
47158
47159 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47160 PyObject *resultobj = 0;
47161 int result;
47162
47163 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47164 {
47165 PyThreadState* __tstate = wxPyBeginAllowThreads();
47166 result = (int)wxMenuItem::GetDefaultMarginWidth();
47167 wxPyEndAllowThreads(__tstate);
47168 if (PyErr_Occurred()) SWIG_fail;
47169 }
47170 resultobj = SWIG_From_int(static_cast< int >(result));
47171 return resultobj;
47172 fail:
47173 return NULL;
47174 }
47175
47176
47177 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47178 PyObject *resultobj = 0;
47179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47180 bool result;
47181 void *argp1 = 0 ;
47182 int res1 = 0 ;
47183 PyObject *swig_obj[1] ;
47184
47185 if (!args) SWIG_fail;
47186 swig_obj[0] = args;
47187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47188 if (!SWIG_IsOK(res1)) {
47189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47190 }
47191 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47192 {
47193 PyThreadState* __tstate = wxPyBeginAllowThreads();
47194 result = (bool)(arg1)->IsOwnerDrawn();
47195 wxPyEndAllowThreads(__tstate);
47196 if (PyErr_Occurred()) SWIG_fail;
47197 }
47198 {
47199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47200 }
47201 return resultobj;
47202 fail:
47203 return NULL;
47204 }
47205
47206
47207 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47208 PyObject *resultobj = 0;
47209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47210 bool arg2 = (bool) true ;
47211 void *argp1 = 0 ;
47212 int res1 = 0 ;
47213 bool val2 ;
47214 int ecode2 = 0 ;
47215 PyObject * obj0 = 0 ;
47216 PyObject * obj1 = 0 ;
47217 char * kwnames[] = {
47218 (char *) "self",(char *) "ownerDrawn", NULL
47219 };
47220
47221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47223 if (!SWIG_IsOK(res1)) {
47224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47225 }
47226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47227 if (obj1) {
47228 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47229 if (!SWIG_IsOK(ecode2)) {
47230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47231 }
47232 arg2 = static_cast< bool >(val2);
47233 }
47234 {
47235 PyThreadState* __tstate = wxPyBeginAllowThreads();
47236 (arg1)->SetOwnerDrawn(arg2);
47237 wxPyEndAllowThreads(__tstate);
47238 if (PyErr_Occurred()) SWIG_fail;
47239 }
47240 resultobj = SWIG_Py_Void();
47241 return resultobj;
47242 fail:
47243 return NULL;
47244 }
47245
47246
47247 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47248 PyObject *resultobj = 0;
47249 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47250 void *argp1 = 0 ;
47251 int res1 = 0 ;
47252 PyObject *swig_obj[1] ;
47253
47254 if (!args) SWIG_fail;
47255 swig_obj[0] = args;
47256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47257 if (!SWIG_IsOK(res1)) {
47258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47259 }
47260 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47261 {
47262 PyThreadState* __tstate = wxPyBeginAllowThreads();
47263 (arg1)->ResetOwnerDrawn();
47264 wxPyEndAllowThreads(__tstate);
47265 if (PyErr_Occurred()) SWIG_fail;
47266 }
47267 resultobj = SWIG_Py_Void();
47268 return resultobj;
47269 fail:
47270 return NULL;
47271 }
47272
47273
47274 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47275 PyObject *obj;
47276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47277 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47278 return SWIG_Py_Void();
47279 }
47280
47281 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47282 return SWIG_Python_InitShadowInstance(args);
47283 }
47284
47285 SWIGINTERN int ControlNameStr_set(PyObject *) {
47286 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47287 return 1;
47288 }
47289
47290
47291 SWIGINTERN PyObject *ControlNameStr_get(void) {
47292 PyObject *pyobj = 0;
47293
47294 {
47295 #if wxUSE_UNICODE
47296 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47297 #else
47298 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47299 #endif
47300 }
47301 return pyobj;
47302 }
47303
47304
47305 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47306 PyObject *resultobj = 0;
47307 wxWindow *arg1 = (wxWindow *) 0 ;
47308 int arg2 = (int) -1 ;
47309 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47310 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47311 wxSize const &arg4_defvalue = wxDefaultSize ;
47312 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47313 long arg5 = (long) 0 ;
47314 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47315 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47316 wxString const &arg7_defvalue = wxPyControlNameStr ;
47317 wxString *arg7 = (wxString *) &arg7_defvalue ;
47318 wxControl *result = 0 ;
47319 void *argp1 = 0 ;
47320 int res1 = 0 ;
47321 int val2 ;
47322 int ecode2 = 0 ;
47323 wxPoint temp3 ;
47324 wxSize temp4 ;
47325 long val5 ;
47326 int ecode5 = 0 ;
47327 void *argp6 = 0 ;
47328 int res6 = 0 ;
47329 bool temp7 = false ;
47330 PyObject * obj0 = 0 ;
47331 PyObject * obj1 = 0 ;
47332 PyObject * obj2 = 0 ;
47333 PyObject * obj3 = 0 ;
47334 PyObject * obj4 = 0 ;
47335 PyObject * obj5 = 0 ;
47336 PyObject * obj6 = 0 ;
47337 char * kwnames[] = {
47338 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47339 };
47340
47341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47343 if (!SWIG_IsOK(res1)) {
47344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47345 }
47346 arg1 = reinterpret_cast< wxWindow * >(argp1);
47347 if (obj1) {
47348 ecode2 = SWIG_AsVal_int(obj1, &val2);
47349 if (!SWIG_IsOK(ecode2)) {
47350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47351 }
47352 arg2 = static_cast< int >(val2);
47353 }
47354 if (obj2) {
47355 {
47356 arg3 = &temp3;
47357 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47358 }
47359 }
47360 if (obj3) {
47361 {
47362 arg4 = &temp4;
47363 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47364 }
47365 }
47366 if (obj4) {
47367 ecode5 = SWIG_AsVal_long(obj4, &val5);
47368 if (!SWIG_IsOK(ecode5)) {
47369 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47370 }
47371 arg5 = static_cast< long >(val5);
47372 }
47373 if (obj5) {
47374 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47375 if (!SWIG_IsOK(res6)) {
47376 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47377 }
47378 if (!argp6) {
47379 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47380 }
47381 arg6 = reinterpret_cast< wxValidator * >(argp6);
47382 }
47383 if (obj6) {
47384 {
47385 arg7 = wxString_in_helper(obj6);
47386 if (arg7 == NULL) SWIG_fail;
47387 temp7 = true;
47388 }
47389 }
47390 {
47391 if (!wxPyCheckForApp()) SWIG_fail;
47392 PyThreadState* __tstate = wxPyBeginAllowThreads();
47393 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47394 wxPyEndAllowThreads(__tstate);
47395 if (PyErr_Occurred()) SWIG_fail;
47396 }
47397 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47398 {
47399 if (temp7)
47400 delete arg7;
47401 }
47402 return resultobj;
47403 fail:
47404 {
47405 if (temp7)
47406 delete arg7;
47407 }
47408 return NULL;
47409 }
47410
47411
47412 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47413 PyObject *resultobj = 0;
47414 wxControl *result = 0 ;
47415
47416 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47417 {
47418 if (!wxPyCheckForApp()) SWIG_fail;
47419 PyThreadState* __tstate = wxPyBeginAllowThreads();
47420 result = (wxControl *)new wxControl();
47421 wxPyEndAllowThreads(__tstate);
47422 if (PyErr_Occurred()) SWIG_fail;
47423 }
47424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47425 return resultobj;
47426 fail:
47427 return NULL;
47428 }
47429
47430
47431 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47432 PyObject *resultobj = 0;
47433 wxControl *arg1 = (wxControl *) 0 ;
47434 wxWindow *arg2 = (wxWindow *) 0 ;
47435 int arg3 = (int) -1 ;
47436 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47437 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47438 wxSize const &arg5_defvalue = wxDefaultSize ;
47439 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47440 long arg6 = (long) 0 ;
47441 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47442 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47443 wxString const &arg8_defvalue = wxPyControlNameStr ;
47444 wxString *arg8 = (wxString *) &arg8_defvalue ;
47445 bool result;
47446 void *argp1 = 0 ;
47447 int res1 = 0 ;
47448 void *argp2 = 0 ;
47449 int res2 = 0 ;
47450 int val3 ;
47451 int ecode3 = 0 ;
47452 wxPoint temp4 ;
47453 wxSize temp5 ;
47454 long val6 ;
47455 int ecode6 = 0 ;
47456 void *argp7 = 0 ;
47457 int res7 = 0 ;
47458 bool temp8 = false ;
47459 PyObject * obj0 = 0 ;
47460 PyObject * obj1 = 0 ;
47461 PyObject * obj2 = 0 ;
47462 PyObject * obj3 = 0 ;
47463 PyObject * obj4 = 0 ;
47464 PyObject * obj5 = 0 ;
47465 PyObject * obj6 = 0 ;
47466 PyObject * obj7 = 0 ;
47467 char * kwnames[] = {
47468 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47469 };
47470
47471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47473 if (!SWIG_IsOK(res1)) {
47474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47475 }
47476 arg1 = reinterpret_cast< wxControl * >(argp1);
47477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47478 if (!SWIG_IsOK(res2)) {
47479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47480 }
47481 arg2 = reinterpret_cast< wxWindow * >(argp2);
47482 if (obj2) {
47483 ecode3 = SWIG_AsVal_int(obj2, &val3);
47484 if (!SWIG_IsOK(ecode3)) {
47485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47486 }
47487 arg3 = static_cast< int >(val3);
47488 }
47489 if (obj3) {
47490 {
47491 arg4 = &temp4;
47492 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47493 }
47494 }
47495 if (obj4) {
47496 {
47497 arg5 = &temp5;
47498 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47499 }
47500 }
47501 if (obj5) {
47502 ecode6 = SWIG_AsVal_long(obj5, &val6);
47503 if (!SWIG_IsOK(ecode6)) {
47504 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47505 }
47506 arg6 = static_cast< long >(val6);
47507 }
47508 if (obj6) {
47509 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47510 if (!SWIG_IsOK(res7)) {
47511 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47512 }
47513 if (!argp7) {
47514 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47515 }
47516 arg7 = reinterpret_cast< wxValidator * >(argp7);
47517 }
47518 if (obj7) {
47519 {
47520 arg8 = wxString_in_helper(obj7);
47521 if (arg8 == NULL) SWIG_fail;
47522 temp8 = true;
47523 }
47524 }
47525 {
47526 PyThreadState* __tstate = wxPyBeginAllowThreads();
47527 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47528 wxPyEndAllowThreads(__tstate);
47529 if (PyErr_Occurred()) SWIG_fail;
47530 }
47531 {
47532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47533 }
47534 {
47535 if (temp8)
47536 delete arg8;
47537 }
47538 return resultobj;
47539 fail:
47540 {
47541 if (temp8)
47542 delete arg8;
47543 }
47544 return NULL;
47545 }
47546
47547
47548 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47549 PyObject *resultobj = 0;
47550 wxControl *arg1 = (wxControl *) 0 ;
47551 int result;
47552 void *argp1 = 0 ;
47553 int res1 = 0 ;
47554 PyObject *swig_obj[1] ;
47555
47556 if (!args) SWIG_fail;
47557 swig_obj[0] = args;
47558 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47559 if (!SWIG_IsOK(res1)) {
47560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47561 }
47562 arg1 = reinterpret_cast< wxControl * >(argp1);
47563 {
47564 PyThreadState* __tstate = wxPyBeginAllowThreads();
47565 result = (int)((wxControl const *)arg1)->GetAlignment();
47566 wxPyEndAllowThreads(__tstate);
47567 if (PyErr_Occurred()) SWIG_fail;
47568 }
47569 resultobj = SWIG_From_int(static_cast< int >(result));
47570 return resultobj;
47571 fail:
47572 return NULL;
47573 }
47574
47575
47576 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47577 PyObject *resultobj = 0;
47578 wxControl *arg1 = (wxControl *) 0 ;
47579 wxString result;
47580 void *argp1 = 0 ;
47581 int res1 = 0 ;
47582 PyObject *swig_obj[1] ;
47583
47584 if (!args) SWIG_fail;
47585 swig_obj[0] = args;
47586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47587 if (!SWIG_IsOK(res1)) {
47588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47589 }
47590 arg1 = reinterpret_cast< wxControl * >(argp1);
47591 {
47592 PyThreadState* __tstate = wxPyBeginAllowThreads();
47593 result = ((wxControl const *)arg1)->GetLabelText();
47594 wxPyEndAllowThreads(__tstate);
47595 if (PyErr_Occurred()) SWIG_fail;
47596 }
47597 {
47598 #if wxUSE_UNICODE
47599 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47600 #else
47601 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47602 #endif
47603 }
47604 return resultobj;
47605 fail:
47606 return NULL;
47607 }
47608
47609
47610 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47611 PyObject *resultobj = 0;
47612 wxControl *arg1 = (wxControl *) 0 ;
47613 wxCommandEvent *arg2 = 0 ;
47614 void *argp1 = 0 ;
47615 int res1 = 0 ;
47616 void *argp2 = 0 ;
47617 int res2 = 0 ;
47618 PyObject * obj0 = 0 ;
47619 PyObject * obj1 = 0 ;
47620 char * kwnames[] = {
47621 (char *) "self",(char *) "event", NULL
47622 };
47623
47624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47626 if (!SWIG_IsOK(res1)) {
47627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47628 }
47629 arg1 = reinterpret_cast< wxControl * >(argp1);
47630 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47631 if (!SWIG_IsOK(res2)) {
47632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47633 }
47634 if (!argp2) {
47635 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47636 }
47637 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47638 {
47639 PyThreadState* __tstate = wxPyBeginAllowThreads();
47640 (arg1)->Command(*arg2);
47641 wxPyEndAllowThreads(__tstate);
47642 if (PyErr_Occurred()) SWIG_fail;
47643 }
47644 resultobj = SWIG_Py_Void();
47645 return resultobj;
47646 fail:
47647 return NULL;
47648 }
47649
47650
47651 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47652 PyObject *resultobj = 0;
47653 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47654 SwigValueWrapper<wxVisualAttributes > result;
47655 int val1 ;
47656 int ecode1 = 0 ;
47657 PyObject * obj0 = 0 ;
47658 char * kwnames[] = {
47659 (char *) "variant", NULL
47660 };
47661
47662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47663 if (obj0) {
47664 ecode1 = SWIG_AsVal_int(obj0, &val1);
47665 if (!SWIG_IsOK(ecode1)) {
47666 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47667 }
47668 arg1 = static_cast< wxWindowVariant >(val1);
47669 }
47670 {
47671 if (!wxPyCheckForApp()) SWIG_fail;
47672 PyThreadState* __tstate = wxPyBeginAllowThreads();
47673 result = wxControl::GetClassDefaultAttributes(arg1);
47674 wxPyEndAllowThreads(__tstate);
47675 if (PyErr_Occurred()) SWIG_fail;
47676 }
47677 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47678 return resultobj;
47679 fail:
47680 return NULL;
47681 }
47682
47683
47684 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47685 PyObject *obj;
47686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47687 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47688 return SWIG_Py_Void();
47689 }
47690
47691 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47692 return SWIG_Python_InitShadowInstance(args);
47693 }
47694
47695 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47696 PyObject *resultobj = 0;
47697 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47698 wxString *arg2 = 0 ;
47699 PyObject *arg3 = (PyObject *) NULL ;
47700 int result;
47701 void *argp1 = 0 ;
47702 int res1 = 0 ;
47703 bool temp2 = false ;
47704 PyObject * obj0 = 0 ;
47705 PyObject * obj1 = 0 ;
47706 PyObject * obj2 = 0 ;
47707 char * kwnames[] = {
47708 (char *) "self",(char *) "item",(char *) "clientData", NULL
47709 };
47710
47711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47713 if (!SWIG_IsOK(res1)) {
47714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47715 }
47716 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47717 {
47718 arg2 = wxString_in_helper(obj1);
47719 if (arg2 == NULL) SWIG_fail;
47720 temp2 = true;
47721 }
47722 if (obj2) {
47723 arg3 = obj2;
47724 }
47725 {
47726 PyThreadState* __tstate = wxPyBeginAllowThreads();
47727 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47728 wxPyEndAllowThreads(__tstate);
47729 if (PyErr_Occurred()) SWIG_fail;
47730 }
47731 resultobj = SWIG_From_int(static_cast< int >(result));
47732 {
47733 if (temp2)
47734 delete arg2;
47735 }
47736 return resultobj;
47737 fail:
47738 {
47739 if (temp2)
47740 delete arg2;
47741 }
47742 return NULL;
47743 }
47744
47745
47746 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47747 PyObject *resultobj = 0;
47748 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47749 wxArrayString *arg2 = 0 ;
47750 void *argp1 = 0 ;
47751 int res1 = 0 ;
47752 bool temp2 = false ;
47753 PyObject * obj0 = 0 ;
47754 PyObject * obj1 = 0 ;
47755 char * kwnames[] = {
47756 (char *) "self",(char *) "strings", NULL
47757 };
47758
47759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47761 if (!SWIG_IsOK(res1)) {
47762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47763 }
47764 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47765 {
47766 if (! PySequence_Check(obj1)) {
47767 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47768 SWIG_fail;
47769 }
47770 arg2 = new wxArrayString;
47771 temp2 = true;
47772 int i, len=PySequence_Length(obj1);
47773 for (i=0; i<len; i++) {
47774 PyObject* item = PySequence_GetItem(obj1, i);
47775 wxString* s = wxString_in_helper(item);
47776 if (PyErr_Occurred()) SWIG_fail;
47777 arg2->Add(*s);
47778 delete s;
47779 Py_DECREF(item);
47780 }
47781 }
47782 {
47783 PyThreadState* __tstate = wxPyBeginAllowThreads();
47784 (arg1)->Append((wxArrayString const &)*arg2);
47785 wxPyEndAllowThreads(__tstate);
47786 if (PyErr_Occurred()) SWIG_fail;
47787 }
47788 resultobj = SWIG_Py_Void();
47789 {
47790 if (temp2) delete arg2;
47791 }
47792 return resultobj;
47793 fail:
47794 {
47795 if (temp2) delete arg2;
47796 }
47797 return NULL;
47798 }
47799
47800
47801 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47802 PyObject *resultobj = 0;
47803 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47804 wxString *arg2 = 0 ;
47805 unsigned int arg3 ;
47806 PyObject *arg4 = (PyObject *) NULL ;
47807 int result;
47808 void *argp1 = 0 ;
47809 int res1 = 0 ;
47810 bool temp2 = false ;
47811 unsigned int val3 ;
47812 int ecode3 = 0 ;
47813 PyObject * obj0 = 0 ;
47814 PyObject * obj1 = 0 ;
47815 PyObject * obj2 = 0 ;
47816 PyObject * obj3 = 0 ;
47817 char * kwnames[] = {
47818 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47819 };
47820
47821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47823 if (!SWIG_IsOK(res1)) {
47824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47825 }
47826 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47827 {
47828 arg2 = wxString_in_helper(obj1);
47829 if (arg2 == NULL) SWIG_fail;
47830 temp2 = true;
47831 }
47832 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47833 if (!SWIG_IsOK(ecode3)) {
47834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47835 }
47836 arg3 = static_cast< unsigned int >(val3);
47837 if (obj3) {
47838 arg4 = obj3;
47839 }
47840 {
47841 PyThreadState* __tstate = wxPyBeginAllowThreads();
47842 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47843 wxPyEndAllowThreads(__tstate);
47844 if (PyErr_Occurred()) SWIG_fail;
47845 }
47846 resultobj = SWIG_From_int(static_cast< int >(result));
47847 {
47848 if (temp2)
47849 delete arg2;
47850 }
47851 return resultobj;
47852 fail:
47853 {
47854 if (temp2)
47855 delete arg2;
47856 }
47857 return NULL;
47858 }
47859
47860
47861 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47862 PyObject *resultobj = 0;
47863 wxItemContainer *arg1 = (wxItemContainer *) 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_wxItemContainer, 0 | 0 );
47871 if (!SWIG_IsOK(res1)) {
47872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47873 }
47874 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47875 {
47876 PyThreadState* __tstate = wxPyBeginAllowThreads();
47877 (arg1)->Clear();
47878 wxPyEndAllowThreads(__tstate);
47879 if (PyErr_Occurred()) SWIG_fail;
47880 }
47881 resultobj = SWIG_Py_Void();
47882 return resultobj;
47883 fail:
47884 return NULL;
47885 }
47886
47887
47888 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47889 PyObject *resultobj = 0;
47890 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47891 unsigned int arg2 ;
47892 void *argp1 = 0 ;
47893 int res1 = 0 ;
47894 unsigned int val2 ;
47895 int ecode2 = 0 ;
47896 PyObject * obj0 = 0 ;
47897 PyObject * obj1 = 0 ;
47898 char * kwnames[] = {
47899 (char *) "self",(char *) "n", NULL
47900 };
47901
47902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47904 if (!SWIG_IsOK(res1)) {
47905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47906 }
47907 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47908 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47909 if (!SWIG_IsOK(ecode2)) {
47910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47911 }
47912 arg2 = static_cast< unsigned int >(val2);
47913 {
47914 PyThreadState* __tstate = wxPyBeginAllowThreads();
47915 (arg1)->Delete(arg2);
47916 wxPyEndAllowThreads(__tstate);
47917 if (PyErr_Occurred()) SWIG_fail;
47918 }
47919 resultobj = SWIG_Py_Void();
47920 return resultobj;
47921 fail:
47922 return NULL;
47923 }
47924
47925
47926 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47927 PyObject *resultobj = 0;
47928 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47929 unsigned int arg2 ;
47930 PyObject *result = 0 ;
47931 void *argp1 = 0 ;
47932 int res1 = 0 ;
47933 unsigned int val2 ;
47934 int ecode2 = 0 ;
47935 PyObject * obj0 = 0 ;
47936 PyObject * obj1 = 0 ;
47937 char * kwnames[] = {
47938 (char *) "self",(char *) "n", NULL
47939 };
47940
47941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47943 if (!SWIG_IsOK(res1)) {
47944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47945 }
47946 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47947 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47948 if (!SWIG_IsOK(ecode2)) {
47949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47950 }
47951 arg2 = static_cast< unsigned int >(val2);
47952 {
47953 PyThreadState* __tstate = wxPyBeginAllowThreads();
47954 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47955 wxPyEndAllowThreads(__tstate);
47956 if (PyErr_Occurred()) SWIG_fail;
47957 }
47958 resultobj = result;
47959 return resultobj;
47960 fail:
47961 return NULL;
47962 }
47963
47964
47965 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47966 PyObject *resultobj = 0;
47967 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47968 unsigned int arg2 ;
47969 PyObject *arg3 = (PyObject *) 0 ;
47970 void *argp1 = 0 ;
47971 int res1 = 0 ;
47972 unsigned int val2 ;
47973 int ecode2 = 0 ;
47974 PyObject * obj0 = 0 ;
47975 PyObject * obj1 = 0 ;
47976 PyObject * obj2 = 0 ;
47977 char * kwnames[] = {
47978 (char *) "self",(char *) "n",(char *) "clientData", NULL
47979 };
47980
47981 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47982 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47983 if (!SWIG_IsOK(res1)) {
47984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47985 }
47986 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47987 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47988 if (!SWIG_IsOK(ecode2)) {
47989 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47990 }
47991 arg2 = static_cast< unsigned int >(val2);
47992 arg3 = obj2;
47993 {
47994 PyThreadState* __tstate = wxPyBeginAllowThreads();
47995 wxItemContainer_SetClientData(arg1,arg2,arg3);
47996 wxPyEndAllowThreads(__tstate);
47997 if (PyErr_Occurred()) SWIG_fail;
47998 }
47999 resultobj = SWIG_Py_Void();
48000 return resultobj;
48001 fail:
48002 return NULL;
48003 }
48004
48005
48006 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48007 PyObject *resultobj = 0;
48008 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48009 unsigned int result;
48010 void *argp1 = 0 ;
48011 int res1 = 0 ;
48012 PyObject *swig_obj[1] ;
48013
48014 if (!args) SWIG_fail;
48015 swig_obj[0] = args;
48016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48017 if (!SWIG_IsOK(res1)) {
48018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48019 }
48020 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48021 {
48022 PyThreadState* __tstate = wxPyBeginAllowThreads();
48023 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
48024 wxPyEndAllowThreads(__tstate);
48025 if (PyErr_Occurred()) SWIG_fail;
48026 }
48027 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
48028 return resultobj;
48029 fail:
48030 return NULL;
48031 }
48032
48033
48034 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48035 PyObject *resultobj = 0;
48036 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48037 bool result;
48038 void *argp1 = 0 ;
48039 int res1 = 0 ;
48040 PyObject *swig_obj[1] ;
48041
48042 if (!args) SWIG_fail;
48043 swig_obj[0] = args;
48044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48045 if (!SWIG_IsOK(res1)) {
48046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48047 }
48048 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48049 {
48050 PyThreadState* __tstate = wxPyBeginAllowThreads();
48051 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48052 wxPyEndAllowThreads(__tstate);
48053 if (PyErr_Occurred()) SWIG_fail;
48054 }
48055 {
48056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48057 }
48058 return resultobj;
48059 fail:
48060 return NULL;
48061 }
48062
48063
48064 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48065 PyObject *resultobj = 0;
48066 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48067 unsigned int arg2 ;
48068 wxString result;
48069 void *argp1 = 0 ;
48070 int res1 = 0 ;
48071 unsigned int val2 ;
48072 int ecode2 = 0 ;
48073 PyObject * obj0 = 0 ;
48074 PyObject * obj1 = 0 ;
48075 char * kwnames[] = {
48076 (char *) "self",(char *) "n", NULL
48077 };
48078
48079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48081 if (!SWIG_IsOK(res1)) {
48082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48083 }
48084 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48085 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48086 if (!SWIG_IsOK(ecode2)) {
48087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
48088 }
48089 arg2 = static_cast< unsigned int >(val2);
48090 {
48091 PyThreadState* __tstate = wxPyBeginAllowThreads();
48092 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48093 wxPyEndAllowThreads(__tstate);
48094 if (PyErr_Occurred()) SWIG_fail;
48095 }
48096 {
48097 #if wxUSE_UNICODE
48098 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48099 #else
48100 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48101 #endif
48102 }
48103 return resultobj;
48104 fail:
48105 return NULL;
48106 }
48107
48108
48109 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48110 PyObject *resultobj = 0;
48111 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48112 wxArrayString result;
48113 void *argp1 = 0 ;
48114 int res1 = 0 ;
48115 PyObject *swig_obj[1] ;
48116
48117 if (!args) SWIG_fail;
48118 swig_obj[0] = args;
48119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48120 if (!SWIG_IsOK(res1)) {
48121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48122 }
48123 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48124 {
48125 PyThreadState* __tstate = wxPyBeginAllowThreads();
48126 result = ((wxItemContainer const *)arg1)->GetStrings();
48127 wxPyEndAllowThreads(__tstate);
48128 if (PyErr_Occurred()) SWIG_fail;
48129 }
48130 {
48131 resultobj = wxArrayString2PyList_helper(result);
48132 }
48133 return resultobj;
48134 fail:
48135 return NULL;
48136 }
48137
48138
48139 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48140 PyObject *resultobj = 0;
48141 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48142 unsigned int arg2 ;
48143 wxString *arg3 = 0 ;
48144 void *argp1 = 0 ;
48145 int res1 = 0 ;
48146 unsigned int val2 ;
48147 int ecode2 = 0 ;
48148 bool temp3 = false ;
48149 PyObject * obj0 = 0 ;
48150 PyObject * obj1 = 0 ;
48151 PyObject * obj2 = 0 ;
48152 char * kwnames[] = {
48153 (char *) "self",(char *) "n",(char *) "s", NULL
48154 };
48155
48156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48158 if (!SWIG_IsOK(res1)) {
48159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48160 }
48161 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48162 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48163 if (!SWIG_IsOK(ecode2)) {
48164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48165 }
48166 arg2 = static_cast< unsigned int >(val2);
48167 {
48168 arg3 = wxString_in_helper(obj2);
48169 if (arg3 == NULL) SWIG_fail;
48170 temp3 = true;
48171 }
48172 {
48173 PyThreadState* __tstate = wxPyBeginAllowThreads();
48174 (arg1)->SetString(arg2,(wxString const &)*arg3);
48175 wxPyEndAllowThreads(__tstate);
48176 if (PyErr_Occurred()) SWIG_fail;
48177 }
48178 resultobj = SWIG_Py_Void();
48179 {
48180 if (temp3)
48181 delete arg3;
48182 }
48183 return resultobj;
48184 fail:
48185 {
48186 if (temp3)
48187 delete arg3;
48188 }
48189 return NULL;
48190 }
48191
48192
48193 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48194 PyObject *resultobj = 0;
48195 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48196 wxString *arg2 = 0 ;
48197 int result;
48198 void *argp1 = 0 ;
48199 int res1 = 0 ;
48200 bool temp2 = false ;
48201 PyObject * obj0 = 0 ;
48202 PyObject * obj1 = 0 ;
48203 char * kwnames[] = {
48204 (char *) "self",(char *) "s", NULL
48205 };
48206
48207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48209 if (!SWIG_IsOK(res1)) {
48210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48211 }
48212 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48213 {
48214 arg2 = wxString_in_helper(obj1);
48215 if (arg2 == NULL) SWIG_fail;
48216 temp2 = true;
48217 }
48218 {
48219 PyThreadState* __tstate = wxPyBeginAllowThreads();
48220 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48221 wxPyEndAllowThreads(__tstate);
48222 if (PyErr_Occurred()) SWIG_fail;
48223 }
48224 resultobj = SWIG_From_int(static_cast< int >(result));
48225 {
48226 if (temp2)
48227 delete arg2;
48228 }
48229 return resultobj;
48230 fail:
48231 {
48232 if (temp2)
48233 delete arg2;
48234 }
48235 return NULL;
48236 }
48237
48238
48239 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48240 PyObject *resultobj = 0;
48241 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48242 int arg2 ;
48243 void *argp1 = 0 ;
48244 int res1 = 0 ;
48245 int val2 ;
48246 int ecode2 = 0 ;
48247 PyObject * obj0 = 0 ;
48248 PyObject * obj1 = 0 ;
48249 char * kwnames[] = {
48250 (char *) "self",(char *) "n", NULL
48251 };
48252
48253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48255 if (!SWIG_IsOK(res1)) {
48256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48257 }
48258 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48259 ecode2 = SWIG_AsVal_int(obj1, &val2);
48260 if (!SWIG_IsOK(ecode2)) {
48261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48262 }
48263 arg2 = static_cast< int >(val2);
48264 {
48265 PyThreadState* __tstate = wxPyBeginAllowThreads();
48266 (arg1)->SetSelection(arg2);
48267 wxPyEndAllowThreads(__tstate);
48268 if (PyErr_Occurred()) SWIG_fail;
48269 }
48270 resultobj = SWIG_Py_Void();
48271 return resultobj;
48272 fail:
48273 return NULL;
48274 }
48275
48276
48277 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48278 PyObject *resultobj = 0;
48279 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48280 int result;
48281 void *argp1 = 0 ;
48282 int res1 = 0 ;
48283 PyObject *swig_obj[1] ;
48284
48285 if (!args) SWIG_fail;
48286 swig_obj[0] = args;
48287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48288 if (!SWIG_IsOK(res1)) {
48289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48290 }
48291 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48292 {
48293 PyThreadState* __tstate = wxPyBeginAllowThreads();
48294 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48295 wxPyEndAllowThreads(__tstate);
48296 if (PyErr_Occurred()) SWIG_fail;
48297 }
48298 resultobj = SWIG_From_int(static_cast< int >(result));
48299 return resultobj;
48300 fail:
48301 return NULL;
48302 }
48303
48304
48305 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48306 PyObject *resultobj = 0;
48307 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48308 wxString *arg2 = 0 ;
48309 bool result;
48310 void *argp1 = 0 ;
48311 int res1 = 0 ;
48312 bool temp2 = false ;
48313 PyObject * obj0 = 0 ;
48314 PyObject * obj1 = 0 ;
48315 char * kwnames[] = {
48316 (char *) "self",(char *) "s", NULL
48317 };
48318
48319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48321 if (!SWIG_IsOK(res1)) {
48322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48323 }
48324 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48325 {
48326 arg2 = wxString_in_helper(obj1);
48327 if (arg2 == NULL) SWIG_fail;
48328 temp2 = true;
48329 }
48330 {
48331 PyThreadState* __tstate = wxPyBeginAllowThreads();
48332 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48333 wxPyEndAllowThreads(__tstate);
48334 if (PyErr_Occurred()) SWIG_fail;
48335 }
48336 {
48337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48338 }
48339 {
48340 if (temp2)
48341 delete arg2;
48342 }
48343 return resultobj;
48344 fail:
48345 {
48346 if (temp2)
48347 delete arg2;
48348 }
48349 return NULL;
48350 }
48351
48352
48353 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48354 PyObject *resultobj = 0;
48355 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48356 wxString result;
48357 void *argp1 = 0 ;
48358 int res1 = 0 ;
48359 PyObject *swig_obj[1] ;
48360
48361 if (!args) SWIG_fail;
48362 swig_obj[0] = args;
48363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48364 if (!SWIG_IsOK(res1)) {
48365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48366 }
48367 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48368 {
48369 PyThreadState* __tstate = wxPyBeginAllowThreads();
48370 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48371 wxPyEndAllowThreads(__tstate);
48372 if (PyErr_Occurred()) SWIG_fail;
48373 }
48374 {
48375 #if wxUSE_UNICODE
48376 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48377 #else
48378 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48379 #endif
48380 }
48381 return resultobj;
48382 fail:
48383 return NULL;
48384 }
48385
48386
48387 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48388 PyObject *resultobj = 0;
48389 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48390 int arg2 ;
48391 void *argp1 = 0 ;
48392 int res1 = 0 ;
48393 int val2 ;
48394 int ecode2 = 0 ;
48395 PyObject * obj0 = 0 ;
48396 PyObject * obj1 = 0 ;
48397 char * kwnames[] = {
48398 (char *) "self",(char *) "n", NULL
48399 };
48400
48401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48403 if (!SWIG_IsOK(res1)) {
48404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48405 }
48406 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48407 ecode2 = SWIG_AsVal_int(obj1, &val2);
48408 if (!SWIG_IsOK(ecode2)) {
48409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48410 }
48411 arg2 = static_cast< int >(val2);
48412 {
48413 PyThreadState* __tstate = wxPyBeginAllowThreads();
48414 (arg1)->Select(arg2);
48415 wxPyEndAllowThreads(__tstate);
48416 if (PyErr_Occurred()) SWIG_fail;
48417 }
48418 resultobj = SWIG_Py_Void();
48419 return resultobj;
48420 fail:
48421 return NULL;
48422 }
48423
48424
48425 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48426 PyObject *obj;
48427 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48428 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48429 return SWIG_Py_Void();
48430 }
48431
48432 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48433 PyObject *obj;
48434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48435 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48436 return SWIG_Py_Void();
48437 }
48438
48439 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48440 PyObject *resultobj = 0;
48441 wxSizerItem *result = 0 ;
48442
48443 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48444 {
48445 PyThreadState* __tstate = wxPyBeginAllowThreads();
48446 result = (wxSizerItem *)new wxSizerItem();
48447 wxPyEndAllowThreads(__tstate);
48448 if (PyErr_Occurred()) SWIG_fail;
48449 }
48450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48451 return resultobj;
48452 fail:
48453 return NULL;
48454 }
48455
48456
48457 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48458 PyObject *resultobj = 0;
48459 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48460 void *argp1 = 0 ;
48461 int res1 = 0 ;
48462 PyObject *swig_obj[1] ;
48463
48464 if (!args) SWIG_fail;
48465 swig_obj[0] = args;
48466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48467 if (!SWIG_IsOK(res1)) {
48468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48469 }
48470 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48471 {
48472 PyThreadState* __tstate = wxPyBeginAllowThreads();
48473 delete arg1;
48474
48475 wxPyEndAllowThreads(__tstate);
48476 if (PyErr_Occurred()) SWIG_fail;
48477 }
48478 resultobj = SWIG_Py_Void();
48479 return resultobj;
48480 fail:
48481 return NULL;
48482 }
48483
48484
48485 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48486 PyObject *resultobj = 0;
48487 wxWindow *arg1 = (wxWindow *) 0 ;
48488 int arg2 ;
48489 int arg3 ;
48490 int arg4 ;
48491 PyObject *arg5 = (PyObject *) NULL ;
48492 wxSizerItem *result = 0 ;
48493 void *argp1 = 0 ;
48494 int res1 = 0 ;
48495 int val2 ;
48496 int ecode2 = 0 ;
48497 int val3 ;
48498 int ecode3 = 0 ;
48499 int val4 ;
48500 int ecode4 = 0 ;
48501 PyObject * obj0 = 0 ;
48502 PyObject * obj1 = 0 ;
48503 PyObject * obj2 = 0 ;
48504 PyObject * obj3 = 0 ;
48505 PyObject * obj4 = 0 ;
48506 char * kwnames[] = {
48507 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48508 };
48509
48510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48512 if (!SWIG_IsOK(res1)) {
48513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48514 }
48515 arg1 = reinterpret_cast< wxWindow * >(argp1);
48516 ecode2 = SWIG_AsVal_int(obj1, &val2);
48517 if (!SWIG_IsOK(ecode2)) {
48518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48519 }
48520 arg2 = static_cast< int >(val2);
48521 ecode3 = SWIG_AsVal_int(obj2, &val3);
48522 if (!SWIG_IsOK(ecode3)) {
48523 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48524 }
48525 arg3 = static_cast< int >(val3);
48526 ecode4 = SWIG_AsVal_int(obj3, &val4);
48527 if (!SWIG_IsOK(ecode4)) {
48528 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48529 }
48530 arg4 = static_cast< int >(val4);
48531 if (obj4) {
48532 arg5 = obj4;
48533 }
48534 {
48535 PyThreadState* __tstate = wxPyBeginAllowThreads();
48536 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48537 wxPyEndAllowThreads(__tstate);
48538 if (PyErr_Occurred()) SWIG_fail;
48539 }
48540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48541 return resultobj;
48542 fail:
48543 return NULL;
48544 }
48545
48546
48547 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48548 PyObject *resultobj = 0;
48549 int arg1 ;
48550 int arg2 ;
48551 int arg3 ;
48552 int arg4 ;
48553 int arg5 ;
48554 PyObject *arg6 = (PyObject *) NULL ;
48555 wxSizerItem *result = 0 ;
48556 int val1 ;
48557 int ecode1 = 0 ;
48558 int val2 ;
48559 int ecode2 = 0 ;
48560 int val3 ;
48561 int ecode3 = 0 ;
48562 int val4 ;
48563 int ecode4 = 0 ;
48564 int val5 ;
48565 int ecode5 = 0 ;
48566 PyObject * obj0 = 0 ;
48567 PyObject * obj1 = 0 ;
48568 PyObject * obj2 = 0 ;
48569 PyObject * obj3 = 0 ;
48570 PyObject * obj4 = 0 ;
48571 PyObject * obj5 = 0 ;
48572 char * kwnames[] = {
48573 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48574 };
48575
48576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48577 ecode1 = SWIG_AsVal_int(obj0, &val1);
48578 if (!SWIG_IsOK(ecode1)) {
48579 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48580 }
48581 arg1 = static_cast< int >(val1);
48582 ecode2 = SWIG_AsVal_int(obj1, &val2);
48583 if (!SWIG_IsOK(ecode2)) {
48584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48585 }
48586 arg2 = static_cast< int >(val2);
48587 ecode3 = SWIG_AsVal_int(obj2, &val3);
48588 if (!SWIG_IsOK(ecode3)) {
48589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48590 }
48591 arg3 = static_cast< int >(val3);
48592 ecode4 = SWIG_AsVal_int(obj3, &val4);
48593 if (!SWIG_IsOK(ecode4)) {
48594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48595 }
48596 arg4 = static_cast< int >(val4);
48597 ecode5 = SWIG_AsVal_int(obj4, &val5);
48598 if (!SWIG_IsOK(ecode5)) {
48599 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48600 }
48601 arg5 = static_cast< int >(val5);
48602 if (obj5) {
48603 arg6 = obj5;
48604 }
48605 {
48606 PyThreadState* __tstate = wxPyBeginAllowThreads();
48607 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48608 wxPyEndAllowThreads(__tstate);
48609 if (PyErr_Occurred()) SWIG_fail;
48610 }
48611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48612 return resultobj;
48613 fail:
48614 return NULL;
48615 }
48616
48617
48618 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48619 PyObject *resultobj = 0;
48620 wxSizer *arg1 = (wxSizer *) 0 ;
48621 int arg2 ;
48622 int arg3 ;
48623 int arg4 ;
48624 PyObject *arg5 = (PyObject *) NULL ;
48625 wxSizerItem *result = 0 ;
48626 int res1 = 0 ;
48627 int val2 ;
48628 int ecode2 = 0 ;
48629 int val3 ;
48630 int ecode3 = 0 ;
48631 int val4 ;
48632 int ecode4 = 0 ;
48633 PyObject * obj0 = 0 ;
48634 PyObject * obj1 = 0 ;
48635 PyObject * obj2 = 0 ;
48636 PyObject * obj3 = 0 ;
48637 PyObject * obj4 = 0 ;
48638 char * kwnames[] = {
48639 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48640 };
48641
48642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48643 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48644 if (!SWIG_IsOK(res1)) {
48645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48646 }
48647 ecode2 = SWIG_AsVal_int(obj1, &val2);
48648 if (!SWIG_IsOK(ecode2)) {
48649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48650 }
48651 arg2 = static_cast< int >(val2);
48652 ecode3 = SWIG_AsVal_int(obj2, &val3);
48653 if (!SWIG_IsOK(ecode3)) {
48654 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48655 }
48656 arg3 = static_cast< int >(val3);
48657 ecode4 = SWIG_AsVal_int(obj3, &val4);
48658 if (!SWIG_IsOK(ecode4)) {
48659 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48660 }
48661 arg4 = static_cast< int >(val4);
48662 if (obj4) {
48663 arg5 = obj4;
48664 }
48665 {
48666 PyThreadState* __tstate = wxPyBeginAllowThreads();
48667 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48668 wxPyEndAllowThreads(__tstate);
48669 if (PyErr_Occurred()) SWIG_fail;
48670 }
48671 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48672 return resultobj;
48673 fail:
48674 return NULL;
48675 }
48676
48677
48678 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48679 PyObject *resultobj = 0;
48680 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48681 void *argp1 = 0 ;
48682 int res1 = 0 ;
48683 PyObject *swig_obj[1] ;
48684
48685 if (!args) SWIG_fail;
48686 swig_obj[0] = args;
48687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48688 if (!SWIG_IsOK(res1)) {
48689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48690 }
48691 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48692 {
48693 PyThreadState* __tstate = wxPyBeginAllowThreads();
48694 (arg1)->DeleteWindows();
48695 wxPyEndAllowThreads(__tstate);
48696 if (PyErr_Occurred()) SWIG_fail;
48697 }
48698 resultobj = SWIG_Py_Void();
48699 return resultobj;
48700 fail:
48701 return NULL;
48702 }
48703
48704
48705 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48706 PyObject *resultobj = 0;
48707 wxSizerItem *arg1 = (wxSizerItem *) 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_wxSizerItem, 0 | 0 );
48715 if (!SWIG_IsOK(res1)) {
48716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48717 }
48718 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48719 {
48720 PyThreadState* __tstate = wxPyBeginAllowThreads();
48721 (arg1)->DetachSizer();
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_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48733 PyObject *resultobj = 0;
48734 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48735 wxSize result;
48736 void *argp1 = 0 ;
48737 int res1 = 0 ;
48738 PyObject *swig_obj[1] ;
48739
48740 if (!args) SWIG_fail;
48741 swig_obj[0] = args;
48742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48743 if (!SWIG_IsOK(res1)) {
48744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48745 }
48746 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48747 {
48748 PyThreadState* __tstate = wxPyBeginAllowThreads();
48749 result = (arg1)->GetSize();
48750 wxPyEndAllowThreads(__tstate);
48751 if (PyErr_Occurred()) SWIG_fail;
48752 }
48753 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48754 return resultobj;
48755 fail:
48756 return NULL;
48757 }
48758
48759
48760 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48761 PyObject *resultobj = 0;
48762 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48763 wxSize result;
48764 void *argp1 = 0 ;
48765 int res1 = 0 ;
48766 PyObject *swig_obj[1] ;
48767
48768 if (!args) SWIG_fail;
48769 swig_obj[0] = args;
48770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48771 if (!SWIG_IsOK(res1)) {
48772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48773 }
48774 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48775 {
48776 PyThreadState* __tstate = wxPyBeginAllowThreads();
48777 result = (arg1)->CalcMin();
48778 wxPyEndAllowThreads(__tstate);
48779 if (PyErr_Occurred()) SWIG_fail;
48780 }
48781 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48782 return resultobj;
48783 fail:
48784 return NULL;
48785 }
48786
48787
48788 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48789 PyObject *resultobj = 0;
48790 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48791 wxPoint *arg2 = 0 ;
48792 wxSize *arg3 = 0 ;
48793 void *argp1 = 0 ;
48794 int res1 = 0 ;
48795 wxPoint temp2 ;
48796 wxSize temp3 ;
48797 PyObject * obj0 = 0 ;
48798 PyObject * obj1 = 0 ;
48799 PyObject * obj2 = 0 ;
48800 char * kwnames[] = {
48801 (char *) "self",(char *) "pos",(char *) "size", NULL
48802 };
48803
48804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48806 if (!SWIG_IsOK(res1)) {
48807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48808 }
48809 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48810 {
48811 arg2 = &temp2;
48812 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48813 }
48814 {
48815 arg3 = &temp3;
48816 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48817 }
48818 {
48819 PyThreadState* __tstate = wxPyBeginAllowThreads();
48820 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48821 wxPyEndAllowThreads(__tstate);
48822 if (PyErr_Occurred()) SWIG_fail;
48823 }
48824 resultobj = SWIG_Py_Void();
48825 return resultobj;
48826 fail:
48827 return NULL;
48828 }
48829
48830
48831 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48832 PyObject *resultobj = 0;
48833 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48834 wxSize result;
48835 void *argp1 = 0 ;
48836 int res1 = 0 ;
48837 PyObject *swig_obj[1] ;
48838
48839 if (!args) SWIG_fail;
48840 swig_obj[0] = args;
48841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48842 if (!SWIG_IsOK(res1)) {
48843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48844 }
48845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48846 {
48847 PyThreadState* __tstate = wxPyBeginAllowThreads();
48848 result = (arg1)->GetMinSize();
48849 wxPyEndAllowThreads(__tstate);
48850 if (PyErr_Occurred()) SWIG_fail;
48851 }
48852 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48853 return resultobj;
48854 fail:
48855 return NULL;
48856 }
48857
48858
48859 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48860 PyObject *resultobj = 0;
48861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48862 wxSize result;
48863 void *argp1 = 0 ;
48864 int res1 = 0 ;
48865 PyObject *swig_obj[1] ;
48866
48867 if (!args) SWIG_fail;
48868 swig_obj[0] = args;
48869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48870 if (!SWIG_IsOK(res1)) {
48871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48872 }
48873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48874 {
48875 PyThreadState* __tstate = wxPyBeginAllowThreads();
48876 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48877 wxPyEndAllowThreads(__tstate);
48878 if (PyErr_Occurred()) SWIG_fail;
48879 }
48880 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48881 return resultobj;
48882 fail:
48883 return NULL;
48884 }
48885
48886
48887 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48888 PyObject *resultobj = 0;
48889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48890 int arg2 ;
48891 int arg3 ;
48892 void *argp1 = 0 ;
48893 int res1 = 0 ;
48894 int val2 ;
48895 int ecode2 = 0 ;
48896 int val3 ;
48897 int ecode3 = 0 ;
48898 PyObject * obj0 = 0 ;
48899 PyObject * obj1 = 0 ;
48900 PyObject * obj2 = 0 ;
48901 char * kwnames[] = {
48902 (char *) "self",(char *) "x",(char *) "y", NULL
48903 };
48904
48905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48907 if (!SWIG_IsOK(res1)) {
48908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48909 }
48910 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48911 ecode2 = SWIG_AsVal_int(obj1, &val2);
48912 if (!SWIG_IsOK(ecode2)) {
48913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48914 }
48915 arg2 = static_cast< int >(val2);
48916 ecode3 = SWIG_AsVal_int(obj2, &val3);
48917 if (!SWIG_IsOK(ecode3)) {
48918 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48919 }
48920 arg3 = static_cast< int >(val3);
48921 {
48922 PyThreadState* __tstate = wxPyBeginAllowThreads();
48923 (arg1)->SetInitSize(arg2,arg3);
48924 wxPyEndAllowThreads(__tstate);
48925 if (PyErr_Occurred()) SWIG_fail;
48926 }
48927 resultobj = SWIG_Py_Void();
48928 return resultobj;
48929 fail:
48930 return NULL;
48931 }
48932
48933
48934 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48935 PyObject *resultobj = 0;
48936 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48937 int arg2 ;
48938 int arg3 ;
48939 void *argp1 = 0 ;
48940 int res1 = 0 ;
48941 int val2 ;
48942 int ecode2 = 0 ;
48943 int val3 ;
48944 int ecode3 = 0 ;
48945 PyObject * obj0 = 0 ;
48946 PyObject * obj1 = 0 ;
48947 PyObject * obj2 = 0 ;
48948 char * kwnames[] = {
48949 (char *) "self",(char *) "width",(char *) "height", NULL
48950 };
48951
48952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48954 if (!SWIG_IsOK(res1)) {
48955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48956 }
48957 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48958 ecode2 = SWIG_AsVal_int(obj1, &val2);
48959 if (!SWIG_IsOK(ecode2)) {
48960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48961 }
48962 arg2 = static_cast< int >(val2);
48963 ecode3 = SWIG_AsVal_int(obj2, &val3);
48964 if (!SWIG_IsOK(ecode3)) {
48965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48966 }
48967 arg3 = static_cast< int >(val3);
48968 {
48969 PyThreadState* __tstate = wxPyBeginAllowThreads();
48970 (arg1)->SetRatio(arg2,arg3);
48971 wxPyEndAllowThreads(__tstate);
48972 if (PyErr_Occurred()) SWIG_fail;
48973 }
48974 resultobj = SWIG_Py_Void();
48975 return resultobj;
48976 fail:
48977 return NULL;
48978 }
48979
48980
48981 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48982 PyObject *resultobj = 0;
48983 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48984 wxSize *arg2 = 0 ;
48985 void *argp1 = 0 ;
48986 int res1 = 0 ;
48987 wxSize temp2 ;
48988 PyObject * obj0 = 0 ;
48989 PyObject * obj1 = 0 ;
48990 char * kwnames[] = {
48991 (char *) "self",(char *) "size", NULL
48992 };
48993
48994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48996 if (!SWIG_IsOK(res1)) {
48997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48998 }
48999 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49000 {
49001 arg2 = &temp2;
49002 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49003 }
49004 {
49005 PyThreadState* __tstate = wxPyBeginAllowThreads();
49006 (arg1)->SetRatio((wxSize const &)*arg2);
49007 wxPyEndAllowThreads(__tstate);
49008 if (PyErr_Occurred()) SWIG_fail;
49009 }
49010 resultobj = SWIG_Py_Void();
49011 return resultobj;
49012 fail:
49013 return NULL;
49014 }
49015
49016
49017 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49018 PyObject *resultobj = 0;
49019 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49020 float arg2 ;
49021 void *argp1 = 0 ;
49022 int res1 = 0 ;
49023 float val2 ;
49024 int ecode2 = 0 ;
49025 PyObject * obj0 = 0 ;
49026 PyObject * obj1 = 0 ;
49027 char * kwnames[] = {
49028 (char *) "self",(char *) "ratio", NULL
49029 };
49030
49031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49033 if (!SWIG_IsOK(res1)) {
49034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49035 }
49036 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49037 ecode2 = SWIG_AsVal_float(obj1, &val2);
49038 if (!SWIG_IsOK(ecode2)) {
49039 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49040 }
49041 arg2 = static_cast< float >(val2);
49042 {
49043 PyThreadState* __tstate = wxPyBeginAllowThreads();
49044 (arg1)->SetRatio(arg2);
49045 wxPyEndAllowThreads(__tstate);
49046 if (PyErr_Occurred()) SWIG_fail;
49047 }
49048 resultobj = SWIG_Py_Void();
49049 return resultobj;
49050 fail:
49051 return NULL;
49052 }
49053
49054
49055 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49056 PyObject *resultobj = 0;
49057 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49058 float result;
49059 void *argp1 = 0 ;
49060 int res1 = 0 ;
49061 PyObject *swig_obj[1] ;
49062
49063 if (!args) SWIG_fail;
49064 swig_obj[0] = args;
49065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49066 if (!SWIG_IsOK(res1)) {
49067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49068 }
49069 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49070 {
49071 PyThreadState* __tstate = wxPyBeginAllowThreads();
49072 result = (float)(arg1)->GetRatio();
49073 wxPyEndAllowThreads(__tstate);
49074 if (PyErr_Occurred()) SWIG_fail;
49075 }
49076 resultobj = SWIG_From_float(static_cast< float >(result));
49077 return resultobj;
49078 fail:
49079 return NULL;
49080 }
49081
49082
49083 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49084 PyObject *resultobj = 0;
49085 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49086 wxRect result;
49087 void *argp1 = 0 ;
49088 int res1 = 0 ;
49089 PyObject *swig_obj[1] ;
49090
49091 if (!args) SWIG_fail;
49092 swig_obj[0] = args;
49093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49094 if (!SWIG_IsOK(res1)) {
49095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49096 }
49097 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49098 {
49099 PyThreadState* __tstate = wxPyBeginAllowThreads();
49100 result = (arg1)->GetRect();
49101 wxPyEndAllowThreads(__tstate);
49102 if (PyErr_Occurred()) SWIG_fail;
49103 }
49104 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49105 return resultobj;
49106 fail:
49107 return NULL;
49108 }
49109
49110
49111 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49112 PyObject *resultobj = 0;
49113 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49114 bool result;
49115 void *argp1 = 0 ;
49116 int res1 = 0 ;
49117 PyObject *swig_obj[1] ;
49118
49119 if (!args) SWIG_fail;
49120 swig_obj[0] = args;
49121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49122 if (!SWIG_IsOK(res1)) {
49123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49124 }
49125 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49126 {
49127 PyThreadState* __tstate = wxPyBeginAllowThreads();
49128 result = (bool)(arg1)->IsWindow();
49129 wxPyEndAllowThreads(__tstate);
49130 if (PyErr_Occurred()) SWIG_fail;
49131 }
49132 {
49133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49134 }
49135 return resultobj;
49136 fail:
49137 return NULL;
49138 }
49139
49140
49141 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49142 PyObject *resultobj = 0;
49143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49144 bool result;
49145 void *argp1 = 0 ;
49146 int res1 = 0 ;
49147 PyObject *swig_obj[1] ;
49148
49149 if (!args) SWIG_fail;
49150 swig_obj[0] = args;
49151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49152 if (!SWIG_IsOK(res1)) {
49153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49154 }
49155 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49156 {
49157 PyThreadState* __tstate = wxPyBeginAllowThreads();
49158 result = (bool)(arg1)->IsSizer();
49159 wxPyEndAllowThreads(__tstate);
49160 if (PyErr_Occurred()) SWIG_fail;
49161 }
49162 {
49163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49164 }
49165 return resultobj;
49166 fail:
49167 return NULL;
49168 }
49169
49170
49171 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49172 PyObject *resultobj = 0;
49173 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49174 bool result;
49175 void *argp1 = 0 ;
49176 int res1 = 0 ;
49177 PyObject *swig_obj[1] ;
49178
49179 if (!args) SWIG_fail;
49180 swig_obj[0] = args;
49181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49182 if (!SWIG_IsOK(res1)) {
49183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49184 }
49185 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49186 {
49187 PyThreadState* __tstate = wxPyBeginAllowThreads();
49188 result = (bool)(arg1)->IsSpacer();
49189 wxPyEndAllowThreads(__tstate);
49190 if (PyErr_Occurred()) SWIG_fail;
49191 }
49192 {
49193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49194 }
49195 return resultobj;
49196 fail:
49197 return NULL;
49198 }
49199
49200
49201 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49202 PyObject *resultobj = 0;
49203 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49204 int arg2 ;
49205 void *argp1 = 0 ;
49206 int res1 = 0 ;
49207 int val2 ;
49208 int ecode2 = 0 ;
49209 PyObject * obj0 = 0 ;
49210 PyObject * obj1 = 0 ;
49211 char * kwnames[] = {
49212 (char *) "self",(char *) "proportion", NULL
49213 };
49214
49215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49217 if (!SWIG_IsOK(res1)) {
49218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49219 }
49220 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49221 ecode2 = SWIG_AsVal_int(obj1, &val2);
49222 if (!SWIG_IsOK(ecode2)) {
49223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49224 }
49225 arg2 = static_cast< int >(val2);
49226 {
49227 PyThreadState* __tstate = wxPyBeginAllowThreads();
49228 (arg1)->SetProportion(arg2);
49229 wxPyEndAllowThreads(__tstate);
49230 if (PyErr_Occurred()) SWIG_fail;
49231 }
49232 resultobj = SWIG_Py_Void();
49233 return resultobj;
49234 fail:
49235 return NULL;
49236 }
49237
49238
49239 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49240 PyObject *resultobj = 0;
49241 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49242 int result;
49243 void *argp1 = 0 ;
49244 int res1 = 0 ;
49245 PyObject *swig_obj[1] ;
49246
49247 if (!args) SWIG_fail;
49248 swig_obj[0] = args;
49249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49250 if (!SWIG_IsOK(res1)) {
49251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49252 }
49253 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49254 {
49255 PyThreadState* __tstate = wxPyBeginAllowThreads();
49256 result = (int)(arg1)->GetProportion();
49257 wxPyEndAllowThreads(__tstate);
49258 if (PyErr_Occurred()) SWIG_fail;
49259 }
49260 resultobj = SWIG_From_int(static_cast< int >(result));
49261 return resultobj;
49262 fail:
49263 return NULL;
49264 }
49265
49266
49267 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49268 PyObject *resultobj = 0;
49269 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49270 int arg2 ;
49271 void *argp1 = 0 ;
49272 int res1 = 0 ;
49273 int val2 ;
49274 int ecode2 = 0 ;
49275 PyObject * obj0 = 0 ;
49276 PyObject * obj1 = 0 ;
49277 char * kwnames[] = {
49278 (char *) "self",(char *) "flag", NULL
49279 };
49280
49281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49283 if (!SWIG_IsOK(res1)) {
49284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49285 }
49286 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49287 ecode2 = SWIG_AsVal_int(obj1, &val2);
49288 if (!SWIG_IsOK(ecode2)) {
49289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49290 }
49291 arg2 = static_cast< int >(val2);
49292 {
49293 PyThreadState* __tstate = wxPyBeginAllowThreads();
49294 (arg1)->SetFlag(arg2);
49295 wxPyEndAllowThreads(__tstate);
49296 if (PyErr_Occurred()) SWIG_fail;
49297 }
49298 resultobj = SWIG_Py_Void();
49299 return resultobj;
49300 fail:
49301 return NULL;
49302 }
49303
49304
49305 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49306 PyObject *resultobj = 0;
49307 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49308 int result;
49309 void *argp1 = 0 ;
49310 int res1 = 0 ;
49311 PyObject *swig_obj[1] ;
49312
49313 if (!args) SWIG_fail;
49314 swig_obj[0] = args;
49315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49316 if (!SWIG_IsOK(res1)) {
49317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49318 }
49319 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49320 {
49321 PyThreadState* __tstate = wxPyBeginAllowThreads();
49322 result = (int)(arg1)->GetFlag();
49323 wxPyEndAllowThreads(__tstate);
49324 if (PyErr_Occurred()) SWIG_fail;
49325 }
49326 resultobj = SWIG_From_int(static_cast< int >(result));
49327 return resultobj;
49328 fail:
49329 return NULL;
49330 }
49331
49332
49333 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49334 PyObject *resultobj = 0;
49335 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49336 int arg2 ;
49337 void *argp1 = 0 ;
49338 int res1 = 0 ;
49339 int val2 ;
49340 int ecode2 = 0 ;
49341 PyObject * obj0 = 0 ;
49342 PyObject * obj1 = 0 ;
49343 char * kwnames[] = {
49344 (char *) "self",(char *) "border", NULL
49345 };
49346
49347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49349 if (!SWIG_IsOK(res1)) {
49350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49351 }
49352 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49353 ecode2 = SWIG_AsVal_int(obj1, &val2);
49354 if (!SWIG_IsOK(ecode2)) {
49355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49356 }
49357 arg2 = static_cast< int >(val2);
49358 {
49359 PyThreadState* __tstate = wxPyBeginAllowThreads();
49360 (arg1)->SetBorder(arg2);
49361 wxPyEndAllowThreads(__tstate);
49362 if (PyErr_Occurred()) SWIG_fail;
49363 }
49364 resultobj = SWIG_Py_Void();
49365 return resultobj;
49366 fail:
49367 return NULL;
49368 }
49369
49370
49371 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49372 PyObject *resultobj = 0;
49373 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49374 int result;
49375 void *argp1 = 0 ;
49376 int res1 = 0 ;
49377 PyObject *swig_obj[1] ;
49378
49379 if (!args) SWIG_fail;
49380 swig_obj[0] = args;
49381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49382 if (!SWIG_IsOK(res1)) {
49383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49384 }
49385 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49386 {
49387 PyThreadState* __tstate = wxPyBeginAllowThreads();
49388 result = (int)(arg1)->GetBorder();
49389 wxPyEndAllowThreads(__tstate);
49390 if (PyErr_Occurred()) SWIG_fail;
49391 }
49392 resultobj = SWIG_From_int(static_cast< int >(result));
49393 return resultobj;
49394 fail:
49395 return NULL;
49396 }
49397
49398
49399 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49400 PyObject *resultobj = 0;
49401 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49402 wxWindow *result = 0 ;
49403 void *argp1 = 0 ;
49404 int res1 = 0 ;
49405 PyObject *swig_obj[1] ;
49406
49407 if (!args) SWIG_fail;
49408 swig_obj[0] = args;
49409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49410 if (!SWIG_IsOK(res1)) {
49411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49412 }
49413 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49414 {
49415 PyThreadState* __tstate = wxPyBeginAllowThreads();
49416 result = (wxWindow *)(arg1)->GetWindow();
49417 wxPyEndAllowThreads(__tstate);
49418 if (PyErr_Occurred()) SWIG_fail;
49419 }
49420 {
49421 resultobj = wxPyMake_wxObject(result, 0);
49422 }
49423 return resultobj;
49424 fail:
49425 return NULL;
49426 }
49427
49428
49429 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49430 PyObject *resultobj = 0;
49431 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49432 wxWindow *arg2 = (wxWindow *) 0 ;
49433 void *argp1 = 0 ;
49434 int res1 = 0 ;
49435 void *argp2 = 0 ;
49436 int res2 = 0 ;
49437 PyObject * obj0 = 0 ;
49438 PyObject * obj1 = 0 ;
49439 char * kwnames[] = {
49440 (char *) "self",(char *) "window", NULL
49441 };
49442
49443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49445 if (!SWIG_IsOK(res1)) {
49446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49447 }
49448 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49450 if (!SWIG_IsOK(res2)) {
49451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49452 }
49453 arg2 = reinterpret_cast< wxWindow * >(argp2);
49454 {
49455 PyThreadState* __tstate = wxPyBeginAllowThreads();
49456 (arg1)->SetWindow(arg2);
49457 wxPyEndAllowThreads(__tstate);
49458 if (PyErr_Occurred()) SWIG_fail;
49459 }
49460 resultobj = SWIG_Py_Void();
49461 return resultobj;
49462 fail:
49463 return NULL;
49464 }
49465
49466
49467 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49468 PyObject *resultobj = 0;
49469 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49470 wxSizer *result = 0 ;
49471 void *argp1 = 0 ;
49472 int res1 = 0 ;
49473 PyObject *swig_obj[1] ;
49474
49475 if (!args) SWIG_fail;
49476 swig_obj[0] = args;
49477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49478 if (!SWIG_IsOK(res1)) {
49479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49480 }
49481 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49482 {
49483 PyThreadState* __tstate = wxPyBeginAllowThreads();
49484 result = (wxSizer *)(arg1)->GetSizer();
49485 wxPyEndAllowThreads(__tstate);
49486 if (PyErr_Occurred()) SWIG_fail;
49487 }
49488 {
49489 resultobj = wxPyMake_wxObject(result, (bool)0);
49490 }
49491 return resultobj;
49492 fail:
49493 return NULL;
49494 }
49495
49496
49497 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49498 PyObject *resultobj = 0;
49499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49500 wxSizer *arg2 = (wxSizer *) 0 ;
49501 void *argp1 = 0 ;
49502 int res1 = 0 ;
49503 int res2 = 0 ;
49504 PyObject * obj0 = 0 ;
49505 PyObject * obj1 = 0 ;
49506 char * kwnames[] = {
49507 (char *) "self",(char *) "sizer", NULL
49508 };
49509
49510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49512 if (!SWIG_IsOK(res1)) {
49513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49514 }
49515 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49516 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49517 if (!SWIG_IsOK(res2)) {
49518 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49519 }
49520 {
49521 PyThreadState* __tstate = wxPyBeginAllowThreads();
49522 (arg1)->SetSizer(arg2);
49523 wxPyEndAllowThreads(__tstate);
49524 if (PyErr_Occurred()) SWIG_fail;
49525 }
49526 resultobj = SWIG_Py_Void();
49527 return resultobj;
49528 fail:
49529 return NULL;
49530 }
49531
49532
49533 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49534 PyObject *resultobj = 0;
49535 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49536 wxSize result;
49537 void *argp1 = 0 ;
49538 int res1 = 0 ;
49539 PyObject *swig_obj[1] ;
49540
49541 if (!args) SWIG_fail;
49542 swig_obj[0] = args;
49543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49544 if (!SWIG_IsOK(res1)) {
49545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49546 }
49547 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49548 {
49549 PyThreadState* __tstate = wxPyBeginAllowThreads();
49550 result = (arg1)->GetSpacer();
49551 wxPyEndAllowThreads(__tstate);
49552 if (PyErr_Occurred()) SWIG_fail;
49553 }
49554 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49555 return resultobj;
49556 fail:
49557 return NULL;
49558 }
49559
49560
49561 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49562 PyObject *resultobj = 0;
49563 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49564 wxSize *arg2 = 0 ;
49565 void *argp1 = 0 ;
49566 int res1 = 0 ;
49567 wxSize temp2 ;
49568 PyObject * obj0 = 0 ;
49569 PyObject * obj1 = 0 ;
49570 char * kwnames[] = {
49571 (char *) "self",(char *) "size", NULL
49572 };
49573
49574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49576 if (!SWIG_IsOK(res1)) {
49577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49578 }
49579 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49580 {
49581 arg2 = &temp2;
49582 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49583 }
49584 {
49585 PyThreadState* __tstate = wxPyBeginAllowThreads();
49586 (arg1)->SetSpacer((wxSize const &)*arg2);
49587 wxPyEndAllowThreads(__tstate);
49588 if (PyErr_Occurred()) SWIG_fail;
49589 }
49590 resultobj = SWIG_Py_Void();
49591 return resultobj;
49592 fail:
49593 return NULL;
49594 }
49595
49596
49597 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49598 PyObject *resultobj = 0;
49599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49600 bool arg2 ;
49601 void *argp1 = 0 ;
49602 int res1 = 0 ;
49603 bool val2 ;
49604 int ecode2 = 0 ;
49605 PyObject * obj0 = 0 ;
49606 PyObject * obj1 = 0 ;
49607 char * kwnames[] = {
49608 (char *) "self",(char *) "show", NULL
49609 };
49610
49611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49613 if (!SWIG_IsOK(res1)) {
49614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49615 }
49616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49617 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49618 if (!SWIG_IsOK(ecode2)) {
49619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49620 }
49621 arg2 = static_cast< bool >(val2);
49622 {
49623 PyThreadState* __tstate = wxPyBeginAllowThreads();
49624 (arg1)->Show(arg2);
49625 wxPyEndAllowThreads(__tstate);
49626 if (PyErr_Occurred()) SWIG_fail;
49627 }
49628 resultobj = SWIG_Py_Void();
49629 return resultobj;
49630 fail:
49631 return NULL;
49632 }
49633
49634
49635 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49636 PyObject *resultobj = 0;
49637 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49638 bool result;
49639 void *argp1 = 0 ;
49640 int res1 = 0 ;
49641 PyObject *swig_obj[1] ;
49642
49643 if (!args) SWIG_fail;
49644 swig_obj[0] = args;
49645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49646 if (!SWIG_IsOK(res1)) {
49647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49648 }
49649 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49650 {
49651 PyThreadState* __tstate = wxPyBeginAllowThreads();
49652 result = (bool)(arg1)->IsShown();
49653 wxPyEndAllowThreads(__tstate);
49654 if (PyErr_Occurred()) SWIG_fail;
49655 }
49656 {
49657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49658 }
49659 return resultobj;
49660 fail:
49661 return NULL;
49662 }
49663
49664
49665 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49666 PyObject *resultobj = 0;
49667 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49668 wxPoint result;
49669 void *argp1 = 0 ;
49670 int res1 = 0 ;
49671 PyObject *swig_obj[1] ;
49672
49673 if (!args) SWIG_fail;
49674 swig_obj[0] = args;
49675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49676 if (!SWIG_IsOK(res1)) {
49677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49678 }
49679 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49680 {
49681 PyThreadState* __tstate = wxPyBeginAllowThreads();
49682 result = (arg1)->GetPosition();
49683 wxPyEndAllowThreads(__tstate);
49684 if (PyErr_Occurred()) SWIG_fail;
49685 }
49686 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49687 return resultobj;
49688 fail:
49689 return NULL;
49690 }
49691
49692
49693 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49694 PyObject *resultobj = 0;
49695 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49696 PyObject *result = 0 ;
49697 void *argp1 = 0 ;
49698 int res1 = 0 ;
49699 PyObject *swig_obj[1] ;
49700
49701 if (!args) SWIG_fail;
49702 swig_obj[0] = args;
49703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49704 if (!SWIG_IsOK(res1)) {
49705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49706 }
49707 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49708 {
49709 PyThreadState* __tstate = wxPyBeginAllowThreads();
49710 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49711 wxPyEndAllowThreads(__tstate);
49712 if (PyErr_Occurred()) SWIG_fail;
49713 }
49714 resultobj = result;
49715 return resultobj;
49716 fail:
49717 return NULL;
49718 }
49719
49720
49721 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49722 PyObject *resultobj = 0;
49723 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49724 PyObject *arg2 = (PyObject *) 0 ;
49725 void *argp1 = 0 ;
49726 int res1 = 0 ;
49727 PyObject * obj0 = 0 ;
49728 PyObject * obj1 = 0 ;
49729 char * kwnames[] = {
49730 (char *) "self",(char *) "userData", NULL
49731 };
49732
49733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49735 if (!SWIG_IsOK(res1)) {
49736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49737 }
49738 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49739 arg2 = obj1;
49740 {
49741 PyThreadState* __tstate = wxPyBeginAllowThreads();
49742 wxSizerItem_SetUserData(arg1,arg2);
49743 wxPyEndAllowThreads(__tstate);
49744 if (PyErr_Occurred()) SWIG_fail;
49745 }
49746 resultobj = SWIG_Py_Void();
49747 return resultobj;
49748 fail:
49749 return NULL;
49750 }
49751
49752
49753 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49754 PyObject *obj;
49755 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49756 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49757 return SWIG_Py_Void();
49758 }
49759
49760 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49761 return SWIG_Python_InitShadowInstance(args);
49762 }
49763
49764 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49765 PyObject *resultobj = 0;
49766 wxSizer *arg1 = (wxSizer *) 0 ;
49767 void *argp1 = 0 ;
49768 int res1 = 0 ;
49769 PyObject *swig_obj[1] ;
49770
49771 if (!args) SWIG_fail;
49772 swig_obj[0] = args;
49773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49774 if (!SWIG_IsOK(res1)) {
49775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49776 }
49777 arg1 = reinterpret_cast< wxSizer * >(argp1);
49778 {
49779 PyThreadState* __tstate = wxPyBeginAllowThreads();
49780 delete arg1;
49781
49782 wxPyEndAllowThreads(__tstate);
49783 if (PyErr_Occurred()) SWIG_fail;
49784 }
49785 resultobj = SWIG_Py_Void();
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49793 PyObject *resultobj = 0;
49794 wxSizer *arg1 = (wxSizer *) 0 ;
49795 PyObject *arg2 = (PyObject *) 0 ;
49796 void *argp1 = 0 ;
49797 int res1 = 0 ;
49798 PyObject * obj0 = 0 ;
49799 PyObject * obj1 = 0 ;
49800 char * kwnames[] = {
49801 (char *) "self",(char *) "_self", NULL
49802 };
49803
49804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49806 if (!SWIG_IsOK(res1)) {
49807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49808 }
49809 arg1 = reinterpret_cast< wxSizer * >(argp1);
49810 arg2 = obj1;
49811 {
49812 PyThreadState* __tstate = wxPyBeginAllowThreads();
49813 wxSizer__setOORInfo(arg1,arg2);
49814 wxPyEndAllowThreads(__tstate);
49815 if (PyErr_Occurred()) SWIG_fail;
49816 }
49817 resultobj = SWIG_Py_Void();
49818 return resultobj;
49819 fail:
49820 return NULL;
49821 }
49822
49823
49824 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49825 PyObject *resultobj = 0;
49826 wxSizer *arg1 = (wxSizer *) 0 ;
49827 PyObject *arg2 = (PyObject *) 0 ;
49828 int arg3 = (int) 0 ;
49829 int arg4 = (int) 0 ;
49830 int arg5 = (int) 0 ;
49831 PyObject *arg6 = (PyObject *) NULL ;
49832 wxSizerItem *result = 0 ;
49833 void *argp1 = 0 ;
49834 int res1 = 0 ;
49835 int val3 ;
49836 int ecode3 = 0 ;
49837 int val4 ;
49838 int ecode4 = 0 ;
49839 int val5 ;
49840 int ecode5 = 0 ;
49841 PyObject * obj0 = 0 ;
49842 PyObject * obj1 = 0 ;
49843 PyObject * obj2 = 0 ;
49844 PyObject * obj3 = 0 ;
49845 PyObject * obj4 = 0 ;
49846 PyObject * obj5 = 0 ;
49847 char * kwnames[] = {
49848 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49849 };
49850
49851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49853 if (!SWIG_IsOK(res1)) {
49854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49855 }
49856 arg1 = reinterpret_cast< wxSizer * >(argp1);
49857 arg2 = obj1;
49858 if (obj2) {
49859 ecode3 = SWIG_AsVal_int(obj2, &val3);
49860 if (!SWIG_IsOK(ecode3)) {
49861 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49862 }
49863 arg3 = static_cast< int >(val3);
49864 }
49865 if (obj3) {
49866 ecode4 = SWIG_AsVal_int(obj3, &val4);
49867 if (!SWIG_IsOK(ecode4)) {
49868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49869 }
49870 arg4 = static_cast< int >(val4);
49871 }
49872 if (obj4) {
49873 ecode5 = SWIG_AsVal_int(obj4, &val5);
49874 if (!SWIG_IsOK(ecode5)) {
49875 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49876 }
49877 arg5 = static_cast< int >(val5);
49878 }
49879 if (obj5) {
49880 arg6 = obj5;
49881 }
49882 {
49883 PyThreadState* __tstate = wxPyBeginAllowThreads();
49884 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49885 wxPyEndAllowThreads(__tstate);
49886 if (PyErr_Occurred()) SWIG_fail;
49887 }
49888 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49889 return resultobj;
49890 fail:
49891 return NULL;
49892 }
49893
49894
49895 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49896 PyObject *resultobj = 0;
49897 wxSizer *arg1 = (wxSizer *) 0 ;
49898 int arg2 ;
49899 PyObject *arg3 = (PyObject *) 0 ;
49900 int arg4 = (int) 0 ;
49901 int arg5 = (int) 0 ;
49902 int arg6 = (int) 0 ;
49903 PyObject *arg7 = (PyObject *) NULL ;
49904 wxSizerItem *result = 0 ;
49905 void *argp1 = 0 ;
49906 int res1 = 0 ;
49907 int val2 ;
49908 int ecode2 = 0 ;
49909 int val4 ;
49910 int ecode4 = 0 ;
49911 int val5 ;
49912 int ecode5 = 0 ;
49913 int val6 ;
49914 int ecode6 = 0 ;
49915 PyObject * obj0 = 0 ;
49916 PyObject * obj1 = 0 ;
49917 PyObject * obj2 = 0 ;
49918 PyObject * obj3 = 0 ;
49919 PyObject * obj4 = 0 ;
49920 PyObject * obj5 = 0 ;
49921 PyObject * obj6 = 0 ;
49922 char * kwnames[] = {
49923 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49924 };
49925
49926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49928 if (!SWIG_IsOK(res1)) {
49929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49930 }
49931 arg1 = reinterpret_cast< wxSizer * >(argp1);
49932 ecode2 = SWIG_AsVal_int(obj1, &val2);
49933 if (!SWIG_IsOK(ecode2)) {
49934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49935 }
49936 arg2 = static_cast< int >(val2);
49937 arg3 = obj2;
49938 if (obj3) {
49939 ecode4 = SWIG_AsVal_int(obj3, &val4);
49940 if (!SWIG_IsOK(ecode4)) {
49941 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49942 }
49943 arg4 = static_cast< int >(val4);
49944 }
49945 if (obj4) {
49946 ecode5 = SWIG_AsVal_int(obj4, &val5);
49947 if (!SWIG_IsOK(ecode5)) {
49948 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49949 }
49950 arg5 = static_cast< int >(val5);
49951 }
49952 if (obj5) {
49953 ecode6 = SWIG_AsVal_int(obj5, &val6);
49954 if (!SWIG_IsOK(ecode6)) {
49955 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49956 }
49957 arg6 = static_cast< int >(val6);
49958 }
49959 if (obj6) {
49960 arg7 = obj6;
49961 }
49962 {
49963 PyThreadState* __tstate = wxPyBeginAllowThreads();
49964 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49965 wxPyEndAllowThreads(__tstate);
49966 if (PyErr_Occurred()) SWIG_fail;
49967 }
49968 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49969 return resultobj;
49970 fail:
49971 return NULL;
49972 }
49973
49974
49975 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49976 PyObject *resultobj = 0;
49977 wxSizer *arg1 = (wxSizer *) 0 ;
49978 PyObject *arg2 = (PyObject *) 0 ;
49979 int arg3 = (int) 0 ;
49980 int arg4 = (int) 0 ;
49981 int arg5 = (int) 0 ;
49982 PyObject *arg6 = (PyObject *) NULL ;
49983 wxSizerItem *result = 0 ;
49984 void *argp1 = 0 ;
49985 int res1 = 0 ;
49986 int val3 ;
49987 int ecode3 = 0 ;
49988 int val4 ;
49989 int ecode4 = 0 ;
49990 int val5 ;
49991 int ecode5 = 0 ;
49992 PyObject * obj0 = 0 ;
49993 PyObject * obj1 = 0 ;
49994 PyObject * obj2 = 0 ;
49995 PyObject * obj3 = 0 ;
49996 PyObject * obj4 = 0 ;
49997 PyObject * obj5 = 0 ;
49998 char * kwnames[] = {
49999 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50000 };
50001
50002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50004 if (!SWIG_IsOK(res1)) {
50005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
50006 }
50007 arg1 = reinterpret_cast< wxSizer * >(argp1);
50008 arg2 = obj1;
50009 if (obj2) {
50010 ecode3 = SWIG_AsVal_int(obj2, &val3);
50011 if (!SWIG_IsOK(ecode3)) {
50012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
50013 }
50014 arg3 = static_cast< int >(val3);
50015 }
50016 if (obj3) {
50017 ecode4 = SWIG_AsVal_int(obj3, &val4);
50018 if (!SWIG_IsOK(ecode4)) {
50019 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
50020 }
50021 arg4 = static_cast< int >(val4);
50022 }
50023 if (obj4) {
50024 ecode5 = SWIG_AsVal_int(obj4, &val5);
50025 if (!SWIG_IsOK(ecode5)) {
50026 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50027 }
50028 arg5 = static_cast< int >(val5);
50029 }
50030 if (obj5) {
50031 arg6 = obj5;
50032 }
50033 {
50034 PyThreadState* __tstate = wxPyBeginAllowThreads();
50035 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50036 wxPyEndAllowThreads(__tstate);
50037 if (PyErr_Occurred()) SWIG_fail;
50038 }
50039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50040 return resultobj;
50041 fail:
50042 return NULL;
50043 }
50044
50045
50046 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50047 PyObject *resultobj = 0;
50048 wxSizer *arg1 = (wxSizer *) 0 ;
50049 PyObject *arg2 = (PyObject *) 0 ;
50050 bool result;
50051 void *argp1 = 0 ;
50052 int res1 = 0 ;
50053 PyObject * obj0 = 0 ;
50054 PyObject * obj1 = 0 ;
50055 char * kwnames[] = {
50056 (char *) "self",(char *) "item", NULL
50057 };
50058
50059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50061 if (!SWIG_IsOK(res1)) {
50062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50063 }
50064 arg1 = reinterpret_cast< wxSizer * >(argp1);
50065 arg2 = obj1;
50066 {
50067 PyThreadState* __tstate = wxPyBeginAllowThreads();
50068 result = (bool)wxSizer_Remove(arg1,arg2);
50069 wxPyEndAllowThreads(__tstate);
50070 if (PyErr_Occurred()) SWIG_fail;
50071 }
50072 {
50073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50074 }
50075 return resultobj;
50076 fail:
50077 return NULL;
50078 }
50079
50080
50081 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50082 PyObject *resultobj = 0;
50083 wxSizer *arg1 = (wxSizer *) 0 ;
50084 PyObject *arg2 = (PyObject *) 0 ;
50085 bool result;
50086 void *argp1 = 0 ;
50087 int res1 = 0 ;
50088 PyObject * obj0 = 0 ;
50089 PyObject * obj1 = 0 ;
50090 char * kwnames[] = {
50091 (char *) "self",(char *) "item", NULL
50092 };
50093
50094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50096 if (!SWIG_IsOK(res1)) {
50097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50098 }
50099 arg1 = reinterpret_cast< wxSizer * >(argp1);
50100 arg2 = obj1;
50101 {
50102 PyThreadState* __tstate = wxPyBeginAllowThreads();
50103 result = (bool)wxSizer_Detach(arg1,arg2);
50104 wxPyEndAllowThreads(__tstate);
50105 if (PyErr_Occurred()) SWIG_fail;
50106 }
50107 {
50108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50109 }
50110 return resultobj;
50111 fail:
50112 return NULL;
50113 }
50114
50115
50116 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50117 PyObject *resultobj = 0;
50118 wxSizer *arg1 = (wxSizer *) 0 ;
50119 PyObject *arg2 = (PyObject *) 0 ;
50120 wxSizerItem *result = 0 ;
50121 void *argp1 = 0 ;
50122 int res1 = 0 ;
50123 PyObject * obj0 = 0 ;
50124 PyObject * obj1 = 0 ;
50125 char * kwnames[] = {
50126 (char *) "self",(char *) "item", NULL
50127 };
50128
50129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50131 if (!SWIG_IsOK(res1)) {
50132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50133 }
50134 arg1 = reinterpret_cast< wxSizer * >(argp1);
50135 arg2 = obj1;
50136 {
50137 PyThreadState* __tstate = wxPyBeginAllowThreads();
50138 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50139 wxPyEndAllowThreads(__tstate);
50140 if (PyErr_Occurred()) SWIG_fail;
50141 }
50142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50143 return resultobj;
50144 fail:
50145 return NULL;
50146 }
50147
50148
50149 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50150 PyObject *resultobj = 0;
50151 wxSizer *arg1 = (wxSizer *) 0 ;
50152 PyObject *arg2 = (PyObject *) 0 ;
50153 wxSize *arg3 = 0 ;
50154 void *argp1 = 0 ;
50155 int res1 = 0 ;
50156 wxSize temp3 ;
50157 PyObject * obj0 = 0 ;
50158 PyObject * obj1 = 0 ;
50159 PyObject * obj2 = 0 ;
50160 char * kwnames[] = {
50161 (char *) "self",(char *) "item",(char *) "size", NULL
50162 };
50163
50164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50166 if (!SWIG_IsOK(res1)) {
50167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50168 }
50169 arg1 = reinterpret_cast< wxSizer * >(argp1);
50170 arg2 = obj1;
50171 {
50172 arg3 = &temp3;
50173 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50174 }
50175 {
50176 PyThreadState* __tstate = wxPyBeginAllowThreads();
50177 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50178 wxPyEndAllowThreads(__tstate);
50179 if (PyErr_Occurred()) SWIG_fail;
50180 }
50181 resultobj = SWIG_Py_Void();
50182 return resultobj;
50183 fail:
50184 return NULL;
50185 }
50186
50187
50188 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50189 PyObject *resultobj = 0;
50190 wxSizer *arg1 = (wxSizer *) 0 ;
50191 wxWindow *arg2 = (wxWindow *) 0 ;
50192 wxWindow *arg3 = (wxWindow *) 0 ;
50193 bool arg4 = (bool) false ;
50194 bool result;
50195 void *argp1 = 0 ;
50196 int res1 = 0 ;
50197 void *argp2 = 0 ;
50198 int res2 = 0 ;
50199 void *argp3 = 0 ;
50200 int res3 = 0 ;
50201 bool val4 ;
50202 int ecode4 = 0 ;
50203 PyObject * obj0 = 0 ;
50204 PyObject * obj1 = 0 ;
50205 PyObject * obj2 = 0 ;
50206 PyObject * obj3 = 0 ;
50207 char * kwnames[] = {
50208 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50209 };
50210
50211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50213 if (!SWIG_IsOK(res1)) {
50214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50215 }
50216 arg1 = reinterpret_cast< wxSizer * >(argp1);
50217 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50218 if (!SWIG_IsOK(res2)) {
50219 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50220 }
50221 arg2 = reinterpret_cast< wxWindow * >(argp2);
50222 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50223 if (!SWIG_IsOK(res3)) {
50224 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50225 }
50226 arg3 = reinterpret_cast< wxWindow * >(argp3);
50227 if (obj3) {
50228 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50229 if (!SWIG_IsOK(ecode4)) {
50230 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50231 }
50232 arg4 = static_cast< bool >(val4);
50233 }
50234 {
50235 PyThreadState* __tstate = wxPyBeginAllowThreads();
50236 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50237 wxPyEndAllowThreads(__tstate);
50238 if (PyErr_Occurred()) SWIG_fail;
50239 }
50240 {
50241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50242 }
50243 return resultobj;
50244 fail:
50245 return NULL;
50246 }
50247
50248
50249 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50250 PyObject *resultobj = 0;
50251 wxSizer *arg1 = (wxSizer *) 0 ;
50252 wxSizer *arg2 = (wxSizer *) 0 ;
50253 wxSizer *arg3 = (wxSizer *) 0 ;
50254 bool arg4 = (bool) false ;
50255 bool result;
50256 void *argp1 = 0 ;
50257 int res1 = 0 ;
50258 void *argp2 = 0 ;
50259 int res2 = 0 ;
50260 void *argp3 = 0 ;
50261 int res3 = 0 ;
50262 bool val4 ;
50263 int ecode4 = 0 ;
50264 PyObject * obj0 = 0 ;
50265 PyObject * obj1 = 0 ;
50266 PyObject * obj2 = 0 ;
50267 PyObject * obj3 = 0 ;
50268 char * kwnames[] = {
50269 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50270 };
50271
50272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50274 if (!SWIG_IsOK(res1)) {
50275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50276 }
50277 arg1 = reinterpret_cast< wxSizer * >(argp1);
50278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50279 if (!SWIG_IsOK(res2)) {
50280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50281 }
50282 arg2 = reinterpret_cast< wxSizer * >(argp2);
50283 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50284 if (!SWIG_IsOK(res3)) {
50285 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50286 }
50287 arg3 = reinterpret_cast< wxSizer * >(argp3);
50288 if (obj3) {
50289 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50290 if (!SWIG_IsOK(ecode4)) {
50291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50292 }
50293 arg4 = static_cast< bool >(val4);
50294 }
50295 {
50296 PyThreadState* __tstate = wxPyBeginAllowThreads();
50297 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50298 wxPyEndAllowThreads(__tstate);
50299 if (PyErr_Occurred()) SWIG_fail;
50300 }
50301 {
50302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50303 }
50304 return resultobj;
50305 fail:
50306 return NULL;
50307 }
50308
50309
50310 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50311 PyObject *resultobj = 0;
50312 wxSizer *arg1 = (wxSizer *) 0 ;
50313 size_t arg2 ;
50314 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50315 bool result;
50316 void *argp1 = 0 ;
50317 int res1 = 0 ;
50318 size_t val2 ;
50319 int ecode2 = 0 ;
50320 void *argp3 = 0 ;
50321 int res3 = 0 ;
50322 PyObject * obj0 = 0 ;
50323 PyObject * obj1 = 0 ;
50324 PyObject * obj2 = 0 ;
50325 char * kwnames[] = {
50326 (char *) "self",(char *) "index",(char *) "newitem", NULL
50327 };
50328
50329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50331 if (!SWIG_IsOK(res1)) {
50332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50333 }
50334 arg1 = reinterpret_cast< wxSizer * >(argp1);
50335 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50336 if (!SWIG_IsOK(ecode2)) {
50337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50338 }
50339 arg2 = static_cast< size_t >(val2);
50340 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50341 if (!SWIG_IsOK(res3)) {
50342 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50343 }
50344 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50345 {
50346 PyThreadState* __tstate = wxPyBeginAllowThreads();
50347 result = (bool)(arg1)->Replace(arg2,arg3);
50348 wxPyEndAllowThreads(__tstate);
50349 if (PyErr_Occurred()) SWIG_fail;
50350 }
50351 {
50352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50353 }
50354 return resultobj;
50355 fail:
50356 return NULL;
50357 }
50358
50359
50360 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50361 PyObject *resultobj = 0;
50362 wxSizer *arg1 = (wxSizer *) 0 ;
50363 wxWindow *arg2 = (wxWindow *) 0 ;
50364 void *argp1 = 0 ;
50365 int res1 = 0 ;
50366 void *argp2 = 0 ;
50367 int res2 = 0 ;
50368 PyObject * obj0 = 0 ;
50369 PyObject * obj1 = 0 ;
50370 char * kwnames[] = {
50371 (char *) "self",(char *) "window", NULL
50372 };
50373
50374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50376 if (!SWIG_IsOK(res1)) {
50377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50378 }
50379 arg1 = reinterpret_cast< wxSizer * >(argp1);
50380 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50381 if (!SWIG_IsOK(res2)) {
50382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50383 }
50384 arg2 = reinterpret_cast< wxWindow * >(argp2);
50385 {
50386 PyThreadState* __tstate = wxPyBeginAllowThreads();
50387 (arg1)->SetContainingWindow(arg2);
50388 wxPyEndAllowThreads(__tstate);
50389 if (PyErr_Occurred()) SWIG_fail;
50390 }
50391 resultobj = SWIG_Py_Void();
50392 return resultobj;
50393 fail:
50394 return NULL;
50395 }
50396
50397
50398 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50399 PyObject *resultobj = 0;
50400 wxSizer *arg1 = (wxSizer *) 0 ;
50401 wxWindow *result = 0 ;
50402 void *argp1 = 0 ;
50403 int res1 = 0 ;
50404 PyObject *swig_obj[1] ;
50405
50406 if (!args) SWIG_fail;
50407 swig_obj[0] = args;
50408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50409 if (!SWIG_IsOK(res1)) {
50410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50411 }
50412 arg1 = reinterpret_cast< wxSizer * >(argp1);
50413 {
50414 PyThreadState* __tstate = wxPyBeginAllowThreads();
50415 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50416 wxPyEndAllowThreads(__tstate);
50417 if (PyErr_Occurred()) SWIG_fail;
50418 }
50419 {
50420 resultobj = wxPyMake_wxObject(result, 0);
50421 }
50422 return resultobj;
50423 fail:
50424 return NULL;
50425 }
50426
50427
50428 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50429 PyObject *resultobj = 0;
50430 wxSizer *arg1 = (wxSizer *) 0 ;
50431 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50432 wxSizerItem *result = 0 ;
50433 void *argp1 = 0 ;
50434 int res1 = 0 ;
50435 int res2 = 0 ;
50436 PyObject * obj0 = 0 ;
50437 PyObject * obj1 = 0 ;
50438 char * kwnames[] = {
50439 (char *) "self",(char *) "item", NULL
50440 };
50441
50442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50444 if (!SWIG_IsOK(res1)) {
50445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50446 }
50447 arg1 = reinterpret_cast< wxSizer * >(argp1);
50448 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50449 if (!SWIG_IsOK(res2)) {
50450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50451 }
50452 {
50453 PyThreadState* __tstate = wxPyBeginAllowThreads();
50454 result = (wxSizerItem *)(arg1)->Add(arg2);
50455 wxPyEndAllowThreads(__tstate);
50456 if (PyErr_Occurred()) SWIG_fail;
50457 }
50458 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50459 return resultobj;
50460 fail:
50461 return NULL;
50462 }
50463
50464
50465 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50466 PyObject *resultobj = 0;
50467 wxSizer *arg1 = (wxSizer *) 0 ;
50468 size_t arg2 ;
50469 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50470 wxSizerItem *result = 0 ;
50471 void *argp1 = 0 ;
50472 int res1 = 0 ;
50473 size_t val2 ;
50474 int ecode2 = 0 ;
50475 int res3 = 0 ;
50476 PyObject * obj0 = 0 ;
50477 PyObject * obj1 = 0 ;
50478 PyObject * obj2 = 0 ;
50479 char * kwnames[] = {
50480 (char *) "self",(char *) "index",(char *) "item", NULL
50481 };
50482
50483 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50484 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50485 if (!SWIG_IsOK(res1)) {
50486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50487 }
50488 arg1 = reinterpret_cast< wxSizer * >(argp1);
50489 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50490 if (!SWIG_IsOK(ecode2)) {
50491 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50492 }
50493 arg2 = static_cast< size_t >(val2);
50494 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50495 if (!SWIG_IsOK(res3)) {
50496 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50497 }
50498 {
50499 PyThreadState* __tstate = wxPyBeginAllowThreads();
50500 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50501 wxPyEndAllowThreads(__tstate);
50502 if (PyErr_Occurred()) SWIG_fail;
50503 }
50504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50505 return resultobj;
50506 fail:
50507 return NULL;
50508 }
50509
50510
50511 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50512 PyObject *resultobj = 0;
50513 wxSizer *arg1 = (wxSizer *) 0 ;
50514 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50515 wxSizerItem *result = 0 ;
50516 void *argp1 = 0 ;
50517 int res1 = 0 ;
50518 int res2 = 0 ;
50519 PyObject * obj0 = 0 ;
50520 PyObject * obj1 = 0 ;
50521 char * kwnames[] = {
50522 (char *) "self",(char *) "item", NULL
50523 };
50524
50525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50527 if (!SWIG_IsOK(res1)) {
50528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50529 }
50530 arg1 = reinterpret_cast< wxSizer * >(argp1);
50531 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50532 if (!SWIG_IsOK(res2)) {
50533 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50534 }
50535 {
50536 PyThreadState* __tstate = wxPyBeginAllowThreads();
50537 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50538 wxPyEndAllowThreads(__tstate);
50539 if (PyErr_Occurred()) SWIG_fail;
50540 }
50541 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50542 return resultobj;
50543 fail:
50544 return NULL;
50545 }
50546
50547
50548 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50549 PyObject *resultobj = 0;
50550 wxSizer *arg1 = (wxSizer *) 0 ;
50551 int arg2 ;
50552 int arg3 ;
50553 int arg4 ;
50554 int arg5 ;
50555 void *argp1 = 0 ;
50556 int res1 = 0 ;
50557 int val2 ;
50558 int ecode2 = 0 ;
50559 int val3 ;
50560 int ecode3 = 0 ;
50561 int val4 ;
50562 int ecode4 = 0 ;
50563 int val5 ;
50564 int ecode5 = 0 ;
50565 PyObject * obj0 = 0 ;
50566 PyObject * obj1 = 0 ;
50567 PyObject * obj2 = 0 ;
50568 PyObject * obj3 = 0 ;
50569 PyObject * obj4 = 0 ;
50570 char * kwnames[] = {
50571 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50572 };
50573
50574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50576 if (!SWIG_IsOK(res1)) {
50577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50578 }
50579 arg1 = reinterpret_cast< wxSizer * >(argp1);
50580 ecode2 = SWIG_AsVal_int(obj1, &val2);
50581 if (!SWIG_IsOK(ecode2)) {
50582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50583 }
50584 arg2 = static_cast< int >(val2);
50585 ecode3 = SWIG_AsVal_int(obj2, &val3);
50586 if (!SWIG_IsOK(ecode3)) {
50587 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50588 }
50589 arg3 = static_cast< int >(val3);
50590 ecode4 = SWIG_AsVal_int(obj3, &val4);
50591 if (!SWIG_IsOK(ecode4)) {
50592 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50593 }
50594 arg4 = static_cast< int >(val4);
50595 ecode5 = SWIG_AsVal_int(obj4, &val5);
50596 if (!SWIG_IsOK(ecode5)) {
50597 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50598 }
50599 arg5 = static_cast< int >(val5);
50600 {
50601 PyThreadState* __tstate = wxPyBeginAllowThreads();
50602 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50603 wxPyEndAllowThreads(__tstate);
50604 if (PyErr_Occurred()) SWIG_fail;
50605 }
50606 resultobj = SWIG_Py_Void();
50607 return resultobj;
50608 fail:
50609 return NULL;
50610 }
50611
50612
50613 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50614 PyObject *resultobj = 0;
50615 wxSizer *arg1 = (wxSizer *) 0 ;
50616 wxSize *arg2 = 0 ;
50617 void *argp1 = 0 ;
50618 int res1 = 0 ;
50619 wxSize temp2 ;
50620 PyObject * obj0 = 0 ;
50621 PyObject * obj1 = 0 ;
50622 char * kwnames[] = {
50623 (char *) "self",(char *) "size", NULL
50624 };
50625
50626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50628 if (!SWIG_IsOK(res1)) {
50629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50630 }
50631 arg1 = reinterpret_cast< wxSizer * >(argp1);
50632 {
50633 arg2 = &temp2;
50634 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50635 }
50636 {
50637 PyThreadState* __tstate = wxPyBeginAllowThreads();
50638 (arg1)->SetMinSize((wxSize const &)*arg2);
50639 wxPyEndAllowThreads(__tstate);
50640 if (PyErr_Occurred()) SWIG_fail;
50641 }
50642 resultobj = SWIG_Py_Void();
50643 return resultobj;
50644 fail:
50645 return NULL;
50646 }
50647
50648
50649 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50650 PyObject *resultobj = 0;
50651 wxSizer *arg1 = (wxSizer *) 0 ;
50652 wxSize result;
50653 void *argp1 = 0 ;
50654 int res1 = 0 ;
50655 PyObject *swig_obj[1] ;
50656
50657 if (!args) SWIG_fail;
50658 swig_obj[0] = args;
50659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50660 if (!SWIG_IsOK(res1)) {
50661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50662 }
50663 arg1 = reinterpret_cast< wxSizer * >(argp1);
50664 {
50665 PyThreadState* __tstate = wxPyBeginAllowThreads();
50666 result = (arg1)->GetSize();
50667 wxPyEndAllowThreads(__tstate);
50668 if (PyErr_Occurred()) SWIG_fail;
50669 }
50670 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50671 return resultobj;
50672 fail:
50673 return NULL;
50674 }
50675
50676
50677 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50678 PyObject *resultobj = 0;
50679 wxSizer *arg1 = (wxSizer *) 0 ;
50680 wxPoint result;
50681 void *argp1 = 0 ;
50682 int res1 = 0 ;
50683 PyObject *swig_obj[1] ;
50684
50685 if (!args) SWIG_fail;
50686 swig_obj[0] = args;
50687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50688 if (!SWIG_IsOK(res1)) {
50689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50690 }
50691 arg1 = reinterpret_cast< wxSizer * >(argp1);
50692 {
50693 PyThreadState* __tstate = wxPyBeginAllowThreads();
50694 result = (arg1)->GetPosition();
50695 wxPyEndAllowThreads(__tstate);
50696 if (PyErr_Occurred()) SWIG_fail;
50697 }
50698 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50699 return resultobj;
50700 fail:
50701 return NULL;
50702 }
50703
50704
50705 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50706 PyObject *resultobj = 0;
50707 wxSizer *arg1 = (wxSizer *) 0 ;
50708 wxSize result;
50709 void *argp1 = 0 ;
50710 int res1 = 0 ;
50711 PyObject *swig_obj[1] ;
50712
50713 if (!args) SWIG_fail;
50714 swig_obj[0] = args;
50715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50716 if (!SWIG_IsOK(res1)) {
50717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50718 }
50719 arg1 = reinterpret_cast< wxSizer * >(argp1);
50720 {
50721 PyThreadState* __tstate = wxPyBeginAllowThreads();
50722 result = (arg1)->GetMinSize();
50723 wxPyEndAllowThreads(__tstate);
50724 if (PyErr_Occurred()) SWIG_fail;
50725 }
50726 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50727 return resultobj;
50728 fail:
50729 return NULL;
50730 }
50731
50732
50733 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50734 PyObject *resultobj = 0;
50735 wxSizer *arg1 = (wxSizer *) 0 ;
50736 void *argp1 = 0 ;
50737 int res1 = 0 ;
50738 PyObject *swig_obj[1] ;
50739
50740 if (!args) SWIG_fail;
50741 swig_obj[0] = args;
50742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50743 if (!SWIG_IsOK(res1)) {
50744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50745 }
50746 arg1 = reinterpret_cast< wxSizer * >(argp1);
50747 {
50748 PyThreadState* __tstate = wxPyBeginAllowThreads();
50749 (arg1)->RecalcSizes();
50750 wxPyEndAllowThreads(__tstate);
50751 if (PyErr_Occurred()) SWIG_fail;
50752 }
50753 resultobj = SWIG_Py_Void();
50754 return resultobj;
50755 fail:
50756 return NULL;
50757 }
50758
50759
50760 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50761 PyObject *resultobj = 0;
50762 wxSizer *arg1 = (wxSizer *) 0 ;
50763 wxSize result;
50764 void *argp1 = 0 ;
50765 int res1 = 0 ;
50766 PyObject *swig_obj[1] ;
50767
50768 if (!args) SWIG_fail;
50769 swig_obj[0] = args;
50770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50771 if (!SWIG_IsOK(res1)) {
50772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50773 }
50774 arg1 = reinterpret_cast< wxSizer * >(argp1);
50775 {
50776 PyThreadState* __tstate = wxPyBeginAllowThreads();
50777 result = (arg1)->CalcMin();
50778 wxPyEndAllowThreads(__tstate);
50779 if (PyErr_Occurred()) SWIG_fail;
50780 }
50781 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50782 return resultobj;
50783 fail:
50784 return NULL;
50785 }
50786
50787
50788 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50789 PyObject *resultobj = 0;
50790 wxSizer *arg1 = (wxSizer *) 0 ;
50791 void *argp1 = 0 ;
50792 int res1 = 0 ;
50793 PyObject *swig_obj[1] ;
50794
50795 if (!args) SWIG_fail;
50796 swig_obj[0] = args;
50797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50798 if (!SWIG_IsOK(res1)) {
50799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50800 }
50801 arg1 = reinterpret_cast< wxSizer * >(argp1);
50802 {
50803 PyThreadState* __tstate = wxPyBeginAllowThreads();
50804 (arg1)->Layout();
50805 wxPyEndAllowThreads(__tstate);
50806 if (PyErr_Occurred()) SWIG_fail;
50807 }
50808 resultobj = SWIG_Py_Void();
50809 return resultobj;
50810 fail:
50811 return NULL;
50812 }
50813
50814
50815 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50816 PyObject *resultobj = 0;
50817 wxSizer *arg1 = (wxSizer *) 0 ;
50818 wxWindow *arg2 = (wxWindow *) 0 ;
50819 wxSize result;
50820 void *argp1 = 0 ;
50821 int res1 = 0 ;
50822 void *argp2 = 0 ;
50823 int res2 = 0 ;
50824 PyObject * obj0 = 0 ;
50825 PyObject * obj1 = 0 ;
50826 char * kwnames[] = {
50827 (char *) "self",(char *) "window", NULL
50828 };
50829
50830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50832 if (!SWIG_IsOK(res1)) {
50833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50834 }
50835 arg1 = reinterpret_cast< wxSizer * >(argp1);
50836 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50837 if (!SWIG_IsOK(res2)) {
50838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50839 }
50840 arg2 = reinterpret_cast< wxWindow * >(argp2);
50841 {
50842 PyThreadState* __tstate = wxPyBeginAllowThreads();
50843 result = (arg1)->Fit(arg2);
50844 wxPyEndAllowThreads(__tstate);
50845 if (PyErr_Occurred()) SWIG_fail;
50846 }
50847 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50848 return resultobj;
50849 fail:
50850 return NULL;
50851 }
50852
50853
50854 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50855 PyObject *resultobj = 0;
50856 wxSizer *arg1 = (wxSizer *) 0 ;
50857 wxWindow *arg2 = (wxWindow *) 0 ;
50858 void *argp1 = 0 ;
50859 int res1 = 0 ;
50860 void *argp2 = 0 ;
50861 int res2 = 0 ;
50862 PyObject * obj0 = 0 ;
50863 PyObject * obj1 = 0 ;
50864 char * kwnames[] = {
50865 (char *) "self",(char *) "window", NULL
50866 };
50867
50868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50870 if (!SWIG_IsOK(res1)) {
50871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50872 }
50873 arg1 = reinterpret_cast< wxSizer * >(argp1);
50874 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50875 if (!SWIG_IsOK(res2)) {
50876 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50877 }
50878 arg2 = reinterpret_cast< wxWindow * >(argp2);
50879 {
50880 PyThreadState* __tstate = wxPyBeginAllowThreads();
50881 (arg1)->FitInside(arg2);
50882 wxPyEndAllowThreads(__tstate);
50883 if (PyErr_Occurred()) SWIG_fail;
50884 }
50885 resultobj = SWIG_Py_Void();
50886 return resultobj;
50887 fail:
50888 return NULL;
50889 }
50890
50891
50892 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50893 PyObject *resultobj = 0;
50894 wxSizer *arg1 = (wxSizer *) 0 ;
50895 wxWindow *arg2 = (wxWindow *) 0 ;
50896 void *argp1 = 0 ;
50897 int res1 = 0 ;
50898 void *argp2 = 0 ;
50899 int res2 = 0 ;
50900 PyObject * obj0 = 0 ;
50901 PyObject * obj1 = 0 ;
50902 char * kwnames[] = {
50903 (char *) "self",(char *) "window", NULL
50904 };
50905
50906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50908 if (!SWIG_IsOK(res1)) {
50909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50910 }
50911 arg1 = reinterpret_cast< wxSizer * >(argp1);
50912 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50913 if (!SWIG_IsOK(res2)) {
50914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50915 }
50916 arg2 = reinterpret_cast< wxWindow * >(argp2);
50917 {
50918 PyThreadState* __tstate = wxPyBeginAllowThreads();
50919 (arg1)->SetSizeHints(arg2);
50920 wxPyEndAllowThreads(__tstate);
50921 if (PyErr_Occurred()) SWIG_fail;
50922 }
50923 resultobj = SWIG_Py_Void();
50924 return resultobj;
50925 fail:
50926 return NULL;
50927 }
50928
50929
50930 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50931 PyObject *resultobj = 0;
50932 wxSizer *arg1 = (wxSizer *) 0 ;
50933 wxWindow *arg2 = (wxWindow *) 0 ;
50934 void *argp1 = 0 ;
50935 int res1 = 0 ;
50936 void *argp2 = 0 ;
50937 int res2 = 0 ;
50938 PyObject * obj0 = 0 ;
50939 PyObject * obj1 = 0 ;
50940 char * kwnames[] = {
50941 (char *) "self",(char *) "window", NULL
50942 };
50943
50944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50946 if (!SWIG_IsOK(res1)) {
50947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50948 }
50949 arg1 = reinterpret_cast< wxSizer * >(argp1);
50950 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50951 if (!SWIG_IsOK(res2)) {
50952 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50953 }
50954 arg2 = reinterpret_cast< wxWindow * >(argp2);
50955 {
50956 PyThreadState* __tstate = wxPyBeginAllowThreads();
50957 (arg1)->SetVirtualSizeHints(arg2);
50958 wxPyEndAllowThreads(__tstate);
50959 if (PyErr_Occurred()) SWIG_fail;
50960 }
50961 resultobj = SWIG_Py_Void();
50962 return resultobj;
50963 fail:
50964 return NULL;
50965 }
50966
50967
50968 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50969 PyObject *resultobj = 0;
50970 wxSizer *arg1 = (wxSizer *) 0 ;
50971 bool arg2 = (bool) false ;
50972 void *argp1 = 0 ;
50973 int res1 = 0 ;
50974 bool val2 ;
50975 int ecode2 = 0 ;
50976 PyObject * obj0 = 0 ;
50977 PyObject * obj1 = 0 ;
50978 char * kwnames[] = {
50979 (char *) "self",(char *) "deleteWindows", NULL
50980 };
50981
50982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50984 if (!SWIG_IsOK(res1)) {
50985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50986 }
50987 arg1 = reinterpret_cast< wxSizer * >(argp1);
50988 if (obj1) {
50989 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50990 if (!SWIG_IsOK(ecode2)) {
50991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50992 }
50993 arg2 = static_cast< bool >(val2);
50994 }
50995 {
50996 PyThreadState* __tstate = wxPyBeginAllowThreads();
50997 (arg1)->Clear(arg2);
50998 wxPyEndAllowThreads(__tstate);
50999 if (PyErr_Occurred()) SWIG_fail;
51000 }
51001 resultobj = SWIG_Py_Void();
51002 return resultobj;
51003 fail:
51004 return NULL;
51005 }
51006
51007
51008 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51009 PyObject *resultobj = 0;
51010 wxSizer *arg1 = (wxSizer *) 0 ;
51011 void *argp1 = 0 ;
51012 int res1 = 0 ;
51013 PyObject *swig_obj[1] ;
51014
51015 if (!args) SWIG_fail;
51016 swig_obj[0] = args;
51017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51018 if (!SWIG_IsOK(res1)) {
51019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
51020 }
51021 arg1 = reinterpret_cast< wxSizer * >(argp1);
51022 {
51023 PyThreadState* __tstate = wxPyBeginAllowThreads();
51024 (arg1)->DeleteWindows();
51025 wxPyEndAllowThreads(__tstate);
51026 if (PyErr_Occurred()) SWIG_fail;
51027 }
51028 resultobj = SWIG_Py_Void();
51029 return resultobj;
51030 fail:
51031 return NULL;
51032 }
51033
51034
51035 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51036 PyObject *resultobj = 0;
51037 wxSizer *arg1 = (wxSizer *) 0 ;
51038 PyObject *result = 0 ;
51039 void *argp1 = 0 ;
51040 int res1 = 0 ;
51041 PyObject *swig_obj[1] ;
51042
51043 if (!args) SWIG_fail;
51044 swig_obj[0] = args;
51045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51046 if (!SWIG_IsOK(res1)) {
51047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51048 }
51049 arg1 = reinterpret_cast< wxSizer * >(argp1);
51050 {
51051 PyThreadState* __tstate = wxPyBeginAllowThreads();
51052 result = (PyObject *)wxSizer_GetChildren(arg1);
51053 wxPyEndAllowThreads(__tstate);
51054 if (PyErr_Occurred()) SWIG_fail;
51055 }
51056 resultobj = result;
51057 return resultobj;
51058 fail:
51059 return NULL;
51060 }
51061
51062
51063 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51064 PyObject *resultobj = 0;
51065 wxSizer *arg1 = (wxSizer *) 0 ;
51066 PyObject *arg2 = (PyObject *) 0 ;
51067 bool arg3 = (bool) true ;
51068 bool arg4 = (bool) false ;
51069 bool result;
51070 void *argp1 = 0 ;
51071 int res1 = 0 ;
51072 bool val3 ;
51073 int ecode3 = 0 ;
51074 bool val4 ;
51075 int ecode4 = 0 ;
51076 PyObject * obj0 = 0 ;
51077 PyObject * obj1 = 0 ;
51078 PyObject * obj2 = 0 ;
51079 PyObject * obj3 = 0 ;
51080 char * kwnames[] = {
51081 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51082 };
51083
51084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51086 if (!SWIG_IsOK(res1)) {
51087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51088 }
51089 arg1 = reinterpret_cast< wxSizer * >(argp1);
51090 arg2 = obj1;
51091 if (obj2) {
51092 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51093 if (!SWIG_IsOK(ecode3)) {
51094 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51095 }
51096 arg3 = static_cast< bool >(val3);
51097 }
51098 if (obj3) {
51099 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51100 if (!SWIG_IsOK(ecode4)) {
51101 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51102 }
51103 arg4 = static_cast< bool >(val4);
51104 }
51105 {
51106 PyThreadState* __tstate = wxPyBeginAllowThreads();
51107 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51108 wxPyEndAllowThreads(__tstate);
51109 if (PyErr_Occurred()) SWIG_fail;
51110 }
51111 {
51112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51113 }
51114 return resultobj;
51115 fail:
51116 return NULL;
51117 }
51118
51119
51120 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51121 PyObject *resultobj = 0;
51122 wxSizer *arg1 = (wxSizer *) 0 ;
51123 PyObject *arg2 = (PyObject *) 0 ;
51124 bool result;
51125 void *argp1 = 0 ;
51126 int res1 = 0 ;
51127 PyObject * obj0 = 0 ;
51128 PyObject * obj1 = 0 ;
51129 char * kwnames[] = {
51130 (char *) "self",(char *) "item", NULL
51131 };
51132
51133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51135 if (!SWIG_IsOK(res1)) {
51136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51137 }
51138 arg1 = reinterpret_cast< wxSizer * >(argp1);
51139 arg2 = obj1;
51140 {
51141 PyThreadState* __tstate = wxPyBeginAllowThreads();
51142 result = (bool)wxSizer_IsShown(arg1,arg2);
51143 wxPyEndAllowThreads(__tstate);
51144 if (PyErr_Occurred()) SWIG_fail;
51145 }
51146 {
51147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51148 }
51149 return resultobj;
51150 fail:
51151 return NULL;
51152 }
51153
51154
51155 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51156 PyObject *resultobj = 0;
51157 wxSizer *arg1 = (wxSizer *) 0 ;
51158 bool arg2 ;
51159 void *argp1 = 0 ;
51160 int res1 = 0 ;
51161 bool val2 ;
51162 int ecode2 = 0 ;
51163 PyObject * obj0 = 0 ;
51164 PyObject * obj1 = 0 ;
51165 char * kwnames[] = {
51166 (char *) "self",(char *) "show", NULL
51167 };
51168
51169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51171 if (!SWIG_IsOK(res1)) {
51172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51173 }
51174 arg1 = reinterpret_cast< wxSizer * >(argp1);
51175 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51176 if (!SWIG_IsOK(ecode2)) {
51177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51178 }
51179 arg2 = static_cast< bool >(val2);
51180 {
51181 PyThreadState* __tstate = wxPyBeginAllowThreads();
51182 (arg1)->ShowItems(arg2);
51183 wxPyEndAllowThreads(__tstate);
51184 if (PyErr_Occurred()) SWIG_fail;
51185 }
51186 resultobj = SWIG_Py_Void();
51187 return resultobj;
51188 fail:
51189 return NULL;
51190 }
51191
51192
51193 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51194 PyObject *obj;
51195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51196 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51197 return SWIG_Py_Void();
51198 }
51199
51200 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51201 PyObject *resultobj = 0;
51202 wxPySizer *result = 0 ;
51203
51204 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51205 {
51206 PyThreadState* __tstate = wxPyBeginAllowThreads();
51207 result = (wxPySizer *)new wxPySizer();
51208 wxPyEndAllowThreads(__tstate);
51209 if (PyErr_Occurred()) SWIG_fail;
51210 }
51211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51212 return resultobj;
51213 fail:
51214 return NULL;
51215 }
51216
51217
51218 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51219 PyObject *resultobj = 0;
51220 wxPySizer *arg1 = (wxPySizer *) 0 ;
51221 PyObject *arg2 = (PyObject *) 0 ;
51222 PyObject *arg3 = (PyObject *) 0 ;
51223 void *argp1 = 0 ;
51224 int res1 = 0 ;
51225 PyObject * obj0 = 0 ;
51226 PyObject * obj1 = 0 ;
51227 PyObject * obj2 = 0 ;
51228 char * kwnames[] = {
51229 (char *) "self",(char *) "self",(char *) "_class", NULL
51230 };
51231
51232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51234 if (!SWIG_IsOK(res1)) {
51235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51236 }
51237 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51238 arg2 = obj1;
51239 arg3 = obj2;
51240 {
51241 PyThreadState* __tstate = wxPyBeginAllowThreads();
51242 (arg1)->_setCallbackInfo(arg2,arg3);
51243 wxPyEndAllowThreads(__tstate);
51244 if (PyErr_Occurred()) SWIG_fail;
51245 }
51246 resultobj = SWIG_Py_Void();
51247 return resultobj;
51248 fail:
51249 return NULL;
51250 }
51251
51252
51253 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51254 PyObject *obj;
51255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51256 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51257 return SWIG_Py_Void();
51258 }
51259
51260 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51261 return SWIG_Python_InitShadowInstance(args);
51262 }
51263
51264 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51265 PyObject *resultobj = 0;
51266 int arg1 = (int) wxHORIZONTAL ;
51267 wxBoxSizer *result = 0 ;
51268 int val1 ;
51269 int ecode1 = 0 ;
51270 PyObject * obj0 = 0 ;
51271 char * kwnames[] = {
51272 (char *) "orient", NULL
51273 };
51274
51275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51276 if (obj0) {
51277 ecode1 = SWIG_AsVal_int(obj0, &val1);
51278 if (!SWIG_IsOK(ecode1)) {
51279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51280 }
51281 arg1 = static_cast< int >(val1);
51282 }
51283 {
51284 PyThreadState* __tstate = wxPyBeginAllowThreads();
51285 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51286 wxPyEndAllowThreads(__tstate);
51287 if (PyErr_Occurred()) SWIG_fail;
51288 }
51289 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51290 return resultobj;
51291 fail:
51292 return NULL;
51293 }
51294
51295
51296 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51297 PyObject *resultobj = 0;
51298 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51299 int result;
51300 void *argp1 = 0 ;
51301 int res1 = 0 ;
51302 PyObject *swig_obj[1] ;
51303
51304 if (!args) SWIG_fail;
51305 swig_obj[0] = args;
51306 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51307 if (!SWIG_IsOK(res1)) {
51308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51309 }
51310 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51311 {
51312 PyThreadState* __tstate = wxPyBeginAllowThreads();
51313 result = (int)(arg1)->GetOrientation();
51314 wxPyEndAllowThreads(__tstate);
51315 if (PyErr_Occurred()) SWIG_fail;
51316 }
51317 resultobj = SWIG_From_int(static_cast< int >(result));
51318 return resultobj;
51319 fail:
51320 return NULL;
51321 }
51322
51323
51324 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51325 PyObject *resultobj = 0;
51326 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51327 int arg2 ;
51328 void *argp1 = 0 ;
51329 int res1 = 0 ;
51330 int val2 ;
51331 int ecode2 = 0 ;
51332 PyObject * obj0 = 0 ;
51333 PyObject * obj1 = 0 ;
51334 char * kwnames[] = {
51335 (char *) "self",(char *) "orient", NULL
51336 };
51337
51338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51340 if (!SWIG_IsOK(res1)) {
51341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51342 }
51343 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51344 ecode2 = SWIG_AsVal_int(obj1, &val2);
51345 if (!SWIG_IsOK(ecode2)) {
51346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51347 }
51348 arg2 = static_cast< int >(val2);
51349 {
51350 PyThreadState* __tstate = wxPyBeginAllowThreads();
51351 (arg1)->SetOrientation(arg2);
51352 wxPyEndAllowThreads(__tstate);
51353 if (PyErr_Occurred()) SWIG_fail;
51354 }
51355 resultobj = SWIG_Py_Void();
51356 return resultobj;
51357 fail:
51358 return NULL;
51359 }
51360
51361
51362 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51363 PyObject *obj;
51364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51365 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51366 return SWIG_Py_Void();
51367 }
51368
51369 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51370 return SWIG_Python_InitShadowInstance(args);
51371 }
51372
51373 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51374 PyObject *resultobj = 0;
51375 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51376 int arg2 = (int) wxHORIZONTAL ;
51377 wxStaticBoxSizer *result = 0 ;
51378 void *argp1 = 0 ;
51379 int res1 = 0 ;
51380 int val2 ;
51381 int ecode2 = 0 ;
51382 PyObject * obj0 = 0 ;
51383 PyObject * obj1 = 0 ;
51384 char * kwnames[] = {
51385 (char *) "box",(char *) "orient", NULL
51386 };
51387
51388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51390 if (!SWIG_IsOK(res1)) {
51391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51392 }
51393 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51394 if (obj1) {
51395 ecode2 = SWIG_AsVal_int(obj1, &val2);
51396 if (!SWIG_IsOK(ecode2)) {
51397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51398 }
51399 arg2 = static_cast< int >(val2);
51400 }
51401 {
51402 PyThreadState* __tstate = wxPyBeginAllowThreads();
51403 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51404 wxPyEndAllowThreads(__tstate);
51405 if (PyErr_Occurred()) SWIG_fail;
51406 }
51407 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51408 return resultobj;
51409 fail:
51410 return NULL;
51411 }
51412
51413
51414 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51415 PyObject *resultobj = 0;
51416 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51417 wxStaticBox *result = 0 ;
51418 void *argp1 = 0 ;
51419 int res1 = 0 ;
51420 PyObject *swig_obj[1] ;
51421
51422 if (!args) SWIG_fail;
51423 swig_obj[0] = args;
51424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51425 if (!SWIG_IsOK(res1)) {
51426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51427 }
51428 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51429 {
51430 PyThreadState* __tstate = wxPyBeginAllowThreads();
51431 result = (wxStaticBox *)(arg1)->GetStaticBox();
51432 wxPyEndAllowThreads(__tstate);
51433 if (PyErr_Occurred()) SWIG_fail;
51434 }
51435 {
51436 resultobj = wxPyMake_wxObject(result, (bool)0);
51437 }
51438 return resultobj;
51439 fail:
51440 return NULL;
51441 }
51442
51443
51444 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51445 PyObject *obj;
51446 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51447 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51448 return SWIG_Py_Void();
51449 }
51450
51451 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51452 return SWIG_Python_InitShadowInstance(args);
51453 }
51454
51455 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51456 PyObject *resultobj = 0;
51457 int arg1 = (int) 1 ;
51458 int arg2 = (int) 0 ;
51459 int arg3 = (int) 0 ;
51460 int arg4 = (int) 0 ;
51461 wxGridSizer *result = 0 ;
51462 int val1 ;
51463 int ecode1 = 0 ;
51464 int val2 ;
51465 int ecode2 = 0 ;
51466 int val3 ;
51467 int ecode3 = 0 ;
51468 int val4 ;
51469 int ecode4 = 0 ;
51470 PyObject * obj0 = 0 ;
51471 PyObject * obj1 = 0 ;
51472 PyObject * obj2 = 0 ;
51473 PyObject * obj3 = 0 ;
51474 char * kwnames[] = {
51475 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51476 };
51477
51478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51479 if (obj0) {
51480 ecode1 = SWIG_AsVal_int(obj0, &val1);
51481 if (!SWIG_IsOK(ecode1)) {
51482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51483 }
51484 arg1 = static_cast< int >(val1);
51485 }
51486 if (obj1) {
51487 ecode2 = SWIG_AsVal_int(obj1, &val2);
51488 if (!SWIG_IsOK(ecode2)) {
51489 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51490 }
51491 arg2 = static_cast< int >(val2);
51492 }
51493 if (obj2) {
51494 ecode3 = SWIG_AsVal_int(obj2, &val3);
51495 if (!SWIG_IsOK(ecode3)) {
51496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51497 }
51498 arg3 = static_cast< int >(val3);
51499 }
51500 if (obj3) {
51501 ecode4 = SWIG_AsVal_int(obj3, &val4);
51502 if (!SWIG_IsOK(ecode4)) {
51503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51504 }
51505 arg4 = static_cast< int >(val4);
51506 }
51507 {
51508 PyThreadState* __tstate = wxPyBeginAllowThreads();
51509 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51510 wxPyEndAllowThreads(__tstate);
51511 if (PyErr_Occurred()) SWIG_fail;
51512 }
51513 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51514 return resultobj;
51515 fail:
51516 return NULL;
51517 }
51518
51519
51520 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51521 PyObject *resultobj = 0;
51522 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51523 int arg2 ;
51524 void *argp1 = 0 ;
51525 int res1 = 0 ;
51526 int val2 ;
51527 int ecode2 = 0 ;
51528 PyObject * obj0 = 0 ;
51529 PyObject * obj1 = 0 ;
51530 char * kwnames[] = {
51531 (char *) "self",(char *) "cols", NULL
51532 };
51533
51534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51536 if (!SWIG_IsOK(res1)) {
51537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51538 }
51539 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51540 ecode2 = SWIG_AsVal_int(obj1, &val2);
51541 if (!SWIG_IsOK(ecode2)) {
51542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51543 }
51544 arg2 = static_cast< int >(val2);
51545 {
51546 PyThreadState* __tstate = wxPyBeginAllowThreads();
51547 (arg1)->SetCols(arg2);
51548 wxPyEndAllowThreads(__tstate);
51549 if (PyErr_Occurred()) SWIG_fail;
51550 }
51551 resultobj = SWIG_Py_Void();
51552 return resultobj;
51553 fail:
51554 return NULL;
51555 }
51556
51557
51558 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51559 PyObject *resultobj = 0;
51560 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51561 int arg2 ;
51562 void *argp1 = 0 ;
51563 int res1 = 0 ;
51564 int val2 ;
51565 int ecode2 = 0 ;
51566 PyObject * obj0 = 0 ;
51567 PyObject * obj1 = 0 ;
51568 char * kwnames[] = {
51569 (char *) "self",(char *) "rows", NULL
51570 };
51571
51572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51574 if (!SWIG_IsOK(res1)) {
51575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51576 }
51577 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51578 ecode2 = SWIG_AsVal_int(obj1, &val2);
51579 if (!SWIG_IsOK(ecode2)) {
51580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51581 }
51582 arg2 = static_cast< int >(val2);
51583 {
51584 PyThreadState* __tstate = wxPyBeginAllowThreads();
51585 (arg1)->SetRows(arg2);
51586 wxPyEndAllowThreads(__tstate);
51587 if (PyErr_Occurred()) SWIG_fail;
51588 }
51589 resultobj = SWIG_Py_Void();
51590 return resultobj;
51591 fail:
51592 return NULL;
51593 }
51594
51595
51596 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51597 PyObject *resultobj = 0;
51598 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51599 int arg2 ;
51600 void *argp1 = 0 ;
51601 int res1 = 0 ;
51602 int val2 ;
51603 int ecode2 = 0 ;
51604 PyObject * obj0 = 0 ;
51605 PyObject * obj1 = 0 ;
51606 char * kwnames[] = {
51607 (char *) "self",(char *) "gap", NULL
51608 };
51609
51610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51612 if (!SWIG_IsOK(res1)) {
51613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51614 }
51615 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51616 ecode2 = SWIG_AsVal_int(obj1, &val2);
51617 if (!SWIG_IsOK(ecode2)) {
51618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51619 }
51620 arg2 = static_cast< int >(val2);
51621 {
51622 PyThreadState* __tstate = wxPyBeginAllowThreads();
51623 (arg1)->SetVGap(arg2);
51624 wxPyEndAllowThreads(__tstate);
51625 if (PyErr_Occurred()) SWIG_fail;
51626 }
51627 resultobj = SWIG_Py_Void();
51628 return resultobj;
51629 fail:
51630 return NULL;
51631 }
51632
51633
51634 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51635 PyObject *resultobj = 0;
51636 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51637 int arg2 ;
51638 void *argp1 = 0 ;
51639 int res1 = 0 ;
51640 int val2 ;
51641 int ecode2 = 0 ;
51642 PyObject * obj0 = 0 ;
51643 PyObject * obj1 = 0 ;
51644 char * kwnames[] = {
51645 (char *) "self",(char *) "gap", NULL
51646 };
51647
51648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51650 if (!SWIG_IsOK(res1)) {
51651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51652 }
51653 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51654 ecode2 = SWIG_AsVal_int(obj1, &val2);
51655 if (!SWIG_IsOK(ecode2)) {
51656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51657 }
51658 arg2 = static_cast< int >(val2);
51659 {
51660 PyThreadState* __tstate = wxPyBeginAllowThreads();
51661 (arg1)->SetHGap(arg2);
51662 wxPyEndAllowThreads(__tstate);
51663 if (PyErr_Occurred()) SWIG_fail;
51664 }
51665 resultobj = SWIG_Py_Void();
51666 return resultobj;
51667 fail:
51668 return NULL;
51669 }
51670
51671
51672 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51673 PyObject *resultobj = 0;
51674 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51675 int result;
51676 void *argp1 = 0 ;
51677 int res1 = 0 ;
51678 PyObject *swig_obj[1] ;
51679
51680 if (!args) SWIG_fail;
51681 swig_obj[0] = args;
51682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51683 if (!SWIG_IsOK(res1)) {
51684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51685 }
51686 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51687 {
51688 PyThreadState* __tstate = wxPyBeginAllowThreads();
51689 result = (int)(arg1)->GetCols();
51690 wxPyEndAllowThreads(__tstate);
51691 if (PyErr_Occurred()) SWIG_fail;
51692 }
51693 resultobj = SWIG_From_int(static_cast< int >(result));
51694 return resultobj;
51695 fail:
51696 return NULL;
51697 }
51698
51699
51700 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51701 PyObject *resultobj = 0;
51702 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51703 int result;
51704 void *argp1 = 0 ;
51705 int res1 = 0 ;
51706 PyObject *swig_obj[1] ;
51707
51708 if (!args) SWIG_fail;
51709 swig_obj[0] = args;
51710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51711 if (!SWIG_IsOK(res1)) {
51712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51713 }
51714 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51715 {
51716 PyThreadState* __tstate = wxPyBeginAllowThreads();
51717 result = (int)(arg1)->GetRows();
51718 wxPyEndAllowThreads(__tstate);
51719 if (PyErr_Occurred()) SWIG_fail;
51720 }
51721 resultobj = SWIG_From_int(static_cast< int >(result));
51722 return resultobj;
51723 fail:
51724 return NULL;
51725 }
51726
51727
51728 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51729 PyObject *resultobj = 0;
51730 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51731 int result;
51732 void *argp1 = 0 ;
51733 int res1 = 0 ;
51734 PyObject *swig_obj[1] ;
51735
51736 if (!args) SWIG_fail;
51737 swig_obj[0] = args;
51738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51739 if (!SWIG_IsOK(res1)) {
51740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51741 }
51742 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51743 {
51744 PyThreadState* __tstate = wxPyBeginAllowThreads();
51745 result = (int)(arg1)->GetVGap();
51746 wxPyEndAllowThreads(__tstate);
51747 if (PyErr_Occurred()) SWIG_fail;
51748 }
51749 resultobj = SWIG_From_int(static_cast< int >(result));
51750 return resultobj;
51751 fail:
51752 return NULL;
51753 }
51754
51755
51756 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51757 PyObject *resultobj = 0;
51758 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51759 int result;
51760 void *argp1 = 0 ;
51761 int res1 = 0 ;
51762 PyObject *swig_obj[1] ;
51763
51764 if (!args) SWIG_fail;
51765 swig_obj[0] = args;
51766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51767 if (!SWIG_IsOK(res1)) {
51768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51769 }
51770 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51771 {
51772 PyThreadState* __tstate = wxPyBeginAllowThreads();
51773 result = (int)(arg1)->GetHGap();
51774 wxPyEndAllowThreads(__tstate);
51775 if (PyErr_Occurred()) SWIG_fail;
51776 }
51777 resultobj = SWIG_From_int(static_cast< int >(result));
51778 return resultobj;
51779 fail:
51780 return NULL;
51781 }
51782
51783
51784 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51785 PyObject *obj;
51786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51787 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51788 return SWIG_Py_Void();
51789 }
51790
51791 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51792 return SWIG_Python_InitShadowInstance(args);
51793 }
51794
51795 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51796 PyObject *resultobj = 0;
51797 int arg1 = (int) 1 ;
51798 int arg2 = (int) 0 ;
51799 int arg3 = (int) 0 ;
51800 int arg4 = (int) 0 ;
51801 wxFlexGridSizer *result = 0 ;
51802 int val1 ;
51803 int ecode1 = 0 ;
51804 int val2 ;
51805 int ecode2 = 0 ;
51806 int val3 ;
51807 int ecode3 = 0 ;
51808 int val4 ;
51809 int ecode4 = 0 ;
51810 PyObject * obj0 = 0 ;
51811 PyObject * obj1 = 0 ;
51812 PyObject * obj2 = 0 ;
51813 PyObject * obj3 = 0 ;
51814 char * kwnames[] = {
51815 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51816 };
51817
51818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51819 if (obj0) {
51820 ecode1 = SWIG_AsVal_int(obj0, &val1);
51821 if (!SWIG_IsOK(ecode1)) {
51822 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51823 }
51824 arg1 = static_cast< int >(val1);
51825 }
51826 if (obj1) {
51827 ecode2 = SWIG_AsVal_int(obj1, &val2);
51828 if (!SWIG_IsOK(ecode2)) {
51829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51830 }
51831 arg2 = static_cast< int >(val2);
51832 }
51833 if (obj2) {
51834 ecode3 = SWIG_AsVal_int(obj2, &val3);
51835 if (!SWIG_IsOK(ecode3)) {
51836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51837 }
51838 arg3 = static_cast< int >(val3);
51839 }
51840 if (obj3) {
51841 ecode4 = SWIG_AsVal_int(obj3, &val4);
51842 if (!SWIG_IsOK(ecode4)) {
51843 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51844 }
51845 arg4 = static_cast< int >(val4);
51846 }
51847 {
51848 PyThreadState* __tstate = wxPyBeginAllowThreads();
51849 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51850 wxPyEndAllowThreads(__tstate);
51851 if (PyErr_Occurred()) SWIG_fail;
51852 }
51853 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51854 return resultobj;
51855 fail:
51856 return NULL;
51857 }
51858
51859
51860 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51861 PyObject *resultobj = 0;
51862 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51863 size_t arg2 ;
51864 int arg3 = (int) 0 ;
51865 void *argp1 = 0 ;
51866 int res1 = 0 ;
51867 size_t val2 ;
51868 int ecode2 = 0 ;
51869 int val3 ;
51870 int ecode3 = 0 ;
51871 PyObject * obj0 = 0 ;
51872 PyObject * obj1 = 0 ;
51873 PyObject * obj2 = 0 ;
51874 char * kwnames[] = {
51875 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51876 };
51877
51878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51880 if (!SWIG_IsOK(res1)) {
51881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51882 }
51883 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51884 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51885 if (!SWIG_IsOK(ecode2)) {
51886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51887 }
51888 arg2 = static_cast< size_t >(val2);
51889 if (obj2) {
51890 ecode3 = SWIG_AsVal_int(obj2, &val3);
51891 if (!SWIG_IsOK(ecode3)) {
51892 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51893 }
51894 arg3 = static_cast< int >(val3);
51895 }
51896 {
51897 PyThreadState* __tstate = wxPyBeginAllowThreads();
51898 (arg1)->AddGrowableRow(arg2,arg3);
51899 wxPyEndAllowThreads(__tstate);
51900 if (PyErr_Occurred()) SWIG_fail;
51901 }
51902 resultobj = SWIG_Py_Void();
51903 return resultobj;
51904 fail:
51905 return NULL;
51906 }
51907
51908
51909 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51910 PyObject *resultobj = 0;
51911 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51912 size_t arg2 ;
51913 void *argp1 = 0 ;
51914 int res1 = 0 ;
51915 size_t val2 ;
51916 int ecode2 = 0 ;
51917 PyObject * obj0 = 0 ;
51918 PyObject * obj1 = 0 ;
51919 char * kwnames[] = {
51920 (char *) "self",(char *) "idx", NULL
51921 };
51922
51923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51925 if (!SWIG_IsOK(res1)) {
51926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51927 }
51928 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51929 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51930 if (!SWIG_IsOK(ecode2)) {
51931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51932 }
51933 arg2 = static_cast< size_t >(val2);
51934 {
51935 PyThreadState* __tstate = wxPyBeginAllowThreads();
51936 (arg1)->RemoveGrowableRow(arg2);
51937 wxPyEndAllowThreads(__tstate);
51938 if (PyErr_Occurred()) SWIG_fail;
51939 }
51940 resultobj = SWIG_Py_Void();
51941 return resultobj;
51942 fail:
51943 return NULL;
51944 }
51945
51946
51947 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51948 PyObject *resultobj = 0;
51949 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51950 size_t arg2 ;
51951 int arg3 = (int) 0 ;
51952 void *argp1 = 0 ;
51953 int res1 = 0 ;
51954 size_t val2 ;
51955 int ecode2 = 0 ;
51956 int val3 ;
51957 int ecode3 = 0 ;
51958 PyObject * obj0 = 0 ;
51959 PyObject * obj1 = 0 ;
51960 PyObject * obj2 = 0 ;
51961 char * kwnames[] = {
51962 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51963 };
51964
51965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51967 if (!SWIG_IsOK(res1)) {
51968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51969 }
51970 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51971 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51972 if (!SWIG_IsOK(ecode2)) {
51973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51974 }
51975 arg2 = static_cast< size_t >(val2);
51976 if (obj2) {
51977 ecode3 = SWIG_AsVal_int(obj2, &val3);
51978 if (!SWIG_IsOK(ecode3)) {
51979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51980 }
51981 arg3 = static_cast< int >(val3);
51982 }
51983 {
51984 PyThreadState* __tstate = wxPyBeginAllowThreads();
51985 (arg1)->AddGrowableCol(arg2,arg3);
51986 wxPyEndAllowThreads(__tstate);
51987 if (PyErr_Occurred()) SWIG_fail;
51988 }
51989 resultobj = SWIG_Py_Void();
51990 return resultobj;
51991 fail:
51992 return NULL;
51993 }
51994
51995
51996 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51997 PyObject *resultobj = 0;
51998 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51999 size_t arg2 ;
52000 void *argp1 = 0 ;
52001 int res1 = 0 ;
52002 size_t val2 ;
52003 int ecode2 = 0 ;
52004 PyObject * obj0 = 0 ;
52005 PyObject * obj1 = 0 ;
52006 char * kwnames[] = {
52007 (char *) "self",(char *) "idx", NULL
52008 };
52009
52010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
52011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52012 if (!SWIG_IsOK(res1)) {
52013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52014 }
52015 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52016 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52017 if (!SWIG_IsOK(ecode2)) {
52018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52019 }
52020 arg2 = static_cast< size_t >(val2);
52021 {
52022 PyThreadState* __tstate = wxPyBeginAllowThreads();
52023 (arg1)->RemoveGrowableCol(arg2);
52024 wxPyEndAllowThreads(__tstate);
52025 if (PyErr_Occurred()) SWIG_fail;
52026 }
52027 resultobj = SWIG_Py_Void();
52028 return resultobj;
52029 fail:
52030 return NULL;
52031 }
52032
52033
52034 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52035 PyObject *resultobj = 0;
52036 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52037 int arg2 ;
52038 void *argp1 = 0 ;
52039 int res1 = 0 ;
52040 int val2 ;
52041 int ecode2 = 0 ;
52042 PyObject * obj0 = 0 ;
52043 PyObject * obj1 = 0 ;
52044 char * kwnames[] = {
52045 (char *) "self",(char *) "direction", NULL
52046 };
52047
52048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52050 if (!SWIG_IsOK(res1)) {
52051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52052 }
52053 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52054 ecode2 = SWIG_AsVal_int(obj1, &val2);
52055 if (!SWIG_IsOK(ecode2)) {
52056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52057 }
52058 arg2 = static_cast< int >(val2);
52059 {
52060 PyThreadState* __tstate = wxPyBeginAllowThreads();
52061 (arg1)->SetFlexibleDirection(arg2);
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_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52073 PyObject *resultobj = 0;
52074 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52075 int result;
52076 void *argp1 = 0 ;
52077 int res1 = 0 ;
52078 PyObject *swig_obj[1] ;
52079
52080 if (!args) SWIG_fail;
52081 swig_obj[0] = args;
52082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52083 if (!SWIG_IsOK(res1)) {
52084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52085 }
52086 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52087 {
52088 PyThreadState* __tstate = wxPyBeginAllowThreads();
52089 result = (int)(arg1)->GetFlexibleDirection();
52090 wxPyEndAllowThreads(__tstate);
52091 if (PyErr_Occurred()) SWIG_fail;
52092 }
52093 resultobj = SWIG_From_int(static_cast< int >(result));
52094 return resultobj;
52095 fail:
52096 return NULL;
52097 }
52098
52099
52100 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52101 PyObject *resultobj = 0;
52102 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52103 wxFlexSizerGrowMode arg2 ;
52104 void *argp1 = 0 ;
52105 int res1 = 0 ;
52106 int val2 ;
52107 int ecode2 = 0 ;
52108 PyObject * obj0 = 0 ;
52109 PyObject * obj1 = 0 ;
52110 char * kwnames[] = {
52111 (char *) "self",(char *) "mode", NULL
52112 };
52113
52114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52116 if (!SWIG_IsOK(res1)) {
52117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52118 }
52119 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52120 ecode2 = SWIG_AsVal_int(obj1, &val2);
52121 if (!SWIG_IsOK(ecode2)) {
52122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52123 }
52124 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52125 {
52126 PyThreadState* __tstate = wxPyBeginAllowThreads();
52127 (arg1)->SetNonFlexibleGrowMode(arg2);
52128 wxPyEndAllowThreads(__tstate);
52129 if (PyErr_Occurred()) SWIG_fail;
52130 }
52131 resultobj = SWIG_Py_Void();
52132 return resultobj;
52133 fail:
52134 return NULL;
52135 }
52136
52137
52138 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52139 PyObject *resultobj = 0;
52140 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52141 wxFlexSizerGrowMode result;
52142 void *argp1 = 0 ;
52143 int res1 = 0 ;
52144 PyObject *swig_obj[1] ;
52145
52146 if (!args) SWIG_fail;
52147 swig_obj[0] = args;
52148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52149 if (!SWIG_IsOK(res1)) {
52150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52151 }
52152 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52153 {
52154 PyThreadState* __tstate = wxPyBeginAllowThreads();
52155 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52156 wxPyEndAllowThreads(__tstate);
52157 if (PyErr_Occurred()) SWIG_fail;
52158 }
52159 resultobj = SWIG_From_int(static_cast< int >(result));
52160 return resultobj;
52161 fail:
52162 return NULL;
52163 }
52164
52165
52166 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52167 PyObject *resultobj = 0;
52168 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52169 wxArrayInt *result = 0 ;
52170 void *argp1 = 0 ;
52171 int res1 = 0 ;
52172 PyObject *swig_obj[1] ;
52173
52174 if (!args) SWIG_fail;
52175 swig_obj[0] = args;
52176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52177 if (!SWIG_IsOK(res1)) {
52178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52179 }
52180 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52181 {
52182 PyThreadState* __tstate = wxPyBeginAllowThreads();
52183 {
52184 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52185 result = (wxArrayInt *) &_result_ref;
52186 }
52187 wxPyEndAllowThreads(__tstate);
52188 if (PyErr_Occurred()) SWIG_fail;
52189 }
52190 {
52191 resultobj = wxArrayInt2PyList_helper(*result);
52192 }
52193 return resultobj;
52194 fail:
52195 return NULL;
52196 }
52197
52198
52199 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52200 PyObject *resultobj = 0;
52201 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52202 wxArrayInt *result = 0 ;
52203 void *argp1 = 0 ;
52204 int res1 = 0 ;
52205 PyObject *swig_obj[1] ;
52206
52207 if (!args) SWIG_fail;
52208 swig_obj[0] = args;
52209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52210 if (!SWIG_IsOK(res1)) {
52211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52212 }
52213 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52214 {
52215 PyThreadState* __tstate = wxPyBeginAllowThreads();
52216 {
52217 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52218 result = (wxArrayInt *) &_result_ref;
52219 }
52220 wxPyEndAllowThreads(__tstate);
52221 if (PyErr_Occurred()) SWIG_fail;
52222 }
52223 {
52224 resultobj = wxArrayInt2PyList_helper(*result);
52225 }
52226 return resultobj;
52227 fail:
52228 return NULL;
52229 }
52230
52231
52232 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52233 PyObject *obj;
52234 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52235 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52236 return SWIG_Py_Void();
52237 }
52238
52239 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52240 return SWIG_Python_InitShadowInstance(args);
52241 }
52242
52243 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52244 PyObject *resultobj = 0;
52245 wxStdDialogButtonSizer *result = 0 ;
52246
52247 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52248 {
52249 PyThreadState* __tstate = wxPyBeginAllowThreads();
52250 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52251 wxPyEndAllowThreads(__tstate);
52252 if (PyErr_Occurred()) SWIG_fail;
52253 }
52254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52255 return resultobj;
52256 fail:
52257 return NULL;
52258 }
52259
52260
52261 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52262 PyObject *resultobj = 0;
52263 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52264 wxButton *arg2 = (wxButton *) 0 ;
52265 void *argp1 = 0 ;
52266 int res1 = 0 ;
52267 void *argp2 = 0 ;
52268 int res2 = 0 ;
52269 PyObject * obj0 = 0 ;
52270 PyObject * obj1 = 0 ;
52271 char * kwnames[] = {
52272 (char *) "self",(char *) "button", NULL
52273 };
52274
52275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52277 if (!SWIG_IsOK(res1)) {
52278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52279 }
52280 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52281 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52282 if (!SWIG_IsOK(res2)) {
52283 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52284 }
52285 arg2 = reinterpret_cast< wxButton * >(argp2);
52286 {
52287 PyThreadState* __tstate = wxPyBeginAllowThreads();
52288 (arg1)->AddButton(arg2);
52289 wxPyEndAllowThreads(__tstate);
52290 if (PyErr_Occurred()) SWIG_fail;
52291 }
52292 resultobj = SWIG_Py_Void();
52293 return resultobj;
52294 fail:
52295 return NULL;
52296 }
52297
52298
52299 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52300 PyObject *resultobj = 0;
52301 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52302 void *argp1 = 0 ;
52303 int res1 = 0 ;
52304 PyObject *swig_obj[1] ;
52305
52306 if (!args) SWIG_fail;
52307 swig_obj[0] = args;
52308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52309 if (!SWIG_IsOK(res1)) {
52310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52311 }
52312 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52313 {
52314 PyThreadState* __tstate = wxPyBeginAllowThreads();
52315 (arg1)->Realize();
52316 wxPyEndAllowThreads(__tstate);
52317 if (PyErr_Occurred()) SWIG_fail;
52318 }
52319 resultobj = SWIG_Py_Void();
52320 return resultobj;
52321 fail:
52322 return NULL;
52323 }
52324
52325
52326 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52327 PyObject *resultobj = 0;
52328 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52329 wxButton *arg2 = (wxButton *) 0 ;
52330 void *argp1 = 0 ;
52331 int res1 = 0 ;
52332 void *argp2 = 0 ;
52333 int res2 = 0 ;
52334 PyObject * obj0 = 0 ;
52335 PyObject * obj1 = 0 ;
52336 char * kwnames[] = {
52337 (char *) "self",(char *) "button", NULL
52338 };
52339
52340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52342 if (!SWIG_IsOK(res1)) {
52343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52344 }
52345 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52346 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52347 if (!SWIG_IsOK(res2)) {
52348 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52349 }
52350 arg2 = reinterpret_cast< wxButton * >(argp2);
52351 {
52352 PyThreadState* __tstate = wxPyBeginAllowThreads();
52353 (arg1)->SetAffirmativeButton(arg2);
52354 wxPyEndAllowThreads(__tstate);
52355 if (PyErr_Occurred()) SWIG_fail;
52356 }
52357 resultobj = SWIG_Py_Void();
52358 return resultobj;
52359 fail:
52360 return NULL;
52361 }
52362
52363
52364 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52365 PyObject *resultobj = 0;
52366 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52367 wxButton *arg2 = (wxButton *) 0 ;
52368 void *argp1 = 0 ;
52369 int res1 = 0 ;
52370 void *argp2 = 0 ;
52371 int res2 = 0 ;
52372 PyObject * obj0 = 0 ;
52373 PyObject * obj1 = 0 ;
52374 char * kwnames[] = {
52375 (char *) "self",(char *) "button", NULL
52376 };
52377
52378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52380 if (!SWIG_IsOK(res1)) {
52381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52382 }
52383 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52384 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52385 if (!SWIG_IsOK(res2)) {
52386 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52387 }
52388 arg2 = reinterpret_cast< wxButton * >(argp2);
52389 {
52390 PyThreadState* __tstate = wxPyBeginAllowThreads();
52391 (arg1)->SetNegativeButton(arg2);
52392 wxPyEndAllowThreads(__tstate);
52393 if (PyErr_Occurred()) SWIG_fail;
52394 }
52395 resultobj = SWIG_Py_Void();
52396 return resultobj;
52397 fail:
52398 return NULL;
52399 }
52400
52401
52402 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52403 PyObject *resultobj = 0;
52404 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52405 wxButton *arg2 = (wxButton *) 0 ;
52406 void *argp1 = 0 ;
52407 int res1 = 0 ;
52408 void *argp2 = 0 ;
52409 int res2 = 0 ;
52410 PyObject * obj0 = 0 ;
52411 PyObject * obj1 = 0 ;
52412 char * kwnames[] = {
52413 (char *) "self",(char *) "button", NULL
52414 };
52415
52416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52418 if (!SWIG_IsOK(res1)) {
52419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52420 }
52421 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52422 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52423 if (!SWIG_IsOK(res2)) {
52424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52425 }
52426 arg2 = reinterpret_cast< wxButton * >(argp2);
52427 {
52428 PyThreadState* __tstate = wxPyBeginAllowThreads();
52429 (arg1)->SetCancelButton(arg2);
52430 wxPyEndAllowThreads(__tstate);
52431 if (PyErr_Occurred()) SWIG_fail;
52432 }
52433 resultobj = SWIG_Py_Void();
52434 return resultobj;
52435 fail:
52436 return NULL;
52437 }
52438
52439
52440 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52441 PyObject *resultobj = 0;
52442 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52443 wxButton *result = 0 ;
52444 void *argp1 = 0 ;
52445 int res1 = 0 ;
52446 PyObject *swig_obj[1] ;
52447
52448 if (!args) SWIG_fail;
52449 swig_obj[0] = args;
52450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52451 if (!SWIG_IsOK(res1)) {
52452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52453 }
52454 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52455 {
52456 PyThreadState* __tstate = wxPyBeginAllowThreads();
52457 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52458 wxPyEndAllowThreads(__tstate);
52459 if (PyErr_Occurred()) SWIG_fail;
52460 }
52461 {
52462 resultobj = wxPyMake_wxObject(result, (bool)0);
52463 }
52464 return resultobj;
52465 fail:
52466 return NULL;
52467 }
52468
52469
52470 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52471 PyObject *resultobj = 0;
52472 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52473 wxButton *result = 0 ;
52474 void *argp1 = 0 ;
52475 int res1 = 0 ;
52476 PyObject *swig_obj[1] ;
52477
52478 if (!args) SWIG_fail;
52479 swig_obj[0] = args;
52480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52481 if (!SWIG_IsOK(res1)) {
52482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52483 }
52484 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52485 {
52486 PyThreadState* __tstate = wxPyBeginAllowThreads();
52487 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52488 wxPyEndAllowThreads(__tstate);
52489 if (PyErr_Occurred()) SWIG_fail;
52490 }
52491 {
52492 resultobj = wxPyMake_wxObject(result, (bool)0);
52493 }
52494 return resultobj;
52495 fail:
52496 return NULL;
52497 }
52498
52499
52500 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52501 PyObject *resultobj = 0;
52502 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52503 wxButton *result = 0 ;
52504 void *argp1 = 0 ;
52505 int res1 = 0 ;
52506 PyObject *swig_obj[1] ;
52507
52508 if (!args) SWIG_fail;
52509 swig_obj[0] = args;
52510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52511 if (!SWIG_IsOK(res1)) {
52512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52513 }
52514 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52515 {
52516 PyThreadState* __tstate = wxPyBeginAllowThreads();
52517 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52518 wxPyEndAllowThreads(__tstate);
52519 if (PyErr_Occurred()) SWIG_fail;
52520 }
52521 {
52522 resultobj = wxPyMake_wxObject(result, (bool)0);
52523 }
52524 return resultobj;
52525 fail:
52526 return NULL;
52527 }
52528
52529
52530 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52531 PyObject *resultobj = 0;
52532 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52533 wxButton *result = 0 ;
52534 void *argp1 = 0 ;
52535 int res1 = 0 ;
52536 PyObject *swig_obj[1] ;
52537
52538 if (!args) SWIG_fail;
52539 swig_obj[0] = args;
52540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52541 if (!SWIG_IsOK(res1)) {
52542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52543 }
52544 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52545 {
52546 PyThreadState* __tstate = wxPyBeginAllowThreads();
52547 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52548 wxPyEndAllowThreads(__tstate);
52549 if (PyErr_Occurred()) SWIG_fail;
52550 }
52551 {
52552 resultobj = wxPyMake_wxObject(result, (bool)0);
52553 }
52554 return resultobj;
52555 fail:
52556 return NULL;
52557 }
52558
52559
52560 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52561 PyObject *resultobj = 0;
52562 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52563 wxButton *result = 0 ;
52564 void *argp1 = 0 ;
52565 int res1 = 0 ;
52566 PyObject *swig_obj[1] ;
52567
52568 if (!args) SWIG_fail;
52569 swig_obj[0] = args;
52570 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52571 if (!SWIG_IsOK(res1)) {
52572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52573 }
52574 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52575 {
52576 PyThreadState* __tstate = wxPyBeginAllowThreads();
52577 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52578 wxPyEndAllowThreads(__tstate);
52579 if (PyErr_Occurred()) SWIG_fail;
52580 }
52581 {
52582 resultobj = wxPyMake_wxObject(result, (bool)0);
52583 }
52584 return resultobj;
52585 fail:
52586 return NULL;
52587 }
52588
52589
52590 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52591 PyObject *obj;
52592 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52593 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52594 return SWIG_Py_Void();
52595 }
52596
52597 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52598 return SWIG_Python_InitShadowInstance(args);
52599 }
52600
52601 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52602 PyObject *resultobj = 0;
52603 int arg1 = (int) 0 ;
52604 int arg2 = (int) 0 ;
52605 wxGBPosition *result = 0 ;
52606 int val1 ;
52607 int ecode1 = 0 ;
52608 int val2 ;
52609 int ecode2 = 0 ;
52610 PyObject * obj0 = 0 ;
52611 PyObject * obj1 = 0 ;
52612 char * kwnames[] = {
52613 (char *) "row",(char *) "col", NULL
52614 };
52615
52616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52617 if (obj0) {
52618 ecode1 = SWIG_AsVal_int(obj0, &val1);
52619 if (!SWIG_IsOK(ecode1)) {
52620 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52621 }
52622 arg1 = static_cast< int >(val1);
52623 }
52624 if (obj1) {
52625 ecode2 = SWIG_AsVal_int(obj1, &val2);
52626 if (!SWIG_IsOK(ecode2)) {
52627 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52628 }
52629 arg2 = static_cast< int >(val2);
52630 }
52631 {
52632 PyThreadState* __tstate = wxPyBeginAllowThreads();
52633 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52634 wxPyEndAllowThreads(__tstate);
52635 if (PyErr_Occurred()) SWIG_fail;
52636 }
52637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52638 return resultobj;
52639 fail:
52640 return NULL;
52641 }
52642
52643
52644 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52645 PyObject *resultobj = 0;
52646 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52647 void *argp1 = 0 ;
52648 int res1 = 0 ;
52649 PyObject *swig_obj[1] ;
52650
52651 if (!args) SWIG_fail;
52652 swig_obj[0] = args;
52653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52654 if (!SWIG_IsOK(res1)) {
52655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52656 }
52657 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52658 {
52659 PyThreadState* __tstate = wxPyBeginAllowThreads();
52660 delete arg1;
52661
52662 wxPyEndAllowThreads(__tstate);
52663 if (PyErr_Occurred()) SWIG_fail;
52664 }
52665 resultobj = SWIG_Py_Void();
52666 return resultobj;
52667 fail:
52668 return NULL;
52669 }
52670
52671
52672 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52673 PyObject *resultobj = 0;
52674 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52675 int result;
52676 void *argp1 = 0 ;
52677 int res1 = 0 ;
52678 PyObject *swig_obj[1] ;
52679
52680 if (!args) SWIG_fail;
52681 swig_obj[0] = args;
52682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52683 if (!SWIG_IsOK(res1)) {
52684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52685 }
52686 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52687 {
52688 PyThreadState* __tstate = wxPyBeginAllowThreads();
52689 result = (int)((wxGBPosition const *)arg1)->GetRow();
52690 wxPyEndAllowThreads(__tstate);
52691 if (PyErr_Occurred()) SWIG_fail;
52692 }
52693 resultobj = SWIG_From_int(static_cast< int >(result));
52694 return resultobj;
52695 fail:
52696 return NULL;
52697 }
52698
52699
52700 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52701 PyObject *resultobj = 0;
52702 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52703 int result;
52704 void *argp1 = 0 ;
52705 int res1 = 0 ;
52706 PyObject *swig_obj[1] ;
52707
52708 if (!args) SWIG_fail;
52709 swig_obj[0] = args;
52710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52711 if (!SWIG_IsOK(res1)) {
52712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52713 }
52714 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52715 {
52716 PyThreadState* __tstate = wxPyBeginAllowThreads();
52717 result = (int)((wxGBPosition const *)arg1)->GetCol();
52718 wxPyEndAllowThreads(__tstate);
52719 if (PyErr_Occurred()) SWIG_fail;
52720 }
52721 resultobj = SWIG_From_int(static_cast< int >(result));
52722 return resultobj;
52723 fail:
52724 return NULL;
52725 }
52726
52727
52728 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52729 PyObject *resultobj = 0;
52730 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52731 int arg2 ;
52732 void *argp1 = 0 ;
52733 int res1 = 0 ;
52734 int val2 ;
52735 int ecode2 = 0 ;
52736 PyObject * obj0 = 0 ;
52737 PyObject * obj1 = 0 ;
52738 char * kwnames[] = {
52739 (char *) "self",(char *) "row", NULL
52740 };
52741
52742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52744 if (!SWIG_IsOK(res1)) {
52745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52746 }
52747 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52748 ecode2 = SWIG_AsVal_int(obj1, &val2);
52749 if (!SWIG_IsOK(ecode2)) {
52750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52751 }
52752 arg2 = static_cast< int >(val2);
52753 {
52754 PyThreadState* __tstate = wxPyBeginAllowThreads();
52755 (arg1)->SetRow(arg2);
52756 wxPyEndAllowThreads(__tstate);
52757 if (PyErr_Occurred()) SWIG_fail;
52758 }
52759 resultobj = SWIG_Py_Void();
52760 return resultobj;
52761 fail:
52762 return NULL;
52763 }
52764
52765
52766 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52767 PyObject *resultobj = 0;
52768 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52769 int arg2 ;
52770 void *argp1 = 0 ;
52771 int res1 = 0 ;
52772 int val2 ;
52773 int ecode2 = 0 ;
52774 PyObject * obj0 = 0 ;
52775 PyObject * obj1 = 0 ;
52776 char * kwnames[] = {
52777 (char *) "self",(char *) "col", NULL
52778 };
52779
52780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52782 if (!SWIG_IsOK(res1)) {
52783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52784 }
52785 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52786 ecode2 = SWIG_AsVal_int(obj1, &val2);
52787 if (!SWIG_IsOK(ecode2)) {
52788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52789 }
52790 arg2 = static_cast< int >(val2);
52791 {
52792 PyThreadState* __tstate = wxPyBeginAllowThreads();
52793 (arg1)->SetCol(arg2);
52794 wxPyEndAllowThreads(__tstate);
52795 if (PyErr_Occurred()) SWIG_fail;
52796 }
52797 resultobj = SWIG_Py_Void();
52798 return resultobj;
52799 fail:
52800 return NULL;
52801 }
52802
52803
52804 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52805 PyObject *resultobj = 0;
52806 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52807 PyObject *arg2 = (PyObject *) 0 ;
52808 bool result;
52809 void *argp1 = 0 ;
52810 int res1 = 0 ;
52811 PyObject * obj0 = 0 ;
52812 PyObject * obj1 = 0 ;
52813 char * kwnames[] = {
52814 (char *) "self",(char *) "other", NULL
52815 };
52816
52817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52819 if (!SWIG_IsOK(res1)) {
52820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52821 }
52822 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52823 arg2 = obj1;
52824 {
52825 result = (bool)wxGBPosition___eq__(arg1,arg2);
52826 if (PyErr_Occurred()) SWIG_fail;
52827 }
52828 {
52829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52830 }
52831 return resultobj;
52832 fail:
52833 return NULL;
52834 }
52835
52836
52837 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52838 PyObject *resultobj = 0;
52839 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52840 PyObject *arg2 = (PyObject *) 0 ;
52841 bool result;
52842 void *argp1 = 0 ;
52843 int res1 = 0 ;
52844 PyObject * obj0 = 0 ;
52845 PyObject * obj1 = 0 ;
52846 char * kwnames[] = {
52847 (char *) "self",(char *) "other", NULL
52848 };
52849
52850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52852 if (!SWIG_IsOK(res1)) {
52853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52854 }
52855 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52856 arg2 = obj1;
52857 {
52858 result = (bool)wxGBPosition___ne__(arg1,arg2);
52859 if (PyErr_Occurred()) SWIG_fail;
52860 }
52861 {
52862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52863 }
52864 return resultobj;
52865 fail:
52866 return NULL;
52867 }
52868
52869
52870 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52871 PyObject *resultobj = 0;
52872 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52873 int arg2 = (int) 0 ;
52874 int arg3 = (int) 0 ;
52875 void *argp1 = 0 ;
52876 int res1 = 0 ;
52877 int val2 ;
52878 int ecode2 = 0 ;
52879 int val3 ;
52880 int ecode3 = 0 ;
52881 PyObject * obj0 = 0 ;
52882 PyObject * obj1 = 0 ;
52883 PyObject * obj2 = 0 ;
52884 char * kwnames[] = {
52885 (char *) "self",(char *) "row",(char *) "col", NULL
52886 };
52887
52888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52890 if (!SWIG_IsOK(res1)) {
52891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52892 }
52893 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52894 if (obj1) {
52895 ecode2 = SWIG_AsVal_int(obj1, &val2);
52896 if (!SWIG_IsOK(ecode2)) {
52897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52898 }
52899 arg2 = static_cast< int >(val2);
52900 }
52901 if (obj2) {
52902 ecode3 = SWIG_AsVal_int(obj2, &val3);
52903 if (!SWIG_IsOK(ecode3)) {
52904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52905 }
52906 arg3 = static_cast< int >(val3);
52907 }
52908 {
52909 PyThreadState* __tstate = wxPyBeginAllowThreads();
52910 wxGBPosition_Set(arg1,arg2,arg3);
52911 wxPyEndAllowThreads(__tstate);
52912 if (PyErr_Occurred()) SWIG_fail;
52913 }
52914 resultobj = SWIG_Py_Void();
52915 return resultobj;
52916 fail:
52917 return NULL;
52918 }
52919
52920
52921 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52922 PyObject *resultobj = 0;
52923 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52924 PyObject *result = 0 ;
52925 void *argp1 = 0 ;
52926 int res1 = 0 ;
52927 PyObject *swig_obj[1] ;
52928
52929 if (!args) SWIG_fail;
52930 swig_obj[0] = args;
52931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52932 if (!SWIG_IsOK(res1)) {
52933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52934 }
52935 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52936 {
52937 PyThreadState* __tstate = wxPyBeginAllowThreads();
52938 result = (PyObject *)wxGBPosition_Get(arg1);
52939 wxPyEndAllowThreads(__tstate);
52940 if (PyErr_Occurred()) SWIG_fail;
52941 }
52942 resultobj = result;
52943 return resultobj;
52944 fail:
52945 return NULL;
52946 }
52947
52948
52949 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52950 PyObject *obj;
52951 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52952 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52953 return SWIG_Py_Void();
52954 }
52955
52956 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52957 return SWIG_Python_InitShadowInstance(args);
52958 }
52959
52960 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52961 PyObject *resultobj = 0;
52962 int arg1 = (int) 1 ;
52963 int arg2 = (int) 1 ;
52964 wxGBSpan *result = 0 ;
52965 int val1 ;
52966 int ecode1 = 0 ;
52967 int val2 ;
52968 int ecode2 = 0 ;
52969 PyObject * obj0 = 0 ;
52970 PyObject * obj1 = 0 ;
52971 char * kwnames[] = {
52972 (char *) "rowspan",(char *) "colspan", NULL
52973 };
52974
52975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52976 if (obj0) {
52977 ecode1 = SWIG_AsVal_int(obj0, &val1);
52978 if (!SWIG_IsOK(ecode1)) {
52979 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52980 }
52981 arg1 = static_cast< int >(val1);
52982 }
52983 if (obj1) {
52984 ecode2 = SWIG_AsVal_int(obj1, &val2);
52985 if (!SWIG_IsOK(ecode2)) {
52986 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52987 }
52988 arg2 = static_cast< int >(val2);
52989 }
52990 {
52991 PyThreadState* __tstate = wxPyBeginAllowThreads();
52992 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52993 wxPyEndAllowThreads(__tstate);
52994 if (PyErr_Occurred()) SWIG_fail;
52995 }
52996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52997 return resultobj;
52998 fail:
52999 return NULL;
53000 }
53001
53002
53003 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53004 PyObject *resultobj = 0;
53005 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53006 void *argp1 = 0 ;
53007 int res1 = 0 ;
53008 PyObject *swig_obj[1] ;
53009
53010 if (!args) SWIG_fail;
53011 swig_obj[0] = args;
53012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
53013 if (!SWIG_IsOK(res1)) {
53014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53015 }
53016 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53017 {
53018 PyThreadState* __tstate = wxPyBeginAllowThreads();
53019 delete arg1;
53020
53021 wxPyEndAllowThreads(__tstate);
53022 if (PyErr_Occurred()) SWIG_fail;
53023 }
53024 resultobj = SWIG_Py_Void();
53025 return resultobj;
53026 fail:
53027 return NULL;
53028 }
53029
53030
53031 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53032 PyObject *resultobj = 0;
53033 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53034 int result;
53035 void *argp1 = 0 ;
53036 int res1 = 0 ;
53037 PyObject *swig_obj[1] ;
53038
53039 if (!args) SWIG_fail;
53040 swig_obj[0] = args;
53041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53042 if (!SWIG_IsOK(res1)) {
53043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53044 }
53045 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53046 {
53047 PyThreadState* __tstate = wxPyBeginAllowThreads();
53048 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53049 wxPyEndAllowThreads(__tstate);
53050 if (PyErr_Occurred()) SWIG_fail;
53051 }
53052 resultobj = SWIG_From_int(static_cast< int >(result));
53053 return resultobj;
53054 fail:
53055 return NULL;
53056 }
53057
53058
53059 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53060 PyObject *resultobj = 0;
53061 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53062 int result;
53063 void *argp1 = 0 ;
53064 int res1 = 0 ;
53065 PyObject *swig_obj[1] ;
53066
53067 if (!args) SWIG_fail;
53068 swig_obj[0] = args;
53069 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53070 if (!SWIG_IsOK(res1)) {
53071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53072 }
53073 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53074 {
53075 PyThreadState* __tstate = wxPyBeginAllowThreads();
53076 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53077 wxPyEndAllowThreads(__tstate);
53078 if (PyErr_Occurred()) SWIG_fail;
53079 }
53080 resultobj = SWIG_From_int(static_cast< int >(result));
53081 return resultobj;
53082 fail:
53083 return NULL;
53084 }
53085
53086
53087 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53088 PyObject *resultobj = 0;
53089 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53090 int arg2 ;
53091 void *argp1 = 0 ;
53092 int res1 = 0 ;
53093 int val2 ;
53094 int ecode2 = 0 ;
53095 PyObject * obj0 = 0 ;
53096 PyObject * obj1 = 0 ;
53097 char * kwnames[] = {
53098 (char *) "self",(char *) "rowspan", NULL
53099 };
53100
53101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53103 if (!SWIG_IsOK(res1)) {
53104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53105 }
53106 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53107 ecode2 = SWIG_AsVal_int(obj1, &val2);
53108 if (!SWIG_IsOK(ecode2)) {
53109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53110 }
53111 arg2 = static_cast< int >(val2);
53112 {
53113 PyThreadState* __tstate = wxPyBeginAllowThreads();
53114 (arg1)->SetRowspan(arg2);
53115 wxPyEndAllowThreads(__tstate);
53116 if (PyErr_Occurred()) SWIG_fail;
53117 }
53118 resultobj = SWIG_Py_Void();
53119 return resultobj;
53120 fail:
53121 return NULL;
53122 }
53123
53124
53125 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53126 PyObject *resultobj = 0;
53127 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53128 int arg2 ;
53129 void *argp1 = 0 ;
53130 int res1 = 0 ;
53131 int val2 ;
53132 int ecode2 = 0 ;
53133 PyObject * obj0 = 0 ;
53134 PyObject * obj1 = 0 ;
53135 char * kwnames[] = {
53136 (char *) "self",(char *) "colspan", NULL
53137 };
53138
53139 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53140 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53141 if (!SWIG_IsOK(res1)) {
53142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53143 }
53144 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53145 ecode2 = SWIG_AsVal_int(obj1, &val2);
53146 if (!SWIG_IsOK(ecode2)) {
53147 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53148 }
53149 arg2 = static_cast< int >(val2);
53150 {
53151 PyThreadState* __tstate = wxPyBeginAllowThreads();
53152 (arg1)->SetColspan(arg2);
53153 wxPyEndAllowThreads(__tstate);
53154 if (PyErr_Occurred()) SWIG_fail;
53155 }
53156 resultobj = SWIG_Py_Void();
53157 return resultobj;
53158 fail:
53159 return NULL;
53160 }
53161
53162
53163 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53164 PyObject *resultobj = 0;
53165 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53166 PyObject *arg2 = (PyObject *) 0 ;
53167 bool result;
53168 void *argp1 = 0 ;
53169 int res1 = 0 ;
53170 PyObject * obj0 = 0 ;
53171 PyObject * obj1 = 0 ;
53172 char * kwnames[] = {
53173 (char *) "self",(char *) "other", NULL
53174 };
53175
53176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53178 if (!SWIG_IsOK(res1)) {
53179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53180 }
53181 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53182 arg2 = obj1;
53183 {
53184 result = (bool)wxGBSpan___eq__(arg1,arg2);
53185 if (PyErr_Occurred()) SWIG_fail;
53186 }
53187 {
53188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53189 }
53190 return resultobj;
53191 fail:
53192 return NULL;
53193 }
53194
53195
53196 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53197 PyObject *resultobj = 0;
53198 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53199 PyObject *arg2 = (PyObject *) 0 ;
53200 bool result;
53201 void *argp1 = 0 ;
53202 int res1 = 0 ;
53203 PyObject * obj0 = 0 ;
53204 PyObject * obj1 = 0 ;
53205 char * kwnames[] = {
53206 (char *) "self",(char *) "other", NULL
53207 };
53208
53209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53211 if (!SWIG_IsOK(res1)) {
53212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53213 }
53214 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53215 arg2 = obj1;
53216 {
53217 result = (bool)wxGBSpan___ne__(arg1,arg2);
53218 if (PyErr_Occurred()) SWIG_fail;
53219 }
53220 {
53221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53222 }
53223 return resultobj;
53224 fail:
53225 return NULL;
53226 }
53227
53228
53229 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53230 PyObject *resultobj = 0;
53231 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53232 int arg2 = (int) 1 ;
53233 int arg3 = (int) 1 ;
53234 void *argp1 = 0 ;
53235 int res1 = 0 ;
53236 int val2 ;
53237 int ecode2 = 0 ;
53238 int val3 ;
53239 int ecode3 = 0 ;
53240 PyObject * obj0 = 0 ;
53241 PyObject * obj1 = 0 ;
53242 PyObject * obj2 = 0 ;
53243 char * kwnames[] = {
53244 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53245 };
53246
53247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53249 if (!SWIG_IsOK(res1)) {
53250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53251 }
53252 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53253 if (obj1) {
53254 ecode2 = SWIG_AsVal_int(obj1, &val2);
53255 if (!SWIG_IsOK(ecode2)) {
53256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53257 }
53258 arg2 = static_cast< int >(val2);
53259 }
53260 if (obj2) {
53261 ecode3 = SWIG_AsVal_int(obj2, &val3);
53262 if (!SWIG_IsOK(ecode3)) {
53263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53264 }
53265 arg3 = static_cast< int >(val3);
53266 }
53267 {
53268 PyThreadState* __tstate = wxPyBeginAllowThreads();
53269 wxGBSpan_Set(arg1,arg2,arg3);
53270 wxPyEndAllowThreads(__tstate);
53271 if (PyErr_Occurred()) SWIG_fail;
53272 }
53273 resultobj = SWIG_Py_Void();
53274 return resultobj;
53275 fail:
53276 return NULL;
53277 }
53278
53279
53280 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53281 PyObject *resultobj = 0;
53282 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53283 PyObject *result = 0 ;
53284 void *argp1 = 0 ;
53285 int res1 = 0 ;
53286 PyObject *swig_obj[1] ;
53287
53288 if (!args) SWIG_fail;
53289 swig_obj[0] = args;
53290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53291 if (!SWIG_IsOK(res1)) {
53292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53293 }
53294 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53295 {
53296 PyThreadState* __tstate = wxPyBeginAllowThreads();
53297 result = (PyObject *)wxGBSpan_Get(arg1);
53298 wxPyEndAllowThreads(__tstate);
53299 if (PyErr_Occurred()) SWIG_fail;
53300 }
53301 resultobj = result;
53302 return resultobj;
53303 fail:
53304 return NULL;
53305 }
53306
53307
53308 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53309 PyObject *obj;
53310 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53311 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53312 return SWIG_Py_Void();
53313 }
53314
53315 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53316 return SWIG_Python_InitShadowInstance(args);
53317 }
53318
53319 SWIGINTERN int DefaultSpan_set(PyObject *) {
53320 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53321 return 1;
53322 }
53323
53324
53325 SWIGINTERN PyObject *DefaultSpan_get(void) {
53326 PyObject *pyobj = 0;
53327
53328 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53329 return pyobj;
53330 }
53331
53332
53333 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53334 PyObject *resultobj = 0;
53335 wxGBSizerItem *result = 0 ;
53336
53337 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53338 {
53339 PyThreadState* __tstate = wxPyBeginAllowThreads();
53340 result = (wxGBSizerItem *)new wxGBSizerItem();
53341 wxPyEndAllowThreads(__tstate);
53342 if (PyErr_Occurred()) SWIG_fail;
53343 }
53344 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53345 return resultobj;
53346 fail:
53347 return NULL;
53348 }
53349
53350
53351 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53352 PyObject *resultobj = 0;
53353 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53354 void *argp1 = 0 ;
53355 int res1 = 0 ;
53356 PyObject *swig_obj[1] ;
53357
53358 if (!args) SWIG_fail;
53359 swig_obj[0] = args;
53360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53361 if (!SWIG_IsOK(res1)) {
53362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53363 }
53364 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53365 {
53366 PyThreadState* __tstate = wxPyBeginAllowThreads();
53367 delete arg1;
53368
53369 wxPyEndAllowThreads(__tstate);
53370 if (PyErr_Occurred()) SWIG_fail;
53371 }
53372 resultobj = SWIG_Py_Void();
53373 return resultobj;
53374 fail:
53375 return NULL;
53376 }
53377
53378
53379 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53380 PyObject *resultobj = 0;
53381 wxWindow *arg1 = (wxWindow *) 0 ;
53382 wxGBPosition *arg2 = 0 ;
53383 wxGBSpan *arg3 = 0 ;
53384 int arg4 ;
53385 int arg5 ;
53386 PyObject *arg6 = (PyObject *) NULL ;
53387 wxGBSizerItem *result = 0 ;
53388 void *argp1 = 0 ;
53389 int res1 = 0 ;
53390 wxGBPosition temp2 ;
53391 wxGBSpan temp3 ;
53392 int val4 ;
53393 int ecode4 = 0 ;
53394 int val5 ;
53395 int ecode5 = 0 ;
53396 PyObject * obj0 = 0 ;
53397 PyObject * obj1 = 0 ;
53398 PyObject * obj2 = 0 ;
53399 PyObject * obj3 = 0 ;
53400 PyObject * obj4 = 0 ;
53401 PyObject * obj5 = 0 ;
53402 char * kwnames[] = {
53403 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53404 };
53405
53406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53408 if (!SWIG_IsOK(res1)) {
53409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53410 }
53411 arg1 = reinterpret_cast< wxWindow * >(argp1);
53412 {
53413 arg2 = &temp2;
53414 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53415 }
53416 {
53417 arg3 = &temp3;
53418 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53419 }
53420 ecode4 = SWIG_AsVal_int(obj3, &val4);
53421 if (!SWIG_IsOK(ecode4)) {
53422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53423 }
53424 arg4 = static_cast< int >(val4);
53425 ecode5 = SWIG_AsVal_int(obj4, &val5);
53426 if (!SWIG_IsOK(ecode5)) {
53427 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53428 }
53429 arg5 = static_cast< int >(val5);
53430 if (obj5) {
53431 arg6 = obj5;
53432 }
53433 {
53434 PyThreadState* __tstate = wxPyBeginAllowThreads();
53435 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53436 wxPyEndAllowThreads(__tstate);
53437 if (PyErr_Occurred()) SWIG_fail;
53438 }
53439 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53440 return resultobj;
53441 fail:
53442 return NULL;
53443 }
53444
53445
53446 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53447 PyObject *resultobj = 0;
53448 wxSizer *arg1 = (wxSizer *) 0 ;
53449 wxGBPosition *arg2 = 0 ;
53450 wxGBSpan *arg3 = 0 ;
53451 int arg4 ;
53452 int arg5 ;
53453 PyObject *arg6 = (PyObject *) NULL ;
53454 wxGBSizerItem *result = 0 ;
53455 int res1 = 0 ;
53456 wxGBPosition temp2 ;
53457 wxGBSpan temp3 ;
53458 int val4 ;
53459 int ecode4 = 0 ;
53460 int val5 ;
53461 int ecode5 = 0 ;
53462 PyObject * obj0 = 0 ;
53463 PyObject * obj1 = 0 ;
53464 PyObject * obj2 = 0 ;
53465 PyObject * obj3 = 0 ;
53466 PyObject * obj4 = 0 ;
53467 PyObject * obj5 = 0 ;
53468 char * kwnames[] = {
53469 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53470 };
53471
53472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53473 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53474 if (!SWIG_IsOK(res1)) {
53475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53476 }
53477 {
53478 arg2 = &temp2;
53479 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53480 }
53481 {
53482 arg3 = &temp3;
53483 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53484 }
53485 ecode4 = SWIG_AsVal_int(obj3, &val4);
53486 if (!SWIG_IsOK(ecode4)) {
53487 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53488 }
53489 arg4 = static_cast< int >(val4);
53490 ecode5 = SWIG_AsVal_int(obj4, &val5);
53491 if (!SWIG_IsOK(ecode5)) {
53492 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53493 }
53494 arg5 = static_cast< int >(val5);
53495 if (obj5) {
53496 arg6 = obj5;
53497 }
53498 {
53499 PyThreadState* __tstate = wxPyBeginAllowThreads();
53500 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53501 wxPyEndAllowThreads(__tstate);
53502 if (PyErr_Occurred()) SWIG_fail;
53503 }
53504 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53505 return resultobj;
53506 fail:
53507 return NULL;
53508 }
53509
53510
53511 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53512 PyObject *resultobj = 0;
53513 int arg1 ;
53514 int arg2 ;
53515 wxGBPosition *arg3 = 0 ;
53516 wxGBSpan *arg4 = 0 ;
53517 int arg5 ;
53518 int arg6 ;
53519 PyObject *arg7 = (PyObject *) NULL ;
53520 wxGBSizerItem *result = 0 ;
53521 int val1 ;
53522 int ecode1 = 0 ;
53523 int val2 ;
53524 int ecode2 = 0 ;
53525 wxGBPosition temp3 ;
53526 wxGBSpan temp4 ;
53527 int val5 ;
53528 int ecode5 = 0 ;
53529 int val6 ;
53530 int ecode6 = 0 ;
53531 PyObject * obj0 = 0 ;
53532 PyObject * obj1 = 0 ;
53533 PyObject * obj2 = 0 ;
53534 PyObject * obj3 = 0 ;
53535 PyObject * obj4 = 0 ;
53536 PyObject * obj5 = 0 ;
53537 PyObject * obj6 = 0 ;
53538 char * kwnames[] = {
53539 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53540 };
53541
53542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53543 ecode1 = SWIG_AsVal_int(obj0, &val1);
53544 if (!SWIG_IsOK(ecode1)) {
53545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53546 }
53547 arg1 = static_cast< int >(val1);
53548 ecode2 = SWIG_AsVal_int(obj1, &val2);
53549 if (!SWIG_IsOK(ecode2)) {
53550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53551 }
53552 arg2 = static_cast< int >(val2);
53553 {
53554 arg3 = &temp3;
53555 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53556 }
53557 {
53558 arg4 = &temp4;
53559 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53560 }
53561 ecode5 = SWIG_AsVal_int(obj4, &val5);
53562 if (!SWIG_IsOK(ecode5)) {
53563 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53564 }
53565 arg5 = static_cast< int >(val5);
53566 ecode6 = SWIG_AsVal_int(obj5, &val6);
53567 if (!SWIG_IsOK(ecode6)) {
53568 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53569 }
53570 arg6 = static_cast< int >(val6);
53571 if (obj6) {
53572 arg7 = obj6;
53573 }
53574 {
53575 PyThreadState* __tstate = wxPyBeginAllowThreads();
53576 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53577 wxPyEndAllowThreads(__tstate);
53578 if (PyErr_Occurred()) SWIG_fail;
53579 }
53580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53581 return resultobj;
53582 fail:
53583 return NULL;
53584 }
53585
53586
53587 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53588 PyObject *resultobj = 0;
53589 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53590 wxGBPosition result;
53591 void *argp1 = 0 ;
53592 int res1 = 0 ;
53593 PyObject *swig_obj[1] ;
53594
53595 if (!args) SWIG_fail;
53596 swig_obj[0] = args;
53597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53598 if (!SWIG_IsOK(res1)) {
53599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53600 }
53601 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53602 {
53603 PyThreadState* __tstate = wxPyBeginAllowThreads();
53604 result = ((wxGBSizerItem const *)arg1)->GetPos();
53605 wxPyEndAllowThreads(__tstate);
53606 if (PyErr_Occurred()) SWIG_fail;
53607 }
53608 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53609 return resultobj;
53610 fail:
53611 return NULL;
53612 }
53613
53614
53615 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53616 PyObject *resultobj = 0;
53617 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53618 wxGBSpan result;
53619 void *argp1 = 0 ;
53620 int res1 = 0 ;
53621 PyObject *swig_obj[1] ;
53622
53623 if (!args) SWIG_fail;
53624 swig_obj[0] = args;
53625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53626 if (!SWIG_IsOK(res1)) {
53627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53628 }
53629 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53630 {
53631 PyThreadState* __tstate = wxPyBeginAllowThreads();
53632 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53633 wxPyEndAllowThreads(__tstate);
53634 if (PyErr_Occurred()) SWIG_fail;
53635 }
53636 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53637 return resultobj;
53638 fail:
53639 return NULL;
53640 }
53641
53642
53643 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53644 PyObject *resultobj = 0;
53645 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53646 wxGBPosition *arg2 = 0 ;
53647 bool result;
53648 void *argp1 = 0 ;
53649 int res1 = 0 ;
53650 wxGBPosition temp2 ;
53651 PyObject * obj0 = 0 ;
53652 PyObject * obj1 = 0 ;
53653 char * kwnames[] = {
53654 (char *) "self",(char *) "pos", NULL
53655 };
53656
53657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53659 if (!SWIG_IsOK(res1)) {
53660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53661 }
53662 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53663 {
53664 arg2 = &temp2;
53665 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53666 }
53667 {
53668 PyThreadState* __tstate = wxPyBeginAllowThreads();
53669 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53670 wxPyEndAllowThreads(__tstate);
53671 if (PyErr_Occurred()) SWIG_fail;
53672 }
53673 {
53674 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53675 }
53676 return resultobj;
53677 fail:
53678 return NULL;
53679 }
53680
53681
53682 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53683 PyObject *resultobj = 0;
53684 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53685 wxGBSpan *arg2 = 0 ;
53686 bool result;
53687 void *argp1 = 0 ;
53688 int res1 = 0 ;
53689 wxGBSpan temp2 ;
53690 PyObject * obj0 = 0 ;
53691 PyObject * obj1 = 0 ;
53692 char * kwnames[] = {
53693 (char *) "self",(char *) "span", NULL
53694 };
53695
53696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53698 if (!SWIG_IsOK(res1)) {
53699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53700 }
53701 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53702 {
53703 arg2 = &temp2;
53704 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53705 }
53706 {
53707 PyThreadState* __tstate = wxPyBeginAllowThreads();
53708 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53709 wxPyEndAllowThreads(__tstate);
53710 if (PyErr_Occurred()) SWIG_fail;
53711 }
53712 {
53713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53714 }
53715 return resultobj;
53716 fail:
53717 return NULL;
53718 }
53719
53720
53721 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53722 PyObject *resultobj = 0;
53723 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53724 wxGBSizerItem *arg2 = 0 ;
53725 bool result;
53726 void *argp1 = 0 ;
53727 int res1 = 0 ;
53728 void *argp2 = 0 ;
53729 int res2 = 0 ;
53730 PyObject * obj0 = 0 ;
53731 PyObject * obj1 = 0 ;
53732 char * kwnames[] = {
53733 (char *) "self",(char *) "other", NULL
53734 };
53735
53736 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53737 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53738 if (!SWIG_IsOK(res1)) {
53739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53740 }
53741 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53742 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53743 if (!SWIG_IsOK(res2)) {
53744 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53745 }
53746 if (!argp2) {
53747 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53748 }
53749 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53750 {
53751 PyThreadState* __tstate = wxPyBeginAllowThreads();
53752 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53753 wxPyEndAllowThreads(__tstate);
53754 if (PyErr_Occurred()) SWIG_fail;
53755 }
53756 {
53757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53758 }
53759 return resultobj;
53760 fail:
53761 return NULL;
53762 }
53763
53764
53765 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53766 PyObject *resultobj = 0;
53767 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53768 wxGBPosition *arg2 = 0 ;
53769 wxGBSpan *arg3 = 0 ;
53770 bool result;
53771 void *argp1 = 0 ;
53772 int res1 = 0 ;
53773 wxGBPosition temp2 ;
53774 wxGBSpan temp3 ;
53775 PyObject * obj0 = 0 ;
53776 PyObject * obj1 = 0 ;
53777 PyObject * obj2 = 0 ;
53778 char * kwnames[] = {
53779 (char *) "self",(char *) "pos",(char *) "span", NULL
53780 };
53781
53782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53784 if (!SWIG_IsOK(res1)) {
53785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53786 }
53787 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53788 {
53789 arg2 = &temp2;
53790 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53791 }
53792 {
53793 arg3 = &temp3;
53794 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53795 }
53796 {
53797 PyThreadState* __tstate = wxPyBeginAllowThreads();
53798 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53799 wxPyEndAllowThreads(__tstate);
53800 if (PyErr_Occurred()) SWIG_fail;
53801 }
53802 {
53803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53804 }
53805 return resultobj;
53806 fail:
53807 return NULL;
53808 }
53809
53810
53811 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53812 PyObject *resultobj = 0;
53813 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53814 wxGBPosition result;
53815 void *argp1 = 0 ;
53816 int res1 = 0 ;
53817 PyObject *swig_obj[1] ;
53818
53819 if (!args) SWIG_fail;
53820 swig_obj[0] = args;
53821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53822 if (!SWIG_IsOK(res1)) {
53823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53824 }
53825 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53826 {
53827 PyThreadState* __tstate = wxPyBeginAllowThreads();
53828 result = wxGBSizerItem_GetEndPos(arg1);
53829 wxPyEndAllowThreads(__tstate);
53830 if (PyErr_Occurred()) SWIG_fail;
53831 }
53832 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53833 return resultobj;
53834 fail:
53835 return NULL;
53836 }
53837
53838
53839 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53840 PyObject *resultobj = 0;
53841 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53842 wxGridBagSizer *result = 0 ;
53843 void *argp1 = 0 ;
53844 int res1 = 0 ;
53845 PyObject *swig_obj[1] ;
53846
53847 if (!args) SWIG_fail;
53848 swig_obj[0] = args;
53849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53850 if (!SWIG_IsOK(res1)) {
53851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53852 }
53853 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53854 {
53855 PyThreadState* __tstate = wxPyBeginAllowThreads();
53856 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53857 wxPyEndAllowThreads(__tstate);
53858 if (PyErr_Occurred()) SWIG_fail;
53859 }
53860 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53861 return resultobj;
53862 fail:
53863 return NULL;
53864 }
53865
53866
53867 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53868 PyObject *resultobj = 0;
53869 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53870 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53871 void *argp1 = 0 ;
53872 int res1 = 0 ;
53873 void *argp2 = 0 ;
53874 int res2 = 0 ;
53875 PyObject * obj0 = 0 ;
53876 PyObject * obj1 = 0 ;
53877 char * kwnames[] = {
53878 (char *) "self",(char *) "sizer", NULL
53879 };
53880
53881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53883 if (!SWIG_IsOK(res1)) {
53884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53885 }
53886 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53887 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53888 if (!SWIG_IsOK(res2)) {
53889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53890 }
53891 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53892 {
53893 PyThreadState* __tstate = wxPyBeginAllowThreads();
53894 (arg1)->SetGBSizer(arg2);
53895 wxPyEndAllowThreads(__tstate);
53896 if (PyErr_Occurred()) SWIG_fail;
53897 }
53898 resultobj = SWIG_Py_Void();
53899 return resultobj;
53900 fail:
53901 return NULL;
53902 }
53903
53904
53905 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53906 PyObject *obj;
53907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53908 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53909 return SWIG_Py_Void();
53910 }
53911
53912 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53913 return SWIG_Python_InitShadowInstance(args);
53914 }
53915
53916 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53917 PyObject *resultobj = 0;
53918 int arg1 = (int) 0 ;
53919 int arg2 = (int) 0 ;
53920 wxGridBagSizer *result = 0 ;
53921 int val1 ;
53922 int ecode1 = 0 ;
53923 int val2 ;
53924 int ecode2 = 0 ;
53925 PyObject * obj0 = 0 ;
53926 PyObject * obj1 = 0 ;
53927 char * kwnames[] = {
53928 (char *) "vgap",(char *) "hgap", NULL
53929 };
53930
53931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53932 if (obj0) {
53933 ecode1 = SWIG_AsVal_int(obj0, &val1);
53934 if (!SWIG_IsOK(ecode1)) {
53935 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53936 }
53937 arg1 = static_cast< int >(val1);
53938 }
53939 if (obj1) {
53940 ecode2 = SWIG_AsVal_int(obj1, &val2);
53941 if (!SWIG_IsOK(ecode2)) {
53942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53943 }
53944 arg2 = static_cast< int >(val2);
53945 }
53946 {
53947 PyThreadState* __tstate = wxPyBeginAllowThreads();
53948 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53949 wxPyEndAllowThreads(__tstate);
53950 if (PyErr_Occurred()) SWIG_fail;
53951 }
53952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53953 return resultobj;
53954 fail:
53955 return NULL;
53956 }
53957
53958
53959 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53960 PyObject *resultobj = 0;
53961 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53962 PyObject *arg2 = (PyObject *) 0 ;
53963 wxGBPosition *arg3 = 0 ;
53964 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53965 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53966 int arg5 = (int) 0 ;
53967 int arg6 = (int) 0 ;
53968 PyObject *arg7 = (PyObject *) NULL ;
53969 wxGBSizerItem *result = 0 ;
53970 void *argp1 = 0 ;
53971 int res1 = 0 ;
53972 wxGBPosition temp3 ;
53973 wxGBSpan temp4 ;
53974 int val5 ;
53975 int ecode5 = 0 ;
53976 int val6 ;
53977 int ecode6 = 0 ;
53978 PyObject * obj0 = 0 ;
53979 PyObject * obj1 = 0 ;
53980 PyObject * obj2 = 0 ;
53981 PyObject * obj3 = 0 ;
53982 PyObject * obj4 = 0 ;
53983 PyObject * obj5 = 0 ;
53984 PyObject * obj6 = 0 ;
53985 char * kwnames[] = {
53986 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53987 };
53988
53989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53991 if (!SWIG_IsOK(res1)) {
53992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53993 }
53994 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53995 arg2 = obj1;
53996 {
53997 arg3 = &temp3;
53998 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53999 }
54000 if (obj3) {
54001 {
54002 arg4 = &temp4;
54003 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54004 }
54005 }
54006 if (obj4) {
54007 ecode5 = SWIG_AsVal_int(obj4, &val5);
54008 if (!SWIG_IsOK(ecode5)) {
54009 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
54010 }
54011 arg5 = static_cast< int >(val5);
54012 }
54013 if (obj5) {
54014 ecode6 = SWIG_AsVal_int(obj5, &val6);
54015 if (!SWIG_IsOK(ecode6)) {
54016 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
54017 }
54018 arg6 = static_cast< int >(val6);
54019 }
54020 if (obj6) {
54021 arg7 = obj6;
54022 }
54023 {
54024 PyThreadState* __tstate = wxPyBeginAllowThreads();
54025 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54026 wxPyEndAllowThreads(__tstate);
54027 if (PyErr_Occurred()) SWIG_fail;
54028 }
54029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54030 return resultobj;
54031 fail:
54032 return NULL;
54033 }
54034
54035
54036 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54037 PyObject *resultobj = 0;
54038 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54039 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54040 wxGBSizerItem *result = 0 ;
54041 void *argp1 = 0 ;
54042 int res1 = 0 ;
54043 int res2 = 0 ;
54044 PyObject * obj0 = 0 ;
54045 PyObject * obj1 = 0 ;
54046 char * kwnames[] = {
54047 (char *) "self",(char *) "item", NULL
54048 };
54049
54050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54052 if (!SWIG_IsOK(res1)) {
54053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54054 }
54055 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54056 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54057 if (!SWIG_IsOK(res2)) {
54058 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54059 }
54060 {
54061 PyThreadState* __tstate = wxPyBeginAllowThreads();
54062 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54063 wxPyEndAllowThreads(__tstate);
54064 if (PyErr_Occurred()) SWIG_fail;
54065 }
54066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54067 return resultobj;
54068 fail:
54069 return NULL;
54070 }
54071
54072
54073 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54074 PyObject *resultobj = 0;
54075 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54076 int arg2 ;
54077 int arg3 ;
54078 wxSize result;
54079 void *argp1 = 0 ;
54080 int res1 = 0 ;
54081 int val2 ;
54082 int ecode2 = 0 ;
54083 int val3 ;
54084 int ecode3 = 0 ;
54085 PyObject * obj0 = 0 ;
54086 PyObject * obj1 = 0 ;
54087 PyObject * obj2 = 0 ;
54088 char * kwnames[] = {
54089 (char *) "self",(char *) "row",(char *) "col", NULL
54090 };
54091
54092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54094 if (!SWIG_IsOK(res1)) {
54095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54096 }
54097 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54098 ecode2 = SWIG_AsVal_int(obj1, &val2);
54099 if (!SWIG_IsOK(ecode2)) {
54100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54101 }
54102 arg2 = static_cast< int >(val2);
54103 ecode3 = SWIG_AsVal_int(obj2, &val3);
54104 if (!SWIG_IsOK(ecode3)) {
54105 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54106 }
54107 arg3 = static_cast< int >(val3);
54108 {
54109 PyThreadState* __tstate = wxPyBeginAllowThreads();
54110 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54111 wxPyEndAllowThreads(__tstate);
54112 if (PyErr_Occurred()) SWIG_fail;
54113 }
54114 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54115 return resultobj;
54116 fail:
54117 return NULL;
54118 }
54119
54120
54121 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54122 PyObject *resultobj = 0;
54123 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54124 wxSize result;
54125 void *argp1 = 0 ;
54126 int res1 = 0 ;
54127 PyObject *swig_obj[1] ;
54128
54129 if (!args) SWIG_fail;
54130 swig_obj[0] = args;
54131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54132 if (!SWIG_IsOK(res1)) {
54133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54134 }
54135 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54136 {
54137 PyThreadState* __tstate = wxPyBeginAllowThreads();
54138 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54139 wxPyEndAllowThreads(__tstate);
54140 if (PyErr_Occurred()) SWIG_fail;
54141 }
54142 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54143 return resultobj;
54144 fail:
54145 return NULL;
54146 }
54147
54148
54149 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54150 PyObject *resultobj = 0;
54151 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54152 wxSize *arg2 = 0 ;
54153 void *argp1 = 0 ;
54154 int res1 = 0 ;
54155 wxSize temp2 ;
54156 PyObject * obj0 = 0 ;
54157 PyObject * obj1 = 0 ;
54158 char * kwnames[] = {
54159 (char *) "self",(char *) "sz", NULL
54160 };
54161
54162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54163 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54164 if (!SWIG_IsOK(res1)) {
54165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54166 }
54167 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54168 {
54169 arg2 = &temp2;
54170 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54171 }
54172 {
54173 PyThreadState* __tstate = wxPyBeginAllowThreads();
54174 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54175 wxPyEndAllowThreads(__tstate);
54176 if (PyErr_Occurred()) SWIG_fail;
54177 }
54178 resultobj = SWIG_Py_Void();
54179 return resultobj;
54180 fail:
54181 return NULL;
54182 }
54183
54184
54185 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54186 PyObject *resultobj = 0;
54187 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54188 wxWindow *arg2 = (wxWindow *) 0 ;
54189 wxGBPosition result;
54190 void *argp1 = 0 ;
54191 int res1 = 0 ;
54192 void *argp2 = 0 ;
54193 int res2 = 0 ;
54194
54195 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54197 if (!SWIG_IsOK(res1)) {
54198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54199 }
54200 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54201 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54202 if (!SWIG_IsOK(res2)) {
54203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54204 }
54205 arg2 = reinterpret_cast< wxWindow * >(argp2);
54206 {
54207 PyThreadState* __tstate = wxPyBeginAllowThreads();
54208 result = (arg1)->GetItemPosition(arg2);
54209 wxPyEndAllowThreads(__tstate);
54210 if (PyErr_Occurred()) SWIG_fail;
54211 }
54212 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54213 return resultobj;
54214 fail:
54215 return NULL;
54216 }
54217
54218
54219 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54220 PyObject *resultobj = 0;
54221 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54222 wxSizer *arg2 = (wxSizer *) 0 ;
54223 wxGBPosition result;
54224 void *argp1 = 0 ;
54225 int res1 = 0 ;
54226 void *argp2 = 0 ;
54227 int res2 = 0 ;
54228
54229 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54231 if (!SWIG_IsOK(res1)) {
54232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54233 }
54234 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54235 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54236 if (!SWIG_IsOK(res2)) {
54237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54238 }
54239 arg2 = reinterpret_cast< wxSizer * >(argp2);
54240 {
54241 PyThreadState* __tstate = wxPyBeginAllowThreads();
54242 result = (arg1)->GetItemPosition(arg2);
54243 wxPyEndAllowThreads(__tstate);
54244 if (PyErr_Occurred()) SWIG_fail;
54245 }
54246 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54247 return resultobj;
54248 fail:
54249 return NULL;
54250 }
54251
54252
54253 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54254 PyObject *resultobj = 0;
54255 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54256 size_t arg2 ;
54257 wxGBPosition result;
54258 void *argp1 = 0 ;
54259 int res1 = 0 ;
54260 size_t val2 ;
54261 int ecode2 = 0 ;
54262
54263 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54264 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54265 if (!SWIG_IsOK(res1)) {
54266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54267 }
54268 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54269 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54270 if (!SWIG_IsOK(ecode2)) {
54271 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54272 }
54273 arg2 = static_cast< size_t >(val2);
54274 {
54275 PyThreadState* __tstate = wxPyBeginAllowThreads();
54276 result = (arg1)->GetItemPosition(arg2);
54277 wxPyEndAllowThreads(__tstate);
54278 if (PyErr_Occurred()) SWIG_fail;
54279 }
54280 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54281 return resultobj;
54282 fail:
54283 return NULL;
54284 }
54285
54286
54287 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54288 int argc;
54289 PyObject *argv[3];
54290
54291 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54292 --argc;
54293 if (argc == 2) {
54294 int _v = 0;
54295 {
54296 void *vptr = 0;
54297 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54298 _v = SWIG_CheckState(res);
54299 }
54300 if (!_v) goto check_1;
54301 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54302 }
54303 check_1:
54304
54305 if (argc == 2) {
54306 int _v = 0;
54307 {
54308 void *vptr = 0;
54309 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54310 _v = SWIG_CheckState(res);
54311 }
54312 if (!_v) goto check_2;
54313 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54314 }
54315 check_2:
54316
54317 if (argc == 2) {
54318 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54319 }
54320
54321 fail:
54322 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54323 return NULL;
54324 }
54325
54326
54327 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54328 PyObject *resultobj = 0;
54329 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54330 wxWindow *arg2 = (wxWindow *) 0 ;
54331 wxGBPosition *arg3 = 0 ;
54332 bool result;
54333 void *argp1 = 0 ;
54334 int res1 = 0 ;
54335 void *argp2 = 0 ;
54336 int res2 = 0 ;
54337 wxGBPosition temp3 ;
54338
54339 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54340 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54341 if (!SWIG_IsOK(res1)) {
54342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54343 }
54344 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54345 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54346 if (!SWIG_IsOK(res2)) {
54347 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54348 }
54349 arg2 = reinterpret_cast< wxWindow * >(argp2);
54350 {
54351 arg3 = &temp3;
54352 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54353 }
54354 {
54355 PyThreadState* __tstate = wxPyBeginAllowThreads();
54356 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54357 wxPyEndAllowThreads(__tstate);
54358 if (PyErr_Occurred()) SWIG_fail;
54359 }
54360 {
54361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54362 }
54363 return resultobj;
54364 fail:
54365 return NULL;
54366 }
54367
54368
54369 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54370 PyObject *resultobj = 0;
54371 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54372 wxSizer *arg2 = (wxSizer *) 0 ;
54373 wxGBPosition *arg3 = 0 ;
54374 bool result;
54375 void *argp1 = 0 ;
54376 int res1 = 0 ;
54377 void *argp2 = 0 ;
54378 int res2 = 0 ;
54379 wxGBPosition temp3 ;
54380
54381 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54383 if (!SWIG_IsOK(res1)) {
54384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54385 }
54386 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54387 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54388 if (!SWIG_IsOK(res2)) {
54389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54390 }
54391 arg2 = reinterpret_cast< wxSizer * >(argp2);
54392 {
54393 arg3 = &temp3;
54394 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54395 }
54396 {
54397 PyThreadState* __tstate = wxPyBeginAllowThreads();
54398 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54399 wxPyEndAllowThreads(__tstate);
54400 if (PyErr_Occurred()) SWIG_fail;
54401 }
54402 {
54403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54404 }
54405 return resultobj;
54406 fail:
54407 return NULL;
54408 }
54409
54410
54411 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54412 PyObject *resultobj = 0;
54413 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54414 size_t arg2 ;
54415 wxGBPosition *arg3 = 0 ;
54416 bool result;
54417 void *argp1 = 0 ;
54418 int res1 = 0 ;
54419 size_t val2 ;
54420 int ecode2 = 0 ;
54421 wxGBPosition temp3 ;
54422
54423 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54425 if (!SWIG_IsOK(res1)) {
54426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54427 }
54428 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54429 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54430 if (!SWIG_IsOK(ecode2)) {
54431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54432 }
54433 arg2 = static_cast< size_t >(val2);
54434 {
54435 arg3 = &temp3;
54436 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54437 }
54438 {
54439 PyThreadState* __tstate = wxPyBeginAllowThreads();
54440 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54441 wxPyEndAllowThreads(__tstate);
54442 if (PyErr_Occurred()) SWIG_fail;
54443 }
54444 {
54445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54446 }
54447 return resultobj;
54448 fail:
54449 return NULL;
54450 }
54451
54452
54453 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54454 int argc;
54455 PyObject *argv[4];
54456
54457 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54458 --argc;
54459 if (argc == 3) {
54460 int _v = 0;
54461 {
54462 void *vptr = 0;
54463 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54464 _v = SWIG_CheckState(res);
54465 }
54466 if (!_v) goto check_1;
54467 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54468 }
54469 check_1:
54470
54471 if (argc == 3) {
54472 int _v = 0;
54473 {
54474 void *vptr = 0;
54475 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54476 _v = SWIG_CheckState(res);
54477 }
54478 if (!_v) goto check_2;
54479 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54480 }
54481 check_2:
54482
54483 if (argc == 3) {
54484 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54485 }
54486
54487 fail:
54488 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54489 return NULL;
54490 }
54491
54492
54493 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54494 PyObject *resultobj = 0;
54495 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54496 wxWindow *arg2 = (wxWindow *) 0 ;
54497 wxGBSpan result;
54498 void *argp1 = 0 ;
54499 int res1 = 0 ;
54500 void *argp2 = 0 ;
54501 int res2 = 0 ;
54502
54503 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54505 if (!SWIG_IsOK(res1)) {
54506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54507 }
54508 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54509 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54510 if (!SWIG_IsOK(res2)) {
54511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54512 }
54513 arg2 = reinterpret_cast< wxWindow * >(argp2);
54514 {
54515 PyThreadState* __tstate = wxPyBeginAllowThreads();
54516 result = (arg1)->GetItemSpan(arg2);
54517 wxPyEndAllowThreads(__tstate);
54518 if (PyErr_Occurred()) SWIG_fail;
54519 }
54520 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54521 return resultobj;
54522 fail:
54523 return NULL;
54524 }
54525
54526
54527 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54528 PyObject *resultobj = 0;
54529 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54530 wxSizer *arg2 = (wxSizer *) 0 ;
54531 wxGBSpan result;
54532 void *argp1 = 0 ;
54533 int res1 = 0 ;
54534 void *argp2 = 0 ;
54535 int res2 = 0 ;
54536
54537 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54539 if (!SWIG_IsOK(res1)) {
54540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54541 }
54542 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54543 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54544 if (!SWIG_IsOK(res2)) {
54545 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54546 }
54547 arg2 = reinterpret_cast< wxSizer * >(argp2);
54548 {
54549 PyThreadState* __tstate = wxPyBeginAllowThreads();
54550 result = (arg1)->GetItemSpan(arg2);
54551 wxPyEndAllowThreads(__tstate);
54552 if (PyErr_Occurred()) SWIG_fail;
54553 }
54554 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54555 return resultobj;
54556 fail:
54557 return NULL;
54558 }
54559
54560
54561 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54562 PyObject *resultobj = 0;
54563 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54564 size_t arg2 ;
54565 wxGBSpan result;
54566 void *argp1 = 0 ;
54567 int res1 = 0 ;
54568 size_t val2 ;
54569 int ecode2 = 0 ;
54570
54571 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54573 if (!SWIG_IsOK(res1)) {
54574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54575 }
54576 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54577 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54578 if (!SWIG_IsOK(ecode2)) {
54579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54580 }
54581 arg2 = static_cast< size_t >(val2);
54582 {
54583 PyThreadState* __tstate = wxPyBeginAllowThreads();
54584 result = (arg1)->GetItemSpan(arg2);
54585 wxPyEndAllowThreads(__tstate);
54586 if (PyErr_Occurred()) SWIG_fail;
54587 }
54588 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54589 return resultobj;
54590 fail:
54591 return NULL;
54592 }
54593
54594
54595 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54596 int argc;
54597 PyObject *argv[3];
54598
54599 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54600 --argc;
54601 if (argc == 2) {
54602 int _v = 0;
54603 {
54604 void *vptr = 0;
54605 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54606 _v = SWIG_CheckState(res);
54607 }
54608 if (!_v) goto check_1;
54609 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54610 }
54611 check_1:
54612
54613 if (argc == 2) {
54614 int _v = 0;
54615 {
54616 void *vptr = 0;
54617 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54618 _v = SWIG_CheckState(res);
54619 }
54620 if (!_v) goto check_2;
54621 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54622 }
54623 check_2:
54624
54625 if (argc == 2) {
54626 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54627 }
54628
54629 fail:
54630 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54631 return NULL;
54632 }
54633
54634
54635 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54636 PyObject *resultobj = 0;
54637 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54638 wxWindow *arg2 = (wxWindow *) 0 ;
54639 wxGBSpan *arg3 = 0 ;
54640 bool result;
54641 void *argp1 = 0 ;
54642 int res1 = 0 ;
54643 void *argp2 = 0 ;
54644 int res2 = 0 ;
54645 wxGBSpan temp3 ;
54646
54647 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54649 if (!SWIG_IsOK(res1)) {
54650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54651 }
54652 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54653 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54654 if (!SWIG_IsOK(res2)) {
54655 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54656 }
54657 arg2 = reinterpret_cast< wxWindow * >(argp2);
54658 {
54659 arg3 = &temp3;
54660 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54661 }
54662 {
54663 PyThreadState* __tstate = wxPyBeginAllowThreads();
54664 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54665 wxPyEndAllowThreads(__tstate);
54666 if (PyErr_Occurred()) SWIG_fail;
54667 }
54668 {
54669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54670 }
54671 return resultobj;
54672 fail:
54673 return NULL;
54674 }
54675
54676
54677 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54678 PyObject *resultobj = 0;
54679 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54680 wxSizer *arg2 = (wxSizer *) 0 ;
54681 wxGBSpan *arg3 = 0 ;
54682 bool result;
54683 void *argp1 = 0 ;
54684 int res1 = 0 ;
54685 void *argp2 = 0 ;
54686 int res2 = 0 ;
54687 wxGBSpan temp3 ;
54688
54689 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54691 if (!SWIG_IsOK(res1)) {
54692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54693 }
54694 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54695 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54696 if (!SWIG_IsOK(res2)) {
54697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54698 }
54699 arg2 = reinterpret_cast< wxSizer * >(argp2);
54700 {
54701 arg3 = &temp3;
54702 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54703 }
54704 {
54705 PyThreadState* __tstate = wxPyBeginAllowThreads();
54706 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54707 wxPyEndAllowThreads(__tstate);
54708 if (PyErr_Occurred()) SWIG_fail;
54709 }
54710 {
54711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54712 }
54713 return resultobj;
54714 fail:
54715 return NULL;
54716 }
54717
54718
54719 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54720 PyObject *resultobj = 0;
54721 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54722 size_t arg2 ;
54723 wxGBSpan *arg3 = 0 ;
54724 bool result;
54725 void *argp1 = 0 ;
54726 int res1 = 0 ;
54727 size_t val2 ;
54728 int ecode2 = 0 ;
54729 wxGBSpan temp3 ;
54730
54731 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54733 if (!SWIG_IsOK(res1)) {
54734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54735 }
54736 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54737 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54738 if (!SWIG_IsOK(ecode2)) {
54739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54740 }
54741 arg2 = static_cast< size_t >(val2);
54742 {
54743 arg3 = &temp3;
54744 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54745 }
54746 {
54747 PyThreadState* __tstate = wxPyBeginAllowThreads();
54748 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54749 wxPyEndAllowThreads(__tstate);
54750 if (PyErr_Occurred()) SWIG_fail;
54751 }
54752 {
54753 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54754 }
54755 return resultobj;
54756 fail:
54757 return NULL;
54758 }
54759
54760
54761 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54762 int argc;
54763 PyObject *argv[4];
54764
54765 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54766 --argc;
54767 if (argc == 3) {
54768 int _v = 0;
54769 {
54770 void *vptr = 0;
54771 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54772 _v = SWIG_CheckState(res);
54773 }
54774 if (!_v) goto check_1;
54775 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54776 }
54777 check_1:
54778
54779 if (argc == 3) {
54780 int _v = 0;
54781 {
54782 void *vptr = 0;
54783 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54784 _v = SWIG_CheckState(res);
54785 }
54786 if (!_v) goto check_2;
54787 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54788 }
54789 check_2:
54790
54791 if (argc == 3) {
54792 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54793 }
54794
54795 fail:
54796 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54797 return NULL;
54798 }
54799
54800
54801 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54802 PyObject *resultobj = 0;
54803 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54804 wxWindow *arg2 = (wxWindow *) 0 ;
54805 wxGBSizerItem *result = 0 ;
54806 void *argp1 = 0 ;
54807 int res1 = 0 ;
54808 void *argp2 = 0 ;
54809 int res2 = 0 ;
54810
54811 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54813 if (!SWIG_IsOK(res1)) {
54814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54815 }
54816 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54817 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54818 if (!SWIG_IsOK(res2)) {
54819 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54820 }
54821 arg2 = reinterpret_cast< wxWindow * >(argp2);
54822 {
54823 PyThreadState* __tstate = wxPyBeginAllowThreads();
54824 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54825 wxPyEndAllowThreads(__tstate);
54826 if (PyErr_Occurred()) SWIG_fail;
54827 }
54828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54829 return resultobj;
54830 fail:
54831 return NULL;
54832 }
54833
54834
54835 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54836 PyObject *resultobj = 0;
54837 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54838 wxSizer *arg2 = (wxSizer *) 0 ;
54839 wxGBSizerItem *result = 0 ;
54840 void *argp1 = 0 ;
54841 int res1 = 0 ;
54842 void *argp2 = 0 ;
54843 int res2 = 0 ;
54844
54845 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54847 if (!SWIG_IsOK(res1)) {
54848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54849 }
54850 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54851 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54852 if (!SWIG_IsOK(res2)) {
54853 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54854 }
54855 arg2 = reinterpret_cast< wxSizer * >(argp2);
54856 {
54857 PyThreadState* __tstate = wxPyBeginAllowThreads();
54858 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54859 wxPyEndAllowThreads(__tstate);
54860 if (PyErr_Occurred()) SWIG_fail;
54861 }
54862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54863 return resultobj;
54864 fail:
54865 return NULL;
54866 }
54867
54868
54869 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54870 int argc;
54871 PyObject *argv[3];
54872
54873 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54874 --argc;
54875 if (argc == 2) {
54876 int _v = 0;
54877 {
54878 void *vptr = 0;
54879 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54880 _v = SWIG_CheckState(res);
54881 }
54882 if (!_v) goto check_1;
54883 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54884 }
54885 check_1:
54886
54887 if (argc == 2) {
54888 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54889 }
54890
54891 fail:
54892 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54893 return NULL;
54894 }
54895
54896
54897 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54898 PyObject *resultobj = 0;
54899 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54900 wxGBPosition *arg2 = 0 ;
54901 wxGBSizerItem *result = 0 ;
54902 void *argp1 = 0 ;
54903 int res1 = 0 ;
54904 wxGBPosition temp2 ;
54905 PyObject * obj0 = 0 ;
54906 PyObject * obj1 = 0 ;
54907 char * kwnames[] = {
54908 (char *) "self",(char *) "pos", NULL
54909 };
54910
54911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54913 if (!SWIG_IsOK(res1)) {
54914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54915 }
54916 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54917 {
54918 arg2 = &temp2;
54919 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54920 }
54921 {
54922 PyThreadState* __tstate = wxPyBeginAllowThreads();
54923 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54924 wxPyEndAllowThreads(__tstate);
54925 if (PyErr_Occurred()) SWIG_fail;
54926 }
54927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54928 return resultobj;
54929 fail:
54930 return NULL;
54931 }
54932
54933
54934 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54935 PyObject *resultobj = 0;
54936 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54937 wxPoint *arg2 = 0 ;
54938 wxGBSizerItem *result = 0 ;
54939 void *argp1 = 0 ;
54940 int res1 = 0 ;
54941 wxPoint temp2 ;
54942 PyObject * obj0 = 0 ;
54943 PyObject * obj1 = 0 ;
54944 char * kwnames[] = {
54945 (char *) "self",(char *) "pt", NULL
54946 };
54947
54948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54950 if (!SWIG_IsOK(res1)) {
54951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54952 }
54953 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54954 {
54955 arg2 = &temp2;
54956 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54957 }
54958 {
54959 PyThreadState* __tstate = wxPyBeginAllowThreads();
54960 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54961 wxPyEndAllowThreads(__tstate);
54962 if (PyErr_Occurred()) SWIG_fail;
54963 }
54964 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54965 return resultobj;
54966 fail:
54967 return NULL;
54968 }
54969
54970
54971 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54972 PyObject *resultobj = 0;
54973 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54974 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54975 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54976 bool result;
54977 void *argp1 = 0 ;
54978 int res1 = 0 ;
54979 void *argp2 = 0 ;
54980 int res2 = 0 ;
54981 void *argp3 = 0 ;
54982 int res3 = 0 ;
54983 PyObject * obj0 = 0 ;
54984 PyObject * obj1 = 0 ;
54985 PyObject * obj2 = 0 ;
54986 char * kwnames[] = {
54987 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54988 };
54989
54990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54992 if (!SWIG_IsOK(res1)) {
54993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54994 }
54995 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54996 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54997 if (!SWIG_IsOK(res2)) {
54998 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54999 }
55000 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55001 if (obj2) {
55002 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55003 if (!SWIG_IsOK(res3)) {
55004 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
55005 }
55006 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
55007 }
55008 {
55009 PyThreadState* __tstate = wxPyBeginAllowThreads();
55010 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
55011 wxPyEndAllowThreads(__tstate);
55012 if (PyErr_Occurred()) SWIG_fail;
55013 }
55014 {
55015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55016 }
55017 return resultobj;
55018 fail:
55019 return NULL;
55020 }
55021
55022
55023 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55024 PyObject *resultobj = 0;
55025 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55026 wxGBPosition *arg2 = 0 ;
55027 wxGBSpan *arg3 = 0 ;
55028 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55029 bool result;
55030 void *argp1 = 0 ;
55031 int res1 = 0 ;
55032 wxGBPosition temp2 ;
55033 wxGBSpan temp3 ;
55034 void *argp4 = 0 ;
55035 int res4 = 0 ;
55036 PyObject * obj0 = 0 ;
55037 PyObject * obj1 = 0 ;
55038 PyObject * obj2 = 0 ;
55039 PyObject * obj3 = 0 ;
55040 char * kwnames[] = {
55041 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55042 };
55043
55044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55046 if (!SWIG_IsOK(res1)) {
55047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55048 }
55049 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55050 {
55051 arg2 = &temp2;
55052 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55053 }
55054 {
55055 arg3 = &temp3;
55056 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55057 }
55058 if (obj3) {
55059 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55060 if (!SWIG_IsOK(res4)) {
55061 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55062 }
55063 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55064 }
55065 {
55066 PyThreadState* __tstate = wxPyBeginAllowThreads();
55067 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55068 wxPyEndAllowThreads(__tstate);
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 *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55081 PyObject *obj;
55082 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55083 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55084 return SWIG_Py_Void();
55085 }
55086
55087 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55088 return SWIG_Python_InitShadowInstance(args);
55089 }
55090
55091 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55092 PyObject *resultobj = 0;
55093 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55094 wxRelationship arg2 ;
55095 wxWindow *arg3 = (wxWindow *) 0 ;
55096 wxEdge arg4 ;
55097 int arg5 = (int) 0 ;
55098 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55099 void *argp1 = 0 ;
55100 int res1 = 0 ;
55101 int val2 ;
55102 int ecode2 = 0 ;
55103 void *argp3 = 0 ;
55104 int res3 = 0 ;
55105 int val4 ;
55106 int ecode4 = 0 ;
55107 int val5 ;
55108 int ecode5 = 0 ;
55109 int val6 ;
55110 int ecode6 = 0 ;
55111 PyObject * obj0 = 0 ;
55112 PyObject * obj1 = 0 ;
55113 PyObject * obj2 = 0 ;
55114 PyObject * obj3 = 0 ;
55115 PyObject * obj4 = 0 ;
55116 PyObject * obj5 = 0 ;
55117 char * kwnames[] = {
55118 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55119 };
55120
55121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55123 if (!SWIG_IsOK(res1)) {
55124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55125 }
55126 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55127 ecode2 = SWIG_AsVal_int(obj1, &val2);
55128 if (!SWIG_IsOK(ecode2)) {
55129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55130 }
55131 arg2 = static_cast< wxRelationship >(val2);
55132 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55133 if (!SWIG_IsOK(res3)) {
55134 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55135 }
55136 arg3 = reinterpret_cast< wxWindow * >(argp3);
55137 ecode4 = SWIG_AsVal_int(obj3, &val4);
55138 if (!SWIG_IsOK(ecode4)) {
55139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55140 }
55141 arg4 = static_cast< wxEdge >(val4);
55142 if (obj4) {
55143 ecode5 = SWIG_AsVal_int(obj4, &val5);
55144 if (!SWIG_IsOK(ecode5)) {
55145 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55146 }
55147 arg5 = static_cast< int >(val5);
55148 }
55149 if (obj5) {
55150 ecode6 = SWIG_AsVal_int(obj5, &val6);
55151 if (!SWIG_IsOK(ecode6)) {
55152 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55153 }
55154 arg6 = static_cast< int >(val6);
55155 }
55156 {
55157 PyThreadState* __tstate = wxPyBeginAllowThreads();
55158 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55159 wxPyEndAllowThreads(__tstate);
55160 if (PyErr_Occurred()) SWIG_fail;
55161 }
55162 resultobj = SWIG_Py_Void();
55163 return resultobj;
55164 fail:
55165 return NULL;
55166 }
55167
55168
55169 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55170 PyObject *resultobj = 0;
55171 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55172 wxWindow *arg2 = (wxWindow *) 0 ;
55173 int arg3 = (int) 0 ;
55174 void *argp1 = 0 ;
55175 int res1 = 0 ;
55176 void *argp2 = 0 ;
55177 int res2 = 0 ;
55178 int val3 ;
55179 int ecode3 = 0 ;
55180 PyObject * obj0 = 0 ;
55181 PyObject * obj1 = 0 ;
55182 PyObject * obj2 = 0 ;
55183 char * kwnames[] = {
55184 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55185 };
55186
55187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55189 if (!SWIG_IsOK(res1)) {
55190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55191 }
55192 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55193 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55194 if (!SWIG_IsOK(res2)) {
55195 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55196 }
55197 arg2 = reinterpret_cast< wxWindow * >(argp2);
55198 if (obj2) {
55199 ecode3 = SWIG_AsVal_int(obj2, &val3);
55200 if (!SWIG_IsOK(ecode3)) {
55201 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55202 }
55203 arg3 = static_cast< int >(val3);
55204 }
55205 {
55206 PyThreadState* __tstate = wxPyBeginAllowThreads();
55207 (arg1)->LeftOf(arg2,arg3);
55208 wxPyEndAllowThreads(__tstate);
55209 if (PyErr_Occurred()) SWIG_fail;
55210 }
55211 resultobj = SWIG_Py_Void();
55212 return resultobj;
55213 fail:
55214 return NULL;
55215 }
55216
55217
55218 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55219 PyObject *resultobj = 0;
55220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55221 wxWindow *arg2 = (wxWindow *) 0 ;
55222 int arg3 = (int) 0 ;
55223 void *argp1 = 0 ;
55224 int res1 = 0 ;
55225 void *argp2 = 0 ;
55226 int res2 = 0 ;
55227 int val3 ;
55228 int ecode3 = 0 ;
55229 PyObject * obj0 = 0 ;
55230 PyObject * obj1 = 0 ;
55231 PyObject * obj2 = 0 ;
55232 char * kwnames[] = {
55233 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55234 };
55235
55236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55238 if (!SWIG_IsOK(res1)) {
55239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55240 }
55241 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55243 if (!SWIG_IsOK(res2)) {
55244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55245 }
55246 arg2 = reinterpret_cast< wxWindow * >(argp2);
55247 if (obj2) {
55248 ecode3 = SWIG_AsVal_int(obj2, &val3);
55249 if (!SWIG_IsOK(ecode3)) {
55250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55251 }
55252 arg3 = static_cast< int >(val3);
55253 }
55254 {
55255 PyThreadState* __tstate = wxPyBeginAllowThreads();
55256 (arg1)->RightOf(arg2,arg3);
55257 wxPyEndAllowThreads(__tstate);
55258 if (PyErr_Occurred()) SWIG_fail;
55259 }
55260 resultobj = SWIG_Py_Void();
55261 return resultobj;
55262 fail:
55263 return NULL;
55264 }
55265
55266
55267 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55268 PyObject *resultobj = 0;
55269 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55270 wxWindow *arg2 = (wxWindow *) 0 ;
55271 int arg3 = (int) 0 ;
55272 void *argp1 = 0 ;
55273 int res1 = 0 ;
55274 void *argp2 = 0 ;
55275 int res2 = 0 ;
55276 int val3 ;
55277 int ecode3 = 0 ;
55278 PyObject * obj0 = 0 ;
55279 PyObject * obj1 = 0 ;
55280 PyObject * obj2 = 0 ;
55281 char * kwnames[] = {
55282 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55283 };
55284
55285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55287 if (!SWIG_IsOK(res1)) {
55288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55289 }
55290 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55292 if (!SWIG_IsOK(res2)) {
55293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55294 }
55295 arg2 = reinterpret_cast< wxWindow * >(argp2);
55296 if (obj2) {
55297 ecode3 = SWIG_AsVal_int(obj2, &val3);
55298 if (!SWIG_IsOK(ecode3)) {
55299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55300 }
55301 arg3 = static_cast< int >(val3);
55302 }
55303 {
55304 PyThreadState* __tstate = wxPyBeginAllowThreads();
55305 (arg1)->Above(arg2,arg3);
55306 wxPyEndAllowThreads(__tstate);
55307 if (PyErr_Occurred()) SWIG_fail;
55308 }
55309 resultobj = SWIG_Py_Void();
55310 return resultobj;
55311 fail:
55312 return NULL;
55313 }
55314
55315
55316 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55317 PyObject *resultobj = 0;
55318 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55319 wxWindow *arg2 = (wxWindow *) 0 ;
55320 int arg3 = (int) 0 ;
55321 void *argp1 = 0 ;
55322 int res1 = 0 ;
55323 void *argp2 = 0 ;
55324 int res2 = 0 ;
55325 int val3 ;
55326 int ecode3 = 0 ;
55327 PyObject * obj0 = 0 ;
55328 PyObject * obj1 = 0 ;
55329 PyObject * obj2 = 0 ;
55330 char * kwnames[] = {
55331 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55332 };
55333
55334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55336 if (!SWIG_IsOK(res1)) {
55337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55338 }
55339 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55341 if (!SWIG_IsOK(res2)) {
55342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55343 }
55344 arg2 = reinterpret_cast< wxWindow * >(argp2);
55345 if (obj2) {
55346 ecode3 = SWIG_AsVal_int(obj2, &val3);
55347 if (!SWIG_IsOK(ecode3)) {
55348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55349 }
55350 arg3 = static_cast< int >(val3);
55351 }
55352 {
55353 PyThreadState* __tstate = wxPyBeginAllowThreads();
55354 (arg1)->Below(arg2,arg3);
55355 wxPyEndAllowThreads(__tstate);
55356 if (PyErr_Occurred()) SWIG_fail;
55357 }
55358 resultobj = SWIG_Py_Void();
55359 return resultobj;
55360 fail:
55361 return NULL;
55362 }
55363
55364
55365 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55366 PyObject *resultobj = 0;
55367 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55368 wxWindow *arg2 = (wxWindow *) 0 ;
55369 wxEdge arg3 ;
55370 int arg4 = (int) 0 ;
55371 void *argp1 = 0 ;
55372 int res1 = 0 ;
55373 void *argp2 = 0 ;
55374 int res2 = 0 ;
55375 int val3 ;
55376 int ecode3 = 0 ;
55377 int val4 ;
55378 int ecode4 = 0 ;
55379 PyObject * obj0 = 0 ;
55380 PyObject * obj1 = 0 ;
55381 PyObject * obj2 = 0 ;
55382 PyObject * obj3 = 0 ;
55383 char * kwnames[] = {
55384 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55385 };
55386
55387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55389 if (!SWIG_IsOK(res1)) {
55390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55391 }
55392 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55393 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55394 if (!SWIG_IsOK(res2)) {
55395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55396 }
55397 arg2 = reinterpret_cast< wxWindow * >(argp2);
55398 ecode3 = SWIG_AsVal_int(obj2, &val3);
55399 if (!SWIG_IsOK(ecode3)) {
55400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55401 }
55402 arg3 = static_cast< wxEdge >(val3);
55403 if (obj3) {
55404 ecode4 = SWIG_AsVal_int(obj3, &val4);
55405 if (!SWIG_IsOK(ecode4)) {
55406 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55407 }
55408 arg4 = static_cast< int >(val4);
55409 }
55410 {
55411 PyThreadState* __tstate = wxPyBeginAllowThreads();
55412 (arg1)->SameAs(arg2,arg3,arg4);
55413 wxPyEndAllowThreads(__tstate);
55414 if (PyErr_Occurred()) SWIG_fail;
55415 }
55416 resultobj = SWIG_Py_Void();
55417 return resultobj;
55418 fail:
55419 return NULL;
55420 }
55421
55422
55423 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55424 PyObject *resultobj = 0;
55425 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55426 wxWindow *arg2 = (wxWindow *) 0 ;
55427 wxEdge arg3 ;
55428 int arg4 ;
55429 void *argp1 = 0 ;
55430 int res1 = 0 ;
55431 void *argp2 = 0 ;
55432 int res2 = 0 ;
55433 int val3 ;
55434 int ecode3 = 0 ;
55435 int val4 ;
55436 int ecode4 = 0 ;
55437 PyObject * obj0 = 0 ;
55438 PyObject * obj1 = 0 ;
55439 PyObject * obj2 = 0 ;
55440 PyObject * obj3 = 0 ;
55441 char * kwnames[] = {
55442 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55443 };
55444
55445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55447 if (!SWIG_IsOK(res1)) {
55448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55449 }
55450 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55451 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55452 if (!SWIG_IsOK(res2)) {
55453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55454 }
55455 arg2 = reinterpret_cast< wxWindow * >(argp2);
55456 ecode3 = SWIG_AsVal_int(obj2, &val3);
55457 if (!SWIG_IsOK(ecode3)) {
55458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55459 }
55460 arg3 = static_cast< wxEdge >(val3);
55461 ecode4 = SWIG_AsVal_int(obj3, &val4);
55462 if (!SWIG_IsOK(ecode4)) {
55463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55464 }
55465 arg4 = static_cast< int >(val4);
55466 {
55467 PyThreadState* __tstate = wxPyBeginAllowThreads();
55468 (arg1)->PercentOf(arg2,arg3,arg4);
55469 wxPyEndAllowThreads(__tstate);
55470 if (PyErr_Occurred()) SWIG_fail;
55471 }
55472 resultobj = SWIG_Py_Void();
55473 return resultobj;
55474 fail:
55475 return NULL;
55476 }
55477
55478
55479 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55480 PyObject *resultobj = 0;
55481 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55482 int arg2 ;
55483 void *argp1 = 0 ;
55484 int res1 = 0 ;
55485 int val2 ;
55486 int ecode2 = 0 ;
55487 PyObject * obj0 = 0 ;
55488 PyObject * obj1 = 0 ;
55489 char * kwnames[] = {
55490 (char *) "self",(char *) "val", NULL
55491 };
55492
55493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55495 if (!SWIG_IsOK(res1)) {
55496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55497 }
55498 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55499 ecode2 = SWIG_AsVal_int(obj1, &val2);
55500 if (!SWIG_IsOK(ecode2)) {
55501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55502 }
55503 arg2 = static_cast< int >(val2);
55504 {
55505 PyThreadState* __tstate = wxPyBeginAllowThreads();
55506 (arg1)->Absolute(arg2);
55507 wxPyEndAllowThreads(__tstate);
55508 if (PyErr_Occurred()) SWIG_fail;
55509 }
55510 resultobj = SWIG_Py_Void();
55511 return resultobj;
55512 fail:
55513 return NULL;
55514 }
55515
55516
55517 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55518 PyObject *resultobj = 0;
55519 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55520 void *argp1 = 0 ;
55521 int res1 = 0 ;
55522 PyObject *swig_obj[1] ;
55523
55524 if (!args) SWIG_fail;
55525 swig_obj[0] = args;
55526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55527 if (!SWIG_IsOK(res1)) {
55528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55529 }
55530 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55531 {
55532 PyThreadState* __tstate = wxPyBeginAllowThreads();
55533 (arg1)->Unconstrained();
55534 wxPyEndAllowThreads(__tstate);
55535 if (PyErr_Occurred()) SWIG_fail;
55536 }
55537 resultobj = SWIG_Py_Void();
55538 return resultobj;
55539 fail:
55540 return NULL;
55541 }
55542
55543
55544 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55545 PyObject *resultobj = 0;
55546 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55547 void *argp1 = 0 ;
55548 int res1 = 0 ;
55549 PyObject *swig_obj[1] ;
55550
55551 if (!args) SWIG_fail;
55552 swig_obj[0] = args;
55553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55554 if (!SWIG_IsOK(res1)) {
55555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55556 }
55557 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55558 {
55559 PyThreadState* __tstate = wxPyBeginAllowThreads();
55560 (arg1)->AsIs();
55561 wxPyEndAllowThreads(__tstate);
55562 if (PyErr_Occurred()) SWIG_fail;
55563 }
55564 resultobj = SWIG_Py_Void();
55565 return resultobj;
55566 fail:
55567 return NULL;
55568 }
55569
55570
55571 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55572 PyObject *resultobj = 0;
55573 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55574 wxWindow *result = 0 ;
55575 void *argp1 = 0 ;
55576 int res1 = 0 ;
55577 PyObject *swig_obj[1] ;
55578
55579 if (!args) SWIG_fail;
55580 swig_obj[0] = args;
55581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55582 if (!SWIG_IsOK(res1)) {
55583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55584 }
55585 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55586 {
55587 PyThreadState* __tstate = wxPyBeginAllowThreads();
55588 result = (wxWindow *)(arg1)->GetOtherWindow();
55589 wxPyEndAllowThreads(__tstate);
55590 if (PyErr_Occurred()) SWIG_fail;
55591 }
55592 {
55593 resultobj = wxPyMake_wxObject(result, 0);
55594 }
55595 return resultobj;
55596 fail:
55597 return NULL;
55598 }
55599
55600
55601 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55602 PyObject *resultobj = 0;
55603 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55604 wxEdge result;
55605 void *argp1 = 0 ;
55606 int res1 = 0 ;
55607 PyObject *swig_obj[1] ;
55608
55609 if (!args) SWIG_fail;
55610 swig_obj[0] = args;
55611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55612 if (!SWIG_IsOK(res1)) {
55613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55614 }
55615 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55616 {
55617 PyThreadState* __tstate = wxPyBeginAllowThreads();
55618 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55619 wxPyEndAllowThreads(__tstate);
55620 if (PyErr_Occurred()) SWIG_fail;
55621 }
55622 resultobj = SWIG_From_int(static_cast< int >(result));
55623 return resultobj;
55624 fail:
55625 return NULL;
55626 }
55627
55628
55629 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55630 PyObject *resultobj = 0;
55631 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55632 wxEdge arg2 ;
55633 void *argp1 = 0 ;
55634 int res1 = 0 ;
55635 int val2 ;
55636 int ecode2 = 0 ;
55637 PyObject * obj0 = 0 ;
55638 PyObject * obj1 = 0 ;
55639 char * kwnames[] = {
55640 (char *) "self",(char *) "which", NULL
55641 };
55642
55643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55645 if (!SWIG_IsOK(res1)) {
55646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55647 }
55648 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55649 ecode2 = SWIG_AsVal_int(obj1, &val2);
55650 if (!SWIG_IsOK(ecode2)) {
55651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55652 }
55653 arg2 = static_cast< wxEdge >(val2);
55654 {
55655 PyThreadState* __tstate = wxPyBeginAllowThreads();
55656 (arg1)->SetEdge(arg2);
55657 wxPyEndAllowThreads(__tstate);
55658 if (PyErr_Occurred()) SWIG_fail;
55659 }
55660 resultobj = SWIG_Py_Void();
55661 return resultobj;
55662 fail:
55663 return NULL;
55664 }
55665
55666
55667 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55668 PyObject *resultobj = 0;
55669 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55670 int arg2 ;
55671 void *argp1 = 0 ;
55672 int res1 = 0 ;
55673 int val2 ;
55674 int ecode2 = 0 ;
55675 PyObject * obj0 = 0 ;
55676 PyObject * obj1 = 0 ;
55677 char * kwnames[] = {
55678 (char *) "self",(char *) "v", NULL
55679 };
55680
55681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55683 if (!SWIG_IsOK(res1)) {
55684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55685 }
55686 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55687 ecode2 = SWIG_AsVal_int(obj1, &val2);
55688 if (!SWIG_IsOK(ecode2)) {
55689 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55690 }
55691 arg2 = static_cast< int >(val2);
55692 {
55693 PyThreadState* __tstate = wxPyBeginAllowThreads();
55694 (arg1)->SetValue(arg2);
55695 wxPyEndAllowThreads(__tstate);
55696 if (PyErr_Occurred()) SWIG_fail;
55697 }
55698 resultobj = SWIG_Py_Void();
55699 return resultobj;
55700 fail:
55701 return NULL;
55702 }
55703
55704
55705 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55706 PyObject *resultobj = 0;
55707 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55708 int result;
55709 void *argp1 = 0 ;
55710 int res1 = 0 ;
55711 PyObject *swig_obj[1] ;
55712
55713 if (!args) SWIG_fail;
55714 swig_obj[0] = args;
55715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55716 if (!SWIG_IsOK(res1)) {
55717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55718 }
55719 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55720 {
55721 PyThreadState* __tstate = wxPyBeginAllowThreads();
55722 result = (int)(arg1)->GetMargin();
55723 wxPyEndAllowThreads(__tstate);
55724 if (PyErr_Occurred()) SWIG_fail;
55725 }
55726 resultobj = SWIG_From_int(static_cast< int >(result));
55727 return resultobj;
55728 fail:
55729 return NULL;
55730 }
55731
55732
55733 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55734 PyObject *resultobj = 0;
55735 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55736 int arg2 ;
55737 void *argp1 = 0 ;
55738 int res1 = 0 ;
55739 int val2 ;
55740 int ecode2 = 0 ;
55741 PyObject * obj0 = 0 ;
55742 PyObject * obj1 = 0 ;
55743 char * kwnames[] = {
55744 (char *) "self",(char *) "m", NULL
55745 };
55746
55747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55749 if (!SWIG_IsOK(res1)) {
55750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55751 }
55752 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55753 ecode2 = SWIG_AsVal_int(obj1, &val2);
55754 if (!SWIG_IsOK(ecode2)) {
55755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55756 }
55757 arg2 = static_cast< int >(val2);
55758 {
55759 PyThreadState* __tstate = wxPyBeginAllowThreads();
55760 (arg1)->SetMargin(arg2);
55761 wxPyEndAllowThreads(__tstate);
55762 if (PyErr_Occurred()) SWIG_fail;
55763 }
55764 resultobj = SWIG_Py_Void();
55765 return resultobj;
55766 fail:
55767 return NULL;
55768 }
55769
55770
55771 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55772 PyObject *resultobj = 0;
55773 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55774 int result;
55775 void *argp1 = 0 ;
55776 int res1 = 0 ;
55777 PyObject *swig_obj[1] ;
55778
55779 if (!args) SWIG_fail;
55780 swig_obj[0] = args;
55781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55782 if (!SWIG_IsOK(res1)) {
55783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55784 }
55785 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55786 {
55787 PyThreadState* __tstate = wxPyBeginAllowThreads();
55788 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55789 wxPyEndAllowThreads(__tstate);
55790 if (PyErr_Occurred()) SWIG_fail;
55791 }
55792 resultobj = SWIG_From_int(static_cast< int >(result));
55793 return resultobj;
55794 fail:
55795 return NULL;
55796 }
55797
55798
55799 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55800 PyObject *resultobj = 0;
55801 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55802 int result;
55803 void *argp1 = 0 ;
55804 int res1 = 0 ;
55805 PyObject *swig_obj[1] ;
55806
55807 if (!args) SWIG_fail;
55808 swig_obj[0] = args;
55809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55810 if (!SWIG_IsOK(res1)) {
55811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55812 }
55813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55814 {
55815 PyThreadState* __tstate = wxPyBeginAllowThreads();
55816 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55817 wxPyEndAllowThreads(__tstate);
55818 if (PyErr_Occurred()) SWIG_fail;
55819 }
55820 resultobj = SWIG_From_int(static_cast< int >(result));
55821 return resultobj;
55822 fail:
55823 return NULL;
55824 }
55825
55826
55827 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55828 PyObject *resultobj = 0;
55829 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55830 int result;
55831 void *argp1 = 0 ;
55832 int res1 = 0 ;
55833 PyObject *swig_obj[1] ;
55834
55835 if (!args) SWIG_fail;
55836 swig_obj[0] = args;
55837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55838 if (!SWIG_IsOK(res1)) {
55839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55840 }
55841 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55842 {
55843 PyThreadState* __tstate = wxPyBeginAllowThreads();
55844 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55845 wxPyEndAllowThreads(__tstate);
55846 if (PyErr_Occurred()) SWIG_fail;
55847 }
55848 resultobj = SWIG_From_int(static_cast< int >(result));
55849 return resultobj;
55850 fail:
55851 return NULL;
55852 }
55853
55854
55855 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55856 PyObject *resultobj = 0;
55857 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55858 bool result;
55859 void *argp1 = 0 ;
55860 int res1 = 0 ;
55861 PyObject *swig_obj[1] ;
55862
55863 if (!args) SWIG_fail;
55864 swig_obj[0] = args;
55865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55866 if (!SWIG_IsOK(res1)) {
55867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55868 }
55869 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55870 {
55871 PyThreadState* __tstate = wxPyBeginAllowThreads();
55872 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55873 wxPyEndAllowThreads(__tstate);
55874 if (PyErr_Occurred()) SWIG_fail;
55875 }
55876 {
55877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55878 }
55879 return resultobj;
55880 fail:
55881 return NULL;
55882 }
55883
55884
55885 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55886 PyObject *resultobj = 0;
55887 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55888 bool arg2 ;
55889 void *argp1 = 0 ;
55890 int res1 = 0 ;
55891 bool val2 ;
55892 int ecode2 = 0 ;
55893 PyObject * obj0 = 0 ;
55894 PyObject * obj1 = 0 ;
55895 char * kwnames[] = {
55896 (char *) "self",(char *) "d", NULL
55897 };
55898
55899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55900 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55901 if (!SWIG_IsOK(res1)) {
55902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55903 }
55904 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55905 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55906 if (!SWIG_IsOK(ecode2)) {
55907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55908 }
55909 arg2 = static_cast< bool >(val2);
55910 {
55911 PyThreadState* __tstate = wxPyBeginAllowThreads();
55912 (arg1)->SetDone(arg2);
55913 wxPyEndAllowThreads(__tstate);
55914 if (PyErr_Occurred()) SWIG_fail;
55915 }
55916 resultobj = SWIG_Py_Void();
55917 return resultobj;
55918 fail:
55919 return NULL;
55920 }
55921
55922
55923 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55924 PyObject *resultobj = 0;
55925 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55926 wxRelationship result;
55927 void *argp1 = 0 ;
55928 int res1 = 0 ;
55929 PyObject *swig_obj[1] ;
55930
55931 if (!args) SWIG_fail;
55932 swig_obj[0] = args;
55933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55934 if (!SWIG_IsOK(res1)) {
55935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55936 }
55937 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55938 {
55939 PyThreadState* __tstate = wxPyBeginAllowThreads();
55940 result = (wxRelationship)(arg1)->GetRelationship();
55941 wxPyEndAllowThreads(__tstate);
55942 if (PyErr_Occurred()) SWIG_fail;
55943 }
55944 resultobj = SWIG_From_int(static_cast< int >(result));
55945 return resultobj;
55946 fail:
55947 return NULL;
55948 }
55949
55950
55951 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55952 PyObject *resultobj = 0;
55953 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55954 wxRelationship arg2 ;
55955 void *argp1 = 0 ;
55956 int res1 = 0 ;
55957 int val2 ;
55958 int ecode2 = 0 ;
55959 PyObject * obj0 = 0 ;
55960 PyObject * obj1 = 0 ;
55961 char * kwnames[] = {
55962 (char *) "self",(char *) "r", NULL
55963 };
55964
55965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55967 if (!SWIG_IsOK(res1)) {
55968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55969 }
55970 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55971 ecode2 = SWIG_AsVal_int(obj1, &val2);
55972 if (!SWIG_IsOK(ecode2)) {
55973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55974 }
55975 arg2 = static_cast< wxRelationship >(val2);
55976 {
55977 PyThreadState* __tstate = wxPyBeginAllowThreads();
55978 (arg1)->SetRelationship(arg2);
55979 wxPyEndAllowThreads(__tstate);
55980 if (PyErr_Occurred()) SWIG_fail;
55981 }
55982 resultobj = SWIG_Py_Void();
55983 return resultobj;
55984 fail:
55985 return NULL;
55986 }
55987
55988
55989 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55990 PyObject *resultobj = 0;
55991 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55992 wxWindow *arg2 = (wxWindow *) 0 ;
55993 bool result;
55994 void *argp1 = 0 ;
55995 int res1 = 0 ;
55996 void *argp2 = 0 ;
55997 int res2 = 0 ;
55998 PyObject * obj0 = 0 ;
55999 PyObject * obj1 = 0 ;
56000 char * kwnames[] = {
56001 (char *) "self",(char *) "otherW", NULL
56002 };
56003
56004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
56005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56006 if (!SWIG_IsOK(res1)) {
56007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56008 }
56009 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56010 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56011 if (!SWIG_IsOK(res2)) {
56012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
56013 }
56014 arg2 = reinterpret_cast< wxWindow * >(argp2);
56015 {
56016 PyThreadState* __tstate = wxPyBeginAllowThreads();
56017 result = (bool)(arg1)->ResetIfWin(arg2);
56018 wxPyEndAllowThreads(__tstate);
56019 if (PyErr_Occurred()) SWIG_fail;
56020 }
56021 {
56022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56023 }
56024 return resultobj;
56025 fail:
56026 return NULL;
56027 }
56028
56029
56030 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56031 PyObject *resultobj = 0;
56032 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56033 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56034 wxWindow *arg3 = (wxWindow *) 0 ;
56035 bool result;
56036 void *argp1 = 0 ;
56037 int res1 = 0 ;
56038 void *argp2 = 0 ;
56039 int res2 = 0 ;
56040 void *argp3 = 0 ;
56041 int res3 = 0 ;
56042 PyObject * obj0 = 0 ;
56043 PyObject * obj1 = 0 ;
56044 PyObject * obj2 = 0 ;
56045 char * kwnames[] = {
56046 (char *) "self",(char *) "constraints",(char *) "win", NULL
56047 };
56048
56049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56051 if (!SWIG_IsOK(res1)) {
56052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56053 }
56054 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56056 if (!SWIG_IsOK(res2)) {
56057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56058 }
56059 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56060 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56061 if (!SWIG_IsOK(res3)) {
56062 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56063 }
56064 arg3 = reinterpret_cast< wxWindow * >(argp3);
56065 {
56066 PyThreadState* __tstate = wxPyBeginAllowThreads();
56067 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56068 wxPyEndAllowThreads(__tstate);
56069 if (PyErr_Occurred()) SWIG_fail;
56070 }
56071 {
56072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56073 }
56074 return resultobj;
56075 fail:
56076 return NULL;
56077 }
56078
56079
56080 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56081 PyObject *resultobj = 0;
56082 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56083 wxEdge arg2 ;
56084 wxWindow *arg3 = (wxWindow *) 0 ;
56085 wxWindow *arg4 = (wxWindow *) 0 ;
56086 int result;
56087 void *argp1 = 0 ;
56088 int res1 = 0 ;
56089 int val2 ;
56090 int ecode2 = 0 ;
56091 void *argp3 = 0 ;
56092 int res3 = 0 ;
56093 void *argp4 = 0 ;
56094 int res4 = 0 ;
56095 PyObject * obj0 = 0 ;
56096 PyObject * obj1 = 0 ;
56097 PyObject * obj2 = 0 ;
56098 PyObject * obj3 = 0 ;
56099 char * kwnames[] = {
56100 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56101 };
56102
56103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56105 if (!SWIG_IsOK(res1)) {
56106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56107 }
56108 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56109 ecode2 = SWIG_AsVal_int(obj1, &val2);
56110 if (!SWIG_IsOK(ecode2)) {
56111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56112 }
56113 arg2 = static_cast< wxEdge >(val2);
56114 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56115 if (!SWIG_IsOK(res3)) {
56116 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56117 }
56118 arg3 = reinterpret_cast< wxWindow * >(argp3);
56119 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56120 if (!SWIG_IsOK(res4)) {
56121 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56122 }
56123 arg4 = reinterpret_cast< wxWindow * >(argp4);
56124 {
56125 PyThreadState* __tstate = wxPyBeginAllowThreads();
56126 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56127 wxPyEndAllowThreads(__tstate);
56128 if (PyErr_Occurred()) SWIG_fail;
56129 }
56130 resultobj = SWIG_From_int(static_cast< int >(result));
56131 return resultobj;
56132 fail:
56133 return NULL;
56134 }
56135
56136
56137 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56138 PyObject *obj;
56139 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56140 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56141 return SWIG_Py_Void();
56142 }
56143
56144 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56145 PyObject *resultobj = 0;
56146 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56147 wxIndividualLayoutConstraint *result = 0 ;
56148 void *argp1 = 0 ;
56149 int res1 = 0 ;
56150 PyObject *swig_obj[1] ;
56151
56152 if (!args) SWIG_fail;
56153 swig_obj[0] = args;
56154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56155 if (!SWIG_IsOK(res1)) {
56156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56157 }
56158 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56159 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56161 return resultobj;
56162 fail:
56163 return NULL;
56164 }
56165
56166
56167 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56168 PyObject *resultobj = 0;
56169 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56170 wxIndividualLayoutConstraint *result = 0 ;
56171 void *argp1 = 0 ;
56172 int res1 = 0 ;
56173 PyObject *swig_obj[1] ;
56174
56175 if (!args) SWIG_fail;
56176 swig_obj[0] = args;
56177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56178 if (!SWIG_IsOK(res1)) {
56179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56180 }
56181 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56182 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56184 return resultobj;
56185 fail:
56186 return NULL;
56187 }
56188
56189
56190 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56191 PyObject *resultobj = 0;
56192 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56193 wxIndividualLayoutConstraint *result = 0 ;
56194 void *argp1 = 0 ;
56195 int res1 = 0 ;
56196 PyObject *swig_obj[1] ;
56197
56198 if (!args) SWIG_fail;
56199 swig_obj[0] = args;
56200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56201 if (!SWIG_IsOK(res1)) {
56202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56203 }
56204 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56205 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56207 return resultobj;
56208 fail:
56209 return NULL;
56210 }
56211
56212
56213 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56214 PyObject *resultobj = 0;
56215 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56216 wxIndividualLayoutConstraint *result = 0 ;
56217 void *argp1 = 0 ;
56218 int res1 = 0 ;
56219 PyObject *swig_obj[1] ;
56220
56221 if (!args) SWIG_fail;
56222 swig_obj[0] = args;
56223 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56224 if (!SWIG_IsOK(res1)) {
56225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56226 }
56227 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56228 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56230 return resultobj;
56231 fail:
56232 return NULL;
56233 }
56234
56235
56236 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56237 PyObject *resultobj = 0;
56238 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56239 wxIndividualLayoutConstraint *result = 0 ;
56240 void *argp1 = 0 ;
56241 int res1 = 0 ;
56242 PyObject *swig_obj[1] ;
56243
56244 if (!args) SWIG_fail;
56245 swig_obj[0] = args;
56246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56247 if (!SWIG_IsOK(res1)) {
56248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56249 }
56250 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56251 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56253 return resultobj;
56254 fail:
56255 return NULL;
56256 }
56257
56258
56259 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56260 PyObject *resultobj = 0;
56261 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56262 wxIndividualLayoutConstraint *result = 0 ;
56263 void *argp1 = 0 ;
56264 int res1 = 0 ;
56265 PyObject *swig_obj[1] ;
56266
56267 if (!args) SWIG_fail;
56268 swig_obj[0] = args;
56269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56270 if (!SWIG_IsOK(res1)) {
56271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56272 }
56273 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56274 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56276 return resultobj;
56277 fail:
56278 return NULL;
56279 }
56280
56281
56282 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56283 PyObject *resultobj = 0;
56284 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56285 wxIndividualLayoutConstraint *result = 0 ;
56286 void *argp1 = 0 ;
56287 int res1 = 0 ;
56288 PyObject *swig_obj[1] ;
56289
56290 if (!args) SWIG_fail;
56291 swig_obj[0] = args;
56292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56293 if (!SWIG_IsOK(res1)) {
56294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56295 }
56296 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56297 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56299 return resultobj;
56300 fail:
56301 return NULL;
56302 }
56303
56304
56305 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56306 PyObject *resultobj = 0;
56307 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56308 wxIndividualLayoutConstraint *result = 0 ;
56309 void *argp1 = 0 ;
56310 int res1 = 0 ;
56311 PyObject *swig_obj[1] ;
56312
56313 if (!args) SWIG_fail;
56314 swig_obj[0] = args;
56315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56316 if (!SWIG_IsOK(res1)) {
56317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56318 }
56319 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56320 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56322 return resultobj;
56323 fail:
56324 return NULL;
56325 }
56326
56327
56328 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56329 PyObject *resultobj = 0;
56330 wxLayoutConstraints *result = 0 ;
56331
56332 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56333 {
56334 PyThreadState* __tstate = wxPyBeginAllowThreads();
56335 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56336 wxPyEndAllowThreads(__tstate);
56337 if (PyErr_Occurred()) SWIG_fail;
56338 }
56339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56340 return resultobj;
56341 fail:
56342 return NULL;
56343 }
56344
56345
56346 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56347 PyObject *resultobj = 0;
56348 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56349 void *argp1 = 0 ;
56350 int res1 = 0 ;
56351 PyObject *swig_obj[1] ;
56352
56353 if (!args) SWIG_fail;
56354 swig_obj[0] = args;
56355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56356 if (!SWIG_IsOK(res1)) {
56357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56358 }
56359 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56360 {
56361 PyThreadState* __tstate = wxPyBeginAllowThreads();
56362 delete arg1;
56363
56364 wxPyEndAllowThreads(__tstate);
56365 if (PyErr_Occurred()) SWIG_fail;
56366 }
56367 resultobj = SWIG_Py_Void();
56368 return resultobj;
56369 fail:
56370 return NULL;
56371 }
56372
56373
56374 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56375 PyObject *resultobj = 0;
56376 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56377 wxWindow *arg2 = (wxWindow *) 0 ;
56378 int *arg3 = (int *) 0 ;
56379 bool result;
56380 void *argp1 = 0 ;
56381 int res1 = 0 ;
56382 void *argp2 = 0 ;
56383 int res2 = 0 ;
56384 int temp3 ;
56385 int res3 = SWIG_TMPOBJ ;
56386 PyObject * obj0 = 0 ;
56387 PyObject * obj1 = 0 ;
56388 char * kwnames[] = {
56389 (char *) "self",(char *) "win", NULL
56390 };
56391
56392 arg3 = &temp3;
56393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56395 if (!SWIG_IsOK(res1)) {
56396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56397 }
56398 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56399 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56400 if (!SWIG_IsOK(res2)) {
56401 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56402 }
56403 arg2 = reinterpret_cast< wxWindow * >(argp2);
56404 {
56405 PyThreadState* __tstate = wxPyBeginAllowThreads();
56406 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56407 wxPyEndAllowThreads(__tstate);
56408 if (PyErr_Occurred()) SWIG_fail;
56409 }
56410 {
56411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56412 }
56413 if (SWIG_IsTmpObj(res3)) {
56414 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56415 } else {
56416 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56417 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56418 }
56419 return resultobj;
56420 fail:
56421 return NULL;
56422 }
56423
56424
56425 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56426 PyObject *resultobj = 0;
56427 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56428 bool result;
56429 void *argp1 = 0 ;
56430 int res1 = 0 ;
56431 PyObject *swig_obj[1] ;
56432
56433 if (!args) SWIG_fail;
56434 swig_obj[0] = args;
56435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56436 if (!SWIG_IsOK(res1)) {
56437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56438 }
56439 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56440 {
56441 PyThreadState* __tstate = wxPyBeginAllowThreads();
56442 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56443 wxPyEndAllowThreads(__tstate);
56444 if (PyErr_Occurred()) SWIG_fail;
56445 }
56446 {
56447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56448 }
56449 return resultobj;
56450 fail:
56451 return NULL;
56452 }
56453
56454
56455 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56456 PyObject *obj;
56457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56458 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56459 return SWIG_Py_Void();
56460 }
56461
56462 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56463 return SWIG_Python_InitShadowInstance(args);
56464 }
56465
56466 static PyMethodDef SwigMethods[] = {
56467 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56468 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56469 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56470 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56472 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56473 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56474 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56475 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56476 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56477 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56478 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56479 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56480 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56481 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56482 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56483 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56484 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56486 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56487 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56488 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56491 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56492 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56493 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56494 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56495 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56496 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56497 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56498 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56499 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56500 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56501 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56503 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56504 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56509 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56510 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56511 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56512 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56513 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56514 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56515 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56516 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56517 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56518 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56520 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56521 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56522 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56523 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56525 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56526 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56527 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56529 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56532 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56533 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56535 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56537 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56538 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56539 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56541 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56543 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56544 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56545 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56546 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56547 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56548 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56550 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56552 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56553 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56554 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56555 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56556 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56557 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56564 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56567 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56568 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56569 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56570 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56571 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56573 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56574 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56576 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56577 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56578 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56579 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56580 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56581 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56582 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56583 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56584 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56586 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56587 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56588 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56592 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56593 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56594 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56595 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56596 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56597 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56600 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56601 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56604 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56611 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56612 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56613 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56614 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56616 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56617 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56618 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56620 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56621 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56622 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56623 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56626 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56627 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56628 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56629 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56632 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56635 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56636 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56638 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56639 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56640 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56641 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56644 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56647 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56652 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56653 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56654 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56655 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56664 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56665 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56666 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56667 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56668 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56669 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56670 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56671 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56672 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56673 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56674 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56675 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56676 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56677 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56678 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56679 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56680 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56681 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56682 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56683 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56688 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56689 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56690 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56691 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56692 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56693 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56696 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56697 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56698 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56700 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56701 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56703 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56704 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56705 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56706 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56707 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56708 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56709 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56710 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56711 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56712 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56713 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56714 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56715 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56719 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56725 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56726 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56727 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56728 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56730 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56733 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56736 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56739 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56740 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56741 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56744 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56745 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56746 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56748 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56750 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56751 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56752 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56756 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56761 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56762 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56763 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56764 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56765 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56766 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56767 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56768 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56774 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56775 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56777 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56778 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56779 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56785 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56786 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56788 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56789 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56790 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56791 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56792 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56793 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56794 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56795 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56797 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56798 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56799 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56800 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56801 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56802 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56803 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56804 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56805 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56806 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56807 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56808 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56809 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56810 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56815 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56820 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56827 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56828 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56831 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56832 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56833 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56834 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56837 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56840 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56848 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56849 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56850 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56851 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56853 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56854 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56856 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56858 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56860 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56862 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56863 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56865 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56866 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56867 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56868 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56869 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56870 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56873 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56876 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56877 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56879 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56880 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56881 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56883 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56887 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56888 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56889 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56890 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56891 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56892 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56893 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56894 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56895 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56896 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56897 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56898 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56899 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56900 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56901 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56902 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56903 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56904 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56905 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56906 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56907 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56908 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56909 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56910 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56911 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56912 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56913 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56914 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56915 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56916 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56917 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56918 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56919 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56920 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56921 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56922 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56923 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56924 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56925 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56926 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56927 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56928 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56929 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56930 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56931 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56932 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56933 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56934 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56935 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56936 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56937 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56940 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56944 { (char *)"EvtHandler_AllowReentrance", (PyCFunction) _wrap_EvtHandler_AllowReentrance, METH_VARARGS | METH_KEYWORDS, NULL},
56945 { (char *)"EvtHandler_IsReentranceAllowed", (PyCFunction)_wrap_EvtHandler_IsReentranceAllowed, METH_O, NULL},
56946 { (char *)"EvtHandler_IsEventHandlingInProgress", (PyCFunction)_wrap_EvtHandler_IsEventHandlingInProgress, METH_O, NULL},
56947 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56948 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56950 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56951 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56952 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56953 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56954 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56956 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56957 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56959 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56960 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56961 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56962 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56963 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56965 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56966 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56967 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56968 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56969 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56970 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56971 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56972 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56973 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56974 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56975 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56976 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56977 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56978 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56979 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56980 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56981 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56982 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56983 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56984 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56985 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56986 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56987 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56988 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56989 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56990 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56991 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56992 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56993 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56994 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56995 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56996 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56997 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56998 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56999 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57000 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
57001 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
57002 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57003 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57004 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
57005 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
57006 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57007 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
57008 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
57009 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57010 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57011 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
57012 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
57013 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57014 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
57015 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
57016 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
57017 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
57018 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
57019 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
57020 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
57021 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
57022 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
57023 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
57024 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
57025 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57026 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57027 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57028 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57029 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57030 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57031 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57032 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57033 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57034 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57035 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57036 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57037 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57038 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57039 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57040 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57041 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57042 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57043 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57044 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57045 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57046 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57047 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57048 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57049 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57050 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57051 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57052 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57053 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57054 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57055 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57056 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57057 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57058 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57059 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57060 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57061 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57062 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57063 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57064 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57065 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57066 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57067 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57068 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57069 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57070 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57071 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57072 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57073 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57074 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57075 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57076 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57077 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57078 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57079 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57080 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57081 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57082 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57083 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57084 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57085 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57086 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57087 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57088 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57089 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57090 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57091 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57092 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57093 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57094 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57095 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57096 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57097 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57098 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57099 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57100 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57101 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57102 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57103 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57104 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57105 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57106 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57107 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57108 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57109 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57110 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57111 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57112 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57113 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57114 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57115 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57116 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57117 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57118 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57119 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57120 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57121 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57122 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57123 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57124 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57125 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57126 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57127 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57128 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57129 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57130 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57131 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57132 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57133 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57134 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57135 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57136 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57137 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57138 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57139 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57140 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57141 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57142 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57143 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57144 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57145 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57146 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57147 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57148 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57149 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57150 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57151 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57152 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57153 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57154 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57155 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57156 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57157 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57158 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57159 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57160 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57161 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57162 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57163 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57164 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57165 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57166 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57167 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57168 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57169 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57170 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57171 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57172 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57173 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57174 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57175 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57176 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57177 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57178 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57179 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57180 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57181 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57182 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57183 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57184 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57186 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57187 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57188 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57190 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57191 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57192 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57193 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57194 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57195 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57196 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57197 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57198 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57199 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57200 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57201 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57202 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57203 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57204 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57205 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57206 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57207 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57208 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57209 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57210 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57211 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57212 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57213 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57214 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57215 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57216 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57217 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57218 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57219 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57220 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57221 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57222 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57223 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57225 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57226 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57227 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57228 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57229 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57230 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57231 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57232 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57233 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57236 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57237 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57238 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57240 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57241 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57242 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57243 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57244 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57245 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57246 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57247 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57248 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57249 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57251 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57252 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57253 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57254 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57255 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57256 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57257 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57258 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57259 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57260 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57261 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57262 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57263 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57264 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57265 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57266 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57267 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57268 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57269 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57270 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57271 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57272 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57273 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57275 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57276 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57277 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57278 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57279 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57281 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57282 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57283 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57284 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57285 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57286 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57287 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57289 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57290 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57291 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57293 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57295 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57296 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57297 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57298 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57300 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57302 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57304 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57305 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57306 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57307 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57309 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57310 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57311 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57312 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57313 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57314 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57315 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57316 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57317 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57319 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57321 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57322 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57323 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57324 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57325 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57327 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57328 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57329 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57330 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57331 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57332 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57333 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57334 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57335 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57340 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57341 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57342 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57343 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57344 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57345 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57346 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57347 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57348 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57349 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57351 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57352 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57354 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57355 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57356 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57357 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57358 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57359 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57360 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57361 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57362 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57364 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57365 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57367 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57368 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57369 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57370 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57371 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57372 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57374 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57375 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57376 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57377 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57378 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57380 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57381 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57382 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57383 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57384 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57385 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57386 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57388 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57389 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57390 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57391 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57392 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57393 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57394 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57395 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57396 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57397 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57399 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57400 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57402 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57403 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57404 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57406 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57408 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57409 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57410 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57411 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57412 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57413 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57416 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57423 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57425 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57426 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57427 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57431 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57432 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57433 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57434 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57435 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57436 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57437 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57438 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57439 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57440 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57441 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57442 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57443 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57444 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57445 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57446 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57447 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57448 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57449 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57450 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57451 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57456 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57457 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57459 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57460 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57461 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57462 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57463 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57466 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57467 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57468 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57470 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57472 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57473 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57474 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57475 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57477 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57479 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57481 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57484 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57485 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57486 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57487 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57488 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57489 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57490 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57493 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57494 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57495 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57496 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57498 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57503 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57506 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57509 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57510 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57511 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57512 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57513 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57514 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57515 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57516 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57525 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57526 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57527 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57528 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57531 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57532 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57533 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57534 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57535 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57536 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57537 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57538 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57539 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57540 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57543 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57549 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57550 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57551 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57552 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57554 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57555 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57557 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57560 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57562 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57563 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57564 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57566 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57567 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57573 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57577 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57578 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57580 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57587 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57590 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57591 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57592 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57593 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57594 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57598 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57601 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57603 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57606 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57608 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57609 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57612 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57614 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57615 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57616 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57617 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57618 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57619 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57620 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57621 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57625 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57626 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57627 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57629 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57630 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57631 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57633 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57635 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57636 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57637 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57639 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57640 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57641 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57643 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57645 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57651 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57658 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57660 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57663 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57666 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57669 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57670 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57675 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57683 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57684 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57685 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57687 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57688 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57690 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57692 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57693 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57695 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57696 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57697 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57701 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57720 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57721 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57723 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57724 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57725 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57726 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57727 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57728 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57730 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57731 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57734 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57735 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57737 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57738 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57740 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57741 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57743 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57744 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57746 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57748 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57750 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57751 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57753 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57754 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57757 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57759 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57761 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57763 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57766 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57768 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57769 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57770 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57771 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57772 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57773 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57774 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57776 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57778 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57779 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57782 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57783 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57787 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57791 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57792 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57794 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57798 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57800 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57802 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57803 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57804 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57805 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57809 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57810 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57811 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57812 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57814 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57815 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57820 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57821 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57822 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57823 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57824 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57825 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57826 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57828 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57829 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57830 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57831 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57833 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57835 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57838 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57839 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57840 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57842 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57843 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57844 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57856 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57857 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57862 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57863 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57864 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57865 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57866 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57867 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57868 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57874 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57875 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57879 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57880 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57882 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57883 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57885 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57887 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57888 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57890 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57891 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57892 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57898 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57899 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57900 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57901 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57902 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57903 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57905 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57910 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57912 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57913 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57914 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57915 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57916 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57917 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57919 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57923 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57924 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57925 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57926 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57927 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57928 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57929 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57931 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57932 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57933 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57934 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57935 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57936 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57939 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57940 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57941 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57943 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57944 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57945 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57947 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57951 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57952 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57953 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57954 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57955 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57959 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57960 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57962 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57965 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57966 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57968 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57969 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57970 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57971 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57972 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57974 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57976 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57977 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57978 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57979 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57980 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57985 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57986 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57987 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57988 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57989 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57990 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57993 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57994 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57995 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57996 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57997 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57998 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57999 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
58000 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
58001 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
58002 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
58003 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
58004 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
58005 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
58006 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
58007 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
58008 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
58013 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
58014 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
58015 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
58016 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
58017 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
58018 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
58019 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
58020 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
58021 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
58022 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
58023 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58024 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
58025 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
58026 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58027 { NULL, NULL, 0, NULL }
58028 };
58029
58030
58031 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58032
58033 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58034 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58035 }
58036 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58037 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58038 }
58039 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58040 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58041 }
58042 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58043 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58044 }
58045 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58046 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58047 }
58048 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58049 return (void *)((wxSizer *) ((wxGridSizer *) x));
58050 }
58051 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58052 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58053 }
58054 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58055 return (void *)((wxSizer *) ((wxPySizer *) x));
58056 }
58057 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58058 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58059 }
58060 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58061 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58062 }
58063 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58064 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58065 }
58066 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58067 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58068 }
58069 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58070 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58071 }
58072 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58073 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58074 }
58075 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58076 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58077 }
58078 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58079 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58080 }
58081 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58082 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58083 }
58084 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58085 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58086 }
58087 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58088 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58089 }
58090 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58091 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58092 }
58093 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58094 return (void *)((wxEvent *) ((wxPyEvent *) x));
58095 }
58096 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58097 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58098 }
58099 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58100 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58101 }
58102 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58103 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58104 }
58105 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58106 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58107 }
58108 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58109 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58110 }
58111 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58112 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58113 }
58114 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58115 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58116 }
58117 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58118 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58119 }
58120 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58121 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58122 }
58123 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58124 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58125 }
58126 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58127 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58128 }
58129 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58130 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58131 }
58132 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58133 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58134 }
58135 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58136 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58137 }
58138 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58139 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58140 }
58141 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58142 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58143 }
58144 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58145 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58146 }
58147 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58148 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58149 }
58150 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58151 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58152 }
58153 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58154 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58155 }
58156 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58157 return (void *)((wxEvent *) ((wxShowEvent *) x));
58158 }
58159 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58160 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58161 }
58162 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58163 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58164 }
58165 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58166 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58167 }
58168 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58169 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58170 }
58171 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58172 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58173 }
58174 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58175 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58176 }
58177 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58178 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58179 }
58180 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58181 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58182 }
58183 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58184 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58185 }
58186 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58187 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58188 }
58189 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58190 return (void *)((wxControl *) ((wxControlWithItems *) x));
58191 }
58192 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58193 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58194 }
58195 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58196 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58197 }
58198 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58199 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58200 }
58201 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58202 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58203 }
58204 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58205 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58206 }
58207 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58208 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58209 }
58210 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58211 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58212 }
58213 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58214 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58215 }
58216 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58217 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58218 }
58219 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58220 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58221 }
58222 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58223 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58224 }
58225 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58226 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58227 }
58228 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58229 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58230 }
58231 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58232 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58233 }
58234 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58235 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58236 }
58237 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58238 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58239 }
58240 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58241 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58242 }
58243 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58244 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58245 }
58246 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58247 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58248 }
58249 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58250 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58251 }
58252 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58253 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58254 }
58255 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58256 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58257 }
58258 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58259 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58260 }
58261 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58262 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58263 }
58264 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58265 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58266 }
58267 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58268 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58269 }
58270 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58271 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58272 }
58273 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58274 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58275 }
58276 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58277 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58278 }
58279 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58280 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58281 }
58282 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58283 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58284 }
58285 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58287 }
58288 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) ((wxSizerItem *) x));
58290 }
58291 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58293 }
58294 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58296 }
58297 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58299 }
58300 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58302 }
58303 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58305 }
58306 static void *_p_wxSizerTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) ((wxSizer *) x));
58308 }
58309 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58311 }
58312 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58314 }
58315 static void *_p_wxEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) ((wxEvent *) x));
58317 }
58318 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58320 }
58321 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58323 }
58324 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58326 }
58327 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58329 }
58330 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58332 }
58333 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58335 }
58336 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58338 }
58339 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58341 }
58342 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58344 }
58345 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58347 }
58348 static void *_p_wxControlTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58350 }
58351 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58353 }
58354 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) ((wxFSFile *) x));
58356 }
58357 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58359 }
58360 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58362 }
58363 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58365 }
58366 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58368 }
58369 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) ((wxMenuItem *) x));
58371 }
58372 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58374 }
58375 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58377 }
58378 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58380 }
58381 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58383 }
58384 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58386 }
58387 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58389 }
58390 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58392 }
58393 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58395 }
58396 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58398 }
58399 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58401 }
58402 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58404 }
58405 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58407 }
58408 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58410 }
58411 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58413 }
58414 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58416 }
58417 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58419 }
58420 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58422 }
58423 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58425 }
58426 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58428 }
58429 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) ((wxImageHandler *) x));
58431 }
58432 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58434 }
58435 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58437 }
58438 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58440 }
58441 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) ((wxEvtHandler *) x));
58443 }
58444 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58446 }
58447 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58449 }
58450 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58452 }
58453 static void *_p_wxImageTo_p_wxObject(void *x) {
58454 return (void *)((wxObject *) ((wxImage *) x));
58455 }
58456 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58457 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58458 }
58459 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58460 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58461 }
58462 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58463 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58464 }
58465 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58466 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58467 }
58468 static void *_p_wxWindowTo_p_wxObject(void *x) {
58469 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58470 }
58471 static void *_p_wxMenuTo_p_wxObject(void *x) {
58472 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58473 }
58474 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58475 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58476 }
58477 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58478 return (void *)((wxObject *) ((wxFileSystem *) x));
58479 }
58480 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58481 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58482 }
58483 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58484 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58485 }
58486 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58487 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58488 }
58489 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58490 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58491 }
58492 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58493 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58494 }
58495 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58496 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58497 }
58498 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58499 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58500 }
58501 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58502 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58503 }
58504 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58505 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58506 }
58507 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58508 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58509 }
58510 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58511 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58512 }
58513 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58514 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58515 }
58516 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58517 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58518 }
58519 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58520 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58521 }
58522 static void *_p_wxControlTo_p_wxWindow(void *x) {
58523 return (void *)((wxWindow *) ((wxControl *) x));
58524 }
58525 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58526 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58527 }
58528 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58529 return (void *)((wxWindow *) ((wxMenuBar *) x));
58530 }
58531 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58532 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58533 }
58534 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58535 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58536 }
58537 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58538 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58539 }
58540 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58541 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58542 }
58543 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58544 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58545 }
58546 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58547 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58548 }
58549 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58550 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58551 }
58552 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58553 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58554 }
58555 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58556 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58557 }
58558 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58559 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58560 }
58561 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58562 return (void *)((wxValidator *) ((wxPyValidator *) x));
58563 }
58564 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58566 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};
58567 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58596 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58597 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58598 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58599 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58600 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58601 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58602 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58603 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58604 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58605 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58606 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58607 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58608 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58609 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58610 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58611 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58612 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58613 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58614 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58615 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58616 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58617 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58618 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58619 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58620 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58621 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58622 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58623 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58624 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58625 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58626 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58627 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58628 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58629 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58630 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58631 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58632 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58633 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58634 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58635 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58636 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58637 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58638 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58639 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58640 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58641 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58642 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58643 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58644 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58645 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58646 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58647 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58648 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58649 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58650 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58651 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58652 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58653 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58654 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58655 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58656 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58657 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58658 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58659 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58660 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58661 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58662 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58663 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58664 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58665 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58666 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58667 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58668 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58669 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58670 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58671 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58672 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58673 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58674 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58675 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58676 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58677 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58678 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58679 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58680 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58681 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58682 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58683 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58684 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58685 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58686 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58687 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58688 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58689 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58690 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58691 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58692 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58693 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58694 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58695 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58696 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58697 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58698 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58699
58700 static swig_type_info *swig_type_initial[] = {
58701 &_swigt__p_buffer,
58702 &_swigt__p_char,
58703 &_swigt__p_form_ops_t,
58704 &_swigt__p_int,
58705 &_swigt__p_long,
58706 &_swigt__p_unsigned_char,
58707 &_swigt__p_unsigned_int,
58708 &_swigt__p_unsigned_long,
58709 &_swigt__p_wxANIHandler,
58710 &_swigt__p_wxAcceleratorEntry,
58711 &_swigt__p_wxAcceleratorTable,
58712 &_swigt__p_wxActivateEvent,
58713 &_swigt__p_wxAppTraits,
58714 &_swigt__p_wxArrayString,
58715 &_swigt__p_wxBMPHandler,
58716 &_swigt__p_wxBitmap,
58717 &_swigt__p_wxBoxSizer,
58718 &_swigt__p_wxButton,
58719 &_swigt__p_wxCURHandler,
58720 &_swigt__p_wxCaret,
58721 &_swigt__p_wxChildFocusEvent,
58722 &_swigt__p_wxClipboardTextEvent,
58723 &_swigt__p_wxCloseEvent,
58724 &_swigt__p_wxColour,
58725 &_swigt__p_wxCommandEvent,
58726 &_swigt__p_wxContextMenuEvent,
58727 &_swigt__p_wxControl,
58728 &_swigt__p_wxControlWithItems,
58729 &_swigt__p_wxCursor,
58730 &_swigt__p_wxDC,
58731 &_swigt__p_wxDateEvent,
58732 &_swigt__p_wxDateTime,
58733 &_swigt__p_wxDisplayChangedEvent,
58734 &_swigt__p_wxDouble,
58735 &_swigt__p_wxDropFilesEvent,
58736 &_swigt__p_wxDuplexMode,
58737 &_swigt__p_wxEraseEvent,
58738 &_swigt__p_wxEvent,
58739 &_swigt__p_wxEventLoop,
58740 &_swigt__p_wxEventLoopActivator,
58741 &_swigt__p_wxEvtHandler,
58742 &_swigt__p_wxFSFile,
58743 &_swigt__p_wxFileSystem,
58744 &_swigt__p_wxFileSystemHandler,
58745 &_swigt__p_wxFlexGridSizer,
58746 &_swigt__p_wxFocusEvent,
58747 &_swigt__p_wxFont,
58748 &_swigt__p_wxFrame,
58749 &_swigt__p_wxGBPosition,
58750 &_swigt__p_wxGBSizerItem,
58751 &_swigt__p_wxGBSpan,
58752 &_swigt__p_wxGIFHandler,
58753 &_swigt__p_wxGridBagSizer,
58754 &_swigt__p_wxGridSizer,
58755 &_swigt__p_wxHelpEvent__Origin,
58756 &_swigt__p_wxICOHandler,
58757 &_swigt__p_wxIconizeEvent,
58758 &_swigt__p_wxIdleEvent,
58759 &_swigt__p_wxImage,
58760 &_swigt__p_wxImageHandler,
58761 &_swigt__p_wxImageHistogram,
58762 &_swigt__p_wxImage_HSVValue,
58763 &_swigt__p_wxImage_RGBValue,
58764 &_swigt__p_wxIndividualLayoutConstraint,
58765 &_swigt__p_wxInitDialogEvent,
58766 &_swigt__p_wxInputStream,
58767 &_swigt__p_wxInternetFSHandler,
58768 &_swigt__p_wxItemContainer,
58769 &_swigt__p_wxJPEGHandler,
58770 &_swigt__p_wxKeyEvent,
58771 &_swigt__p_wxLayoutConstraints,
58772 &_swigt__p_wxMaximizeEvent,
58773 &_swigt__p_wxMemoryFSHandler,
58774 &_swigt__p_wxMenu,
58775 &_swigt__p_wxMenuBar,
58776 &_swigt__p_wxMenuBarBase,
58777 &_swigt__p_wxMenuEvent,
58778 &_swigt__p_wxMenuItem,
58779 &_swigt__p_wxMouseCaptureChangedEvent,
58780 &_swigt__p_wxMouseCaptureLostEvent,
58781 &_swigt__p_wxMouseEvent,
58782 &_swigt__p_wxMoveEvent,
58783 &_swigt__p_wxNavigationKeyEvent,
58784 &_swigt__p_wxNcPaintEvent,
58785 &_swigt__p_wxNotifyEvent,
58786 &_swigt__p_wxObject,
58787 &_swigt__p_wxOutputStream,
58788 &_swigt__p_wxPCXHandler,
58789 &_swigt__p_wxPNGHandler,
58790 &_swigt__p_wxPNMHandler,
58791 &_swigt__p_wxPaintEvent,
58792 &_swigt__p_wxPaletteChangedEvent,
58793 &_swigt__p_wxPaperSize,
58794 &_swigt__p_wxPoint,
58795 &_swigt__p_wxPoint2D,
58796 &_swigt__p_wxPropagateOnce,
58797 &_swigt__p_wxPropagationDisabler,
58798 &_swigt__p_wxPyApp,
58799 &_swigt__p_wxPyCommandEvent,
58800 &_swigt__p_wxPyDropTarget,
58801 &_swigt__p_wxPyEvent,
58802 &_swigt__p_wxPyFileSystemHandler,
58803 &_swigt__p_wxPyImageHandler,
58804 &_swigt__p_wxPyInputStream,
58805 &_swigt__p_wxPySizer,
58806 &_swigt__p_wxPyValidator,
58807 &_swigt__p_wxQuantize,
58808 &_swigt__p_wxQueryNewPaletteEvent,
58809 &_swigt__p_wxRealPoint,
58810 &_swigt__p_wxRect,
58811 &_swigt__p_wxRect2D,
58812 &_swigt__p_wxRegion,
58813 &_swigt__p_wxScrollEvent,
58814 &_swigt__p_wxScrollWinEvent,
58815 &_swigt__p_wxSetCursorEvent,
58816 &_swigt__p_wxShowEvent,
58817 &_swigt__p_wxSize,
58818 &_swigt__p_wxSizeEvent,
58819 &_swigt__p_wxSizer,
58820 &_swigt__p_wxSizerItem,
58821 &_swigt__p_wxStaticBox,
58822 &_swigt__p_wxStaticBoxSizer,
58823 &_swigt__p_wxStdDialogButtonSizer,
58824 &_swigt__p_wxSysColourChangedEvent,
58825 &_swigt__p_wxTGAHandler,
58826 &_swigt__p_wxTIFFHandler,
58827 &_swigt__p_wxToolTip,
58828 &_swigt__p_wxUpdateUIEvent,
58829 &_swigt__p_wxValidator,
58830 &_swigt__p_wxVisualAttributes,
58831 &_swigt__p_wxWindow,
58832 &_swigt__p_wxWindowCreateEvent,
58833 &_swigt__p_wxWindowDestroyEvent,
58834 &_swigt__p_wxXPMHandler,
58835 &_swigt__p_wxZipFSHandler,
58836 };
58837
58838 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58852 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}};
58853 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58854 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}};
58855 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58856 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}};
58857 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58862 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}};
58863 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58864 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}};
58865 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58866 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58870 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58871 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58872 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58873 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58874 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58875 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}};
58876 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58877 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58878 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
58879 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58880 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58881 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}};
58882 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}};
58883 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58884 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58885 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58886 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58887 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58888 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58889 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58890 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58891 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}};
58892 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58893 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}};
58894 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58895 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58896 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58897 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}};
58898 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58899 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58900 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58901 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58902 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58903 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58904 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58905 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}};
58906 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58907 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58908 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58909 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58910 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58911 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58912 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58913 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58914 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58915 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58916 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58917 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58918 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58919 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58920 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58921 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58922 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58923 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_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_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}};
58924 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58925 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58926 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58927 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58928 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58929 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58930 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58931 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58932 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58933 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58934 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58935 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58936 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58937 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58938 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58939 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58940 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58941 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58942 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58943 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58944 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58945 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58946 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58947 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58948 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58949 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58950 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58951 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58952 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58953 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58954 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58955 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58956 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}};
58957 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}};
58958 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58959 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58960 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58961 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58962 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58963 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58964 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58965 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58966 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}};
58967 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58968 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}};
58969 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58970 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58971 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58972 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58973
58974 static swig_cast_info *swig_cast_initial[] = {
58975 _swigc__p_buffer,
58976 _swigc__p_char,
58977 _swigc__p_form_ops_t,
58978 _swigc__p_int,
58979 _swigc__p_long,
58980 _swigc__p_unsigned_char,
58981 _swigc__p_unsigned_int,
58982 _swigc__p_unsigned_long,
58983 _swigc__p_wxANIHandler,
58984 _swigc__p_wxAcceleratorEntry,
58985 _swigc__p_wxAcceleratorTable,
58986 _swigc__p_wxActivateEvent,
58987 _swigc__p_wxAppTraits,
58988 _swigc__p_wxArrayString,
58989 _swigc__p_wxBMPHandler,
58990 _swigc__p_wxBitmap,
58991 _swigc__p_wxBoxSizer,
58992 _swigc__p_wxButton,
58993 _swigc__p_wxCURHandler,
58994 _swigc__p_wxCaret,
58995 _swigc__p_wxChildFocusEvent,
58996 _swigc__p_wxClipboardTextEvent,
58997 _swigc__p_wxCloseEvent,
58998 _swigc__p_wxColour,
58999 _swigc__p_wxCommandEvent,
59000 _swigc__p_wxContextMenuEvent,
59001 _swigc__p_wxControl,
59002 _swigc__p_wxControlWithItems,
59003 _swigc__p_wxCursor,
59004 _swigc__p_wxDC,
59005 _swigc__p_wxDateEvent,
59006 _swigc__p_wxDateTime,
59007 _swigc__p_wxDisplayChangedEvent,
59008 _swigc__p_wxDouble,
59009 _swigc__p_wxDropFilesEvent,
59010 _swigc__p_wxDuplexMode,
59011 _swigc__p_wxEraseEvent,
59012 _swigc__p_wxEvent,
59013 _swigc__p_wxEventLoop,
59014 _swigc__p_wxEventLoopActivator,
59015 _swigc__p_wxEvtHandler,
59016 _swigc__p_wxFSFile,
59017 _swigc__p_wxFileSystem,
59018 _swigc__p_wxFileSystemHandler,
59019 _swigc__p_wxFlexGridSizer,
59020 _swigc__p_wxFocusEvent,
59021 _swigc__p_wxFont,
59022 _swigc__p_wxFrame,
59023 _swigc__p_wxGBPosition,
59024 _swigc__p_wxGBSizerItem,
59025 _swigc__p_wxGBSpan,
59026 _swigc__p_wxGIFHandler,
59027 _swigc__p_wxGridBagSizer,
59028 _swigc__p_wxGridSizer,
59029 _swigc__p_wxHelpEvent__Origin,
59030 _swigc__p_wxICOHandler,
59031 _swigc__p_wxIconizeEvent,
59032 _swigc__p_wxIdleEvent,
59033 _swigc__p_wxImage,
59034 _swigc__p_wxImageHandler,
59035 _swigc__p_wxImageHistogram,
59036 _swigc__p_wxImage_HSVValue,
59037 _swigc__p_wxImage_RGBValue,
59038 _swigc__p_wxIndividualLayoutConstraint,
59039 _swigc__p_wxInitDialogEvent,
59040 _swigc__p_wxInputStream,
59041 _swigc__p_wxInternetFSHandler,
59042 _swigc__p_wxItemContainer,
59043 _swigc__p_wxJPEGHandler,
59044 _swigc__p_wxKeyEvent,
59045 _swigc__p_wxLayoutConstraints,
59046 _swigc__p_wxMaximizeEvent,
59047 _swigc__p_wxMemoryFSHandler,
59048 _swigc__p_wxMenu,
59049 _swigc__p_wxMenuBar,
59050 _swigc__p_wxMenuBarBase,
59051 _swigc__p_wxMenuEvent,
59052 _swigc__p_wxMenuItem,
59053 _swigc__p_wxMouseCaptureChangedEvent,
59054 _swigc__p_wxMouseCaptureLostEvent,
59055 _swigc__p_wxMouseEvent,
59056 _swigc__p_wxMoveEvent,
59057 _swigc__p_wxNavigationKeyEvent,
59058 _swigc__p_wxNcPaintEvent,
59059 _swigc__p_wxNotifyEvent,
59060 _swigc__p_wxObject,
59061 _swigc__p_wxOutputStream,
59062 _swigc__p_wxPCXHandler,
59063 _swigc__p_wxPNGHandler,
59064 _swigc__p_wxPNMHandler,
59065 _swigc__p_wxPaintEvent,
59066 _swigc__p_wxPaletteChangedEvent,
59067 _swigc__p_wxPaperSize,
59068 _swigc__p_wxPoint,
59069 _swigc__p_wxPoint2D,
59070 _swigc__p_wxPropagateOnce,
59071 _swigc__p_wxPropagationDisabler,
59072 _swigc__p_wxPyApp,
59073 _swigc__p_wxPyCommandEvent,
59074 _swigc__p_wxPyDropTarget,
59075 _swigc__p_wxPyEvent,
59076 _swigc__p_wxPyFileSystemHandler,
59077 _swigc__p_wxPyImageHandler,
59078 _swigc__p_wxPyInputStream,
59079 _swigc__p_wxPySizer,
59080 _swigc__p_wxPyValidator,
59081 _swigc__p_wxQuantize,
59082 _swigc__p_wxQueryNewPaletteEvent,
59083 _swigc__p_wxRealPoint,
59084 _swigc__p_wxRect,
59085 _swigc__p_wxRect2D,
59086 _swigc__p_wxRegion,
59087 _swigc__p_wxScrollEvent,
59088 _swigc__p_wxScrollWinEvent,
59089 _swigc__p_wxSetCursorEvent,
59090 _swigc__p_wxShowEvent,
59091 _swigc__p_wxSize,
59092 _swigc__p_wxSizeEvent,
59093 _swigc__p_wxSizer,
59094 _swigc__p_wxSizerItem,
59095 _swigc__p_wxStaticBox,
59096 _swigc__p_wxStaticBoxSizer,
59097 _swigc__p_wxStdDialogButtonSizer,
59098 _swigc__p_wxSysColourChangedEvent,
59099 _swigc__p_wxTGAHandler,
59100 _swigc__p_wxTIFFHandler,
59101 _swigc__p_wxToolTip,
59102 _swigc__p_wxUpdateUIEvent,
59103 _swigc__p_wxValidator,
59104 _swigc__p_wxVisualAttributes,
59105 _swigc__p_wxWindow,
59106 _swigc__p_wxWindowCreateEvent,
59107 _swigc__p_wxWindowDestroyEvent,
59108 _swigc__p_wxXPMHandler,
59109 _swigc__p_wxZipFSHandler,
59110 };
59111
59112
59113 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59114
59115 static swig_const_info swig_const_table[] = {
59116 {0, 0, 0, 0.0, 0, 0}};
59117
59118 #ifdef __cplusplus
59119 }
59120 #endif
59121 /* -----------------------------------------------------------------------------
59122 * Type initialization:
59123 * This problem is tough by the requirement that no dynamic
59124 * memory is used. Also, since swig_type_info structures store pointers to
59125 * swig_cast_info structures and swig_cast_info structures store pointers back
59126 * to swig_type_info structures, we need some lookup code at initialization.
59127 * The idea is that swig generates all the structures that are needed.
59128 * The runtime then collects these partially filled structures.
59129 * The SWIG_InitializeModule function takes these initial arrays out of
59130 * swig_module, and does all the lookup, filling in the swig_module.types
59131 * array with the correct data and linking the correct swig_cast_info
59132 * structures together.
59133 *
59134 * The generated swig_type_info structures are assigned staticly to an initial
59135 * array. We just loop though that array, and handle each type individually.
59136 * First we lookup if this type has been already loaded, and if so, use the
59137 * loaded structure instead of the generated one. Then we have to fill in the
59138 * cast linked list. The cast data is initially stored in something like a
59139 * two-dimensional array. Each row corresponds to a type (there are the same
59140 * number of rows as there are in the swig_type_initial array). Each entry in
59141 * a column is one of the swig_cast_info structures for that type.
59142 * The cast_initial array is actually an array of arrays, because each row has
59143 * a variable number of columns. So to actually build the cast linked list,
59144 * we find the array of casts associated with the type, and loop through it
59145 * adding the casts to the list. The one last trick we need to do is making
59146 * sure the type pointer in the swig_cast_info struct is correct.
59147 *
59148 * First off, we lookup the cast->type name to see if it is already loaded.
59149 * There are three cases to handle:
59150 * 1) If the cast->type has already been loaded AND the type we are adding
59151 * casting info to has not been loaded (it is in this module), THEN we
59152 * replace the cast->type pointer with the type pointer that has already
59153 * been loaded.
59154 * 2) If BOTH types (the one we are adding casting info to, and the
59155 * cast->type) are loaded, THEN the cast info has already been loaded by
59156 * the previous module so we just ignore it.
59157 * 3) Finally, if cast->type has not already been loaded, then we add that
59158 * swig_cast_info to the linked list (because the cast->type) pointer will
59159 * be correct.
59160 * ----------------------------------------------------------------------------- */
59161
59162 #ifdef __cplusplus
59163 extern "C" {
59164 #if 0
59165 } /* c-mode */
59166 #endif
59167 #endif
59168
59169 #if 0
59170 #define SWIGRUNTIME_DEBUG
59171 #endif
59172
59173 SWIGRUNTIME void
59174 SWIG_InitializeModule(void *clientdata) {
59175 size_t i;
59176 swig_module_info *module_head;
59177 static int init_run = 0;
59178
59179 clientdata = clientdata;
59180
59181 if (init_run) return;
59182 init_run = 1;
59183
59184 /* Initialize the swig_module */
59185 swig_module.type_initial = swig_type_initial;
59186 swig_module.cast_initial = swig_cast_initial;
59187
59188 /* Try and load any already created modules */
59189 module_head = SWIG_GetModule(clientdata);
59190 if (module_head) {
59191 swig_module.next = module_head->next;
59192 module_head->next = &swig_module;
59193 } else {
59194 /* This is the first module loaded */
59195 swig_module.next = &swig_module;
59196 SWIG_SetModule(clientdata, &swig_module);
59197 }
59198
59199 /* Now work on filling in swig_module.types */
59200 #ifdef SWIGRUNTIME_DEBUG
59201 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59202 #endif
59203 for (i = 0; i < swig_module.size; ++i) {
59204 swig_type_info *type = 0;
59205 swig_type_info *ret;
59206 swig_cast_info *cast;
59207
59208 #ifdef SWIGRUNTIME_DEBUG
59209 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59210 #endif
59211
59212 /* if there is another module already loaded */
59213 if (swig_module.next != &swig_module) {
59214 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59215 }
59216 if (type) {
59217 /* Overwrite clientdata field */
59218 #ifdef SWIGRUNTIME_DEBUG
59219 printf("SWIG_InitializeModule: found type %s\n", type->name);
59220 #endif
59221 if (swig_module.type_initial[i]->clientdata) {
59222 type->clientdata = swig_module.type_initial[i]->clientdata;
59223 #ifdef SWIGRUNTIME_DEBUG
59224 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59225 #endif
59226 }
59227 } else {
59228 type = swig_module.type_initial[i];
59229 }
59230
59231 /* Insert casting types */
59232 cast = swig_module.cast_initial[i];
59233 while (cast->type) {
59234 /* Don't need to add information already in the list */
59235 ret = 0;
59236 #ifdef SWIGRUNTIME_DEBUG
59237 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59238 #endif
59239 if (swig_module.next != &swig_module) {
59240 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59241 #ifdef SWIGRUNTIME_DEBUG
59242 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59243 #endif
59244 }
59245 if (ret) {
59246 if (type == swig_module.type_initial[i]) {
59247 #ifdef SWIGRUNTIME_DEBUG
59248 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59249 #endif
59250 cast->type = ret;
59251 ret = 0;
59252 } else {
59253 /* Check for casting already in the list */
59254 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59255 #ifdef SWIGRUNTIME_DEBUG
59256 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59257 #endif
59258 if (!ocast) ret = 0;
59259 }
59260 }
59261
59262 if (!ret) {
59263 #ifdef SWIGRUNTIME_DEBUG
59264 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59265 #endif
59266 if (type->cast) {
59267 type->cast->prev = cast;
59268 cast->next = type->cast;
59269 }
59270 type->cast = cast;
59271 }
59272 cast++;
59273 }
59274 /* Set entry in modules->types array equal to the type */
59275 swig_module.types[i] = type;
59276 }
59277 swig_module.types[i] = 0;
59278
59279 #ifdef SWIGRUNTIME_DEBUG
59280 printf("**** SWIG_InitializeModule: Cast List ******\n");
59281 for (i = 0; i < swig_module.size; ++i) {
59282 int j = 0;
59283 swig_cast_info *cast = swig_module.cast_initial[i];
59284 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59285 while (cast->type) {
59286 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59287 cast++;
59288 ++j;
59289 }
59290 printf("---- Total casts: %d\n",j);
59291 }
59292 printf("**** SWIG_InitializeModule: Cast List ******\n");
59293 #endif
59294 }
59295
59296 /* This function will propagate the clientdata field of type to
59297 * any new swig_type_info structures that have been added into the list
59298 * of equivalent types. It is like calling
59299 * SWIG_TypeClientData(type, clientdata) a second time.
59300 */
59301 SWIGRUNTIME void
59302 SWIG_PropagateClientData(void) {
59303 size_t i;
59304 swig_cast_info *equiv;
59305 static int init_run = 0;
59306
59307 if (init_run) return;
59308 init_run = 1;
59309
59310 for (i = 0; i < swig_module.size; i++) {
59311 if (swig_module.types[i]->clientdata) {
59312 equiv = swig_module.types[i]->cast;
59313 while (equiv) {
59314 if (!equiv->converter) {
59315 if (equiv->type && !equiv->type->clientdata)
59316 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59317 }
59318 equiv = equiv->next;
59319 }
59320 }
59321 }
59322 }
59323
59324 #ifdef __cplusplus
59325 #if 0
59326 {
59327 /* c-mode */
59328 #endif
59329 }
59330 #endif
59331
59332
59333
59334 #ifdef __cplusplus
59335 extern "C" {
59336 #endif
59337
59338 /* Python-specific SWIG API */
59339 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59340 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59341 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59342
59343 /* -----------------------------------------------------------------------------
59344 * global variable support code.
59345 * ----------------------------------------------------------------------------- */
59346
59347 typedef struct swig_globalvar {
59348 char *name; /* Name of global variable */
59349 PyObject *(*get_attr)(void); /* Return the current value */
59350 int (*set_attr)(PyObject *); /* Set the value */
59351 struct swig_globalvar *next;
59352 } swig_globalvar;
59353
59354 typedef struct swig_varlinkobject {
59355 PyObject_HEAD
59356 swig_globalvar *vars;
59357 } swig_varlinkobject;
59358
59359 SWIGINTERN PyObject *
59360 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59361 return PyString_FromString("<Swig global variables>");
59362 }
59363
59364 SWIGINTERN PyObject *
59365 swig_varlink_str(swig_varlinkobject *v) {
59366 PyObject *str = PyString_FromString("(");
59367 swig_globalvar *var;
59368 for (var = v->vars; var; var=var->next) {
59369 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59370 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59371 }
59372 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59373 return str;
59374 }
59375
59376 SWIGINTERN int
59377 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59378 PyObject *str = swig_varlink_str(v);
59379 fprintf(fp,"Swig global variables ");
59380 fprintf(fp,"%s\n", PyString_AsString(str));
59381 Py_DECREF(str);
59382 return 0;
59383 }
59384
59385 SWIGINTERN void
59386 swig_varlink_dealloc(swig_varlinkobject *v) {
59387 swig_globalvar *var = v->vars;
59388 while (var) {
59389 swig_globalvar *n = var->next;
59390 free(var->name);
59391 free(var);
59392 var = n;
59393 }
59394 }
59395
59396 SWIGINTERN PyObject *
59397 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59398 PyObject *res = NULL;
59399 swig_globalvar *var = v->vars;
59400 while (var) {
59401 if (strcmp(var->name,n) == 0) {
59402 res = (*var->get_attr)();
59403 break;
59404 }
59405 var = var->next;
59406 }
59407 if (res == NULL && !PyErr_Occurred()) {
59408 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59409 }
59410 return res;
59411 }
59412
59413 SWIGINTERN int
59414 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59415 int res = 1;
59416 swig_globalvar *var = v->vars;
59417 while (var) {
59418 if (strcmp(var->name,n) == 0) {
59419 res = (*var->set_attr)(p);
59420 break;
59421 }
59422 var = var->next;
59423 }
59424 if (res == 1 && !PyErr_Occurred()) {
59425 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59426 }
59427 return res;
59428 }
59429
59430 SWIGINTERN PyTypeObject*
59431 swig_varlink_type(void) {
59432 static char varlink__doc__[] = "Swig var link object";
59433 static PyTypeObject varlink_type;
59434 static int type_init = 0;
59435 if (!type_init) {
59436 const PyTypeObject tmp
59437 = {
59438 PyObject_HEAD_INIT(NULL)
59439 0, /* Number of items in variable part (ob_size) */
59440 (char *)"swigvarlink", /* Type name (tp_name) */
59441 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59442 0, /* Itemsize (tp_itemsize) */
59443 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59444 (printfunc) swig_varlink_print, /* Print (tp_print) */
59445 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59446 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59447 0, /* tp_compare */
59448 (reprfunc) swig_varlink_repr, /* tp_repr */
59449 0, /* tp_as_number */
59450 0, /* tp_as_sequence */
59451 0, /* tp_as_mapping */
59452 0, /* tp_hash */
59453 0, /* tp_call */
59454 (reprfunc)swig_varlink_str, /* tp_str */
59455 0, /* tp_getattro */
59456 0, /* tp_setattro */
59457 0, /* tp_as_buffer */
59458 0, /* tp_flags */
59459 varlink__doc__, /* tp_doc */
59460 0, /* tp_traverse */
59461 0, /* tp_clear */
59462 0, /* tp_richcompare */
59463 0, /* tp_weaklistoffset */
59464 #if PY_VERSION_HEX >= 0x02020000
59465 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59466 #endif
59467 #if PY_VERSION_HEX >= 0x02030000
59468 0, /* tp_del */
59469 #endif
59470 #ifdef COUNT_ALLOCS
59471 0,0,0,0 /* tp_alloc -> tp_next */
59472 #endif
59473 };
59474 varlink_type = tmp;
59475 varlink_type.ob_type = &PyType_Type;
59476 type_init = 1;
59477 }
59478 return &varlink_type;
59479 }
59480
59481 /* Create a variable linking object for use later */
59482 SWIGINTERN PyObject *
59483 SWIG_Python_newvarlink(void) {
59484 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59485 if (result) {
59486 result->vars = 0;
59487 }
59488 return ((PyObject*) result);
59489 }
59490
59491 SWIGINTERN void
59492 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59493 swig_varlinkobject *v = (swig_varlinkobject *) p;
59494 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59495 if (gv) {
59496 size_t size = strlen(name)+1;
59497 gv->name = (char *)malloc(size);
59498 if (gv->name) {
59499 strncpy(gv->name,name,size);
59500 gv->get_attr = get_attr;
59501 gv->set_attr = set_attr;
59502 gv->next = v->vars;
59503 }
59504 }
59505 v->vars = gv;
59506 }
59507
59508 SWIGINTERN PyObject *
59509 SWIG_globals() {
59510 static PyObject *_SWIG_globals = 0;
59511 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59512 return _SWIG_globals;
59513 }
59514
59515 /* -----------------------------------------------------------------------------
59516 * constants/methods manipulation
59517 * ----------------------------------------------------------------------------- */
59518
59519 /* Install Constants */
59520 SWIGINTERN void
59521 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59522 PyObject *obj = 0;
59523 size_t i;
59524 for (i = 0; constants[i].type; ++i) {
59525 switch(constants[i].type) {
59526 case SWIG_PY_POINTER:
59527 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59528 break;
59529 case SWIG_PY_BINARY:
59530 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59531 break;
59532 default:
59533 obj = 0;
59534 break;
59535 }
59536 if (obj) {
59537 PyDict_SetItemString(d, constants[i].name, obj);
59538 Py_DECREF(obj);
59539 }
59540 }
59541 }
59542
59543 /* -----------------------------------------------------------------------------*/
59544 /* Fix SwigMethods to carry the callback ptrs when needed */
59545 /* -----------------------------------------------------------------------------*/
59546
59547 SWIGINTERN void
59548 SWIG_Python_FixMethods(PyMethodDef *methods,
59549 swig_const_info *const_table,
59550 swig_type_info **types,
59551 swig_type_info **types_initial) {
59552 size_t i;
59553 for (i = 0; methods[i].ml_name; ++i) {
59554 const char *c = methods[i].ml_doc;
59555 if (c && (c = strstr(c, "swig_ptr: "))) {
59556 int j;
59557 swig_const_info *ci = 0;
59558 const char *name = c + 10;
59559 for (j = 0; const_table[j].type; ++j) {
59560 if (strncmp(const_table[j].name, name,
59561 strlen(const_table[j].name)) == 0) {
59562 ci = &(const_table[j]);
59563 break;
59564 }
59565 }
59566 if (ci) {
59567 size_t shift = (ci->ptype) - types;
59568 swig_type_info *ty = types_initial[shift];
59569 size_t ldoc = (c - methods[i].ml_doc);
59570 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59571 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59572 if (ndoc) {
59573 char *buff = ndoc;
59574 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59575 if (ptr) {
59576 strncpy(buff, methods[i].ml_doc, ldoc);
59577 buff += ldoc;
59578 strncpy(buff, "swig_ptr: ", 10);
59579 buff += 10;
59580 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59581 methods[i].ml_doc = ndoc;
59582 }
59583 }
59584 }
59585 }
59586 }
59587 }
59588
59589 #ifdef __cplusplus
59590 }
59591 #endif
59592
59593 /* -----------------------------------------------------------------------------*
59594 * Partial Init method
59595 * -----------------------------------------------------------------------------*/
59596
59597 #ifdef __cplusplus
59598 extern "C"
59599 #endif
59600 SWIGEXPORT void SWIG_init(void) {
59601 PyObject *m, *d;
59602
59603 /* Fix SwigMethods to carry the callback ptrs when needed */
59604 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59605
59606 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59607 d = PyModule_GetDict(m);
59608
59609 SWIG_InitializeModule(0);
59610 SWIG_InstallConstants(d,swig_const_table);
59611
59612
59613
59614 #ifndef wxPyUSE_EXPORT
59615 // Make our API structure a CObject so other modules can import it
59616 // from this module.
59617 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59618 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59619 Py_XDECREF(cobj);
59620 #endif
59621
59622 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59623 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59624 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59625 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59626 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59627 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59628 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59629 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59630 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59631 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59632 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59633 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59634 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59635 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59636 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59637 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59638 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59639 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59640 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59641 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59642 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59643 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59644 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59645 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59646 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59647 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59648 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59649 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59650 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59651 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59652 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59653 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59654 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59655 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59656 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59657 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59658 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59659 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59660 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59661 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59662 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59663 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59664 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59665 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59666 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59667 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59668 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59669 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59670 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59671 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59672 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59673 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59674 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59675 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59676 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59677 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59678 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59679 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59680 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59681 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59682 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59683 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59684 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59685 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59686 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59687 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59688 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59689 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59690 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59691 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59692 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59693 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59694 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59695 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59696 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59697 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59698 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59699 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59700 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59701 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59702 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59703 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59704 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59705 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59706 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59707 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59708 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59709 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59710 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59711 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59712 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59713 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59714 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59715 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59716 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59717 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59718 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59719 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59720 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59721 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59722 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59723 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59724 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59725 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59726 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59727 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59728 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59729 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59730 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59731 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59732 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59733 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59734 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59735 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59736 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59737 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59738 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59739 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59740 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59741 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59742 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59743 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59744 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59745 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59746 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59747 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59748 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59749 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59750 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59751 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59752 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59753 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59754 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59755 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59756 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59757 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59758 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59759 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59760 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59761 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59762 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59763 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59764 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59765 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59766 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59767 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59768 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59769 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59770 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59771 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59772 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59773 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59774 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59775 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59776 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59777 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59778 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59779 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59780 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59781 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59782 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59783 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59784 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59785 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59786 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59787 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59788 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59789 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59790 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59791 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59792 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59793 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59794 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59795 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59796 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59797 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59798 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59799 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59800 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59801 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59802 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59803 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59804 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59805 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59806 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59807 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59808 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59809 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59810 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59811 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59812 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59813 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59814 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59815 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59816 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59817 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59818 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59819 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59820 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59821 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59822 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59823 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59824 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59825 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59826 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59827 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59828 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59829 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59830 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59831 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59832 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59833 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59834 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59835 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59836 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59837 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59838 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59839 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59840 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59841 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59842 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59843 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59844 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59845 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59846 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59847 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59848 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59849 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59850 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59851 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59852 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59853 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59854 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59855 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59856 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59857 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59858 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59859 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59860 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59861 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59862 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59863 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59864 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59865 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59866 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59867 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59868 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59869 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59870 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59871 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59872 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59873 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59874 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59875 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59876 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59877 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59878 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59879 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59880 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59881 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59882 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59883 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59884 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59885 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59886 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59887 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59888 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59889 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59890 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59891 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59892 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59893 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59894 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59895 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59896 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59897 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59898 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59899 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59900 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59901 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59902 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59903 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59904 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59905 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59906 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59907 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59908 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59909 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59910 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59911 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59912 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59913 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59914 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59915 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59916 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59917 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59918 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59919 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59920 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59921 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59922 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59923 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59924 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59925 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59926 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59927 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59928 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59929 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59930 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59931 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59932 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59933 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59934 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59935 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59936 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59937 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59938 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59939 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59940 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59941 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59942 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59943 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59944 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59945 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59946 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59947 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59948 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59949 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59950 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59951 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59952 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59953 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59954 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59955 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59956 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59957 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59958 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59959 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59960 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59961 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59962 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59963 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59964 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59965 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59966 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59967 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59968 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59969 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59970 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59971 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59972 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59973 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59974 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59975 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59976 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59977 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59978 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59979 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59980 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59981 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59982 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59983 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59984 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59985 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59986 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59987 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59988 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59989 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59990 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59991 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59992 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59993 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59994 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59995 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59996 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59997 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59998 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59999 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
60000 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
60001 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
60002 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
60003 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
60004 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
60005 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
60006 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
60007 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
60008 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
60009 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
60010 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
60011 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
60012 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
60013 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
60014 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
60015 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
60016 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
60017 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
60018 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
60019 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
60020 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
60021 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
60022 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
60023 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
60024 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
60025 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
60026 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60027 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60028 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60029 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60030 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60031 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60032 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60033 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60034 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60035 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60036 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60037 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60038 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60039 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60040 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60041 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60042 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60043 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60044 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60045 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60046 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60047 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60048 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60049 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60050 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60051 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60052 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60053 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60054 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60055 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60056 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60057 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60058 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60059 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60060 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60061 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60062 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60063 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60064 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60065 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60066 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60067 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60068 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60069 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60070 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60071 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60072 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60073 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60074 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60075 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60076 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60077 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60078 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60079 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60080 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60081 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60082 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60083 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60084 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60085 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60086 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60087 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60088 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60089 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60090 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60091 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60092 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60093 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60094 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60095 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60096 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60097 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60098 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60099 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60100 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60101 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60102 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60103 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60104 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60105 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60106 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60107 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60108 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60109 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60110 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60111 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60112 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60113 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60114 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60115 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60116 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60117 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60118 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60119 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60120 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60121 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60122 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60123 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60124 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60125 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60126 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60127 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60128 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60129 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60130 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60131 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60132 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60133 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60134 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60135 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60136 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60137 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60138 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60139 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60140 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60141 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60142 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60143 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60144 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60145 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60146 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60147 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60148 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60149 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60150 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60151 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60152 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60153 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60154 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60155 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60156 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60157 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60158 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60159 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60160 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60161 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60162 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60163 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60164 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60165 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60166 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60167 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60168 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60169 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60170 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60171 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60172 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60173 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60174 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60175 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60176 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60177 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60178 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60179 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60180 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60181 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60182 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60183 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60184 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60185 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60186 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60187 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60188 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60189 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60190 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60191 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60192 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60193 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60194 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60195 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60196 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60197 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60198 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60199 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60200 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60201 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60202 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60203 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60204 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60205 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60206 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60207 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60208 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60209 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60210 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60211 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60212 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60213 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60214 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60215 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60216 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60217 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60218 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60219 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60220 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60221 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60222 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60223 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60224 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60225 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60226 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60227 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60228 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60229 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60230 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60231 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60232 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60233 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60234 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60235 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60236 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60237 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60238 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60239 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60240 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60241 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60242 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60243 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60244 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60245 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60246 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60247 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60248 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60249 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60250 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60251 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60252 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60253 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60254 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60255 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60256 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60257 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60258 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60259 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60260 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60261 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60262 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60263 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60264 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60265 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60266 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60267 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60268 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60269 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60270 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60271 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60272 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60273 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60274 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60275 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60276 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60277 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60278 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60279 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60280 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60281 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60282 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60283 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60284 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60285 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60286 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60287
60288 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60289
60290
60291 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60292
60293 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60294 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60295 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60296 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60297 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60298 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60299 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60300 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60301 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60302 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60303 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60304 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60305 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60306 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60307 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60308 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60309 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60310 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60311 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60312 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60313 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60314 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60315 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60316 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60317 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60318 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60319 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60320 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60321 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60322 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60323 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60324 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60325 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60326 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60327 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60328 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60329 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60330 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60331 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60332 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60333 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60334 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60335 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60336 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60337 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60338 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60339 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60340 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60341 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60342 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60343 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60344 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60345 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60346 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60347 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60348 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60349 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60350 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60351 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60352 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60353 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60354 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60355 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60356 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60357 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60358 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60359 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60360 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60361 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60362 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60363 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60364 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60365 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60366 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60367 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60368 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60369 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60370 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60371 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60372 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60373 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60374 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60375 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60376 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60377 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60378 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60379 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60380 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60381 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60382 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60383 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60384 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60385 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60386 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60387 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60388 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60389 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60390 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60391 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60392 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60393 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60394 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60395 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60396 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60397 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60398 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60399 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60400 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60401 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60402 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60403 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60404 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60405 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60406 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60407 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60408 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60409 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60410 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60411 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60412 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60413 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60414 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60415 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60416 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60417 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60418 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60419 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60420 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60421 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60422 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60423 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60424 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60425 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60426 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60427 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60428 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60429 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60430 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60431 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60432 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60433 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60434 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60435 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60436 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60437 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60438 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60439 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60440 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60441 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60442 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60443 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60444 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60445 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60446 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60447 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60448 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60449 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60450 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60451 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60452 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60453 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60454 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60455 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60456 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60457 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60458 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60459 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60460 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60461 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60462 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60463 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60464 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60465 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60466 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60467 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60468 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60469 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60470 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60471 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60472 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60473 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60474 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60475 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60476 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60477 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60478 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60479 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60480 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60481 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60482 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60483 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60484 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60485 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60486 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60487 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60488 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60489 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60490 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60491 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60492 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60493 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60494 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60495 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60496 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60497 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60498 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60499 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60500 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60501 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60502 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60503 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60504 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60505 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60506 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60507
60508 // Initialize threading, some globals and such
60509 __wxPyPreStart(d);
60510
60511
60512 // Although these are defined in __version__ they need to be here too so
60513 // that an assert can be done to ensure that the wxPython and the wxWindows
60514 // versions match.
60515 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60516 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60517 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60518
60519 }
60520
wxWidgets (Impactor)