]> 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_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20872 PyObject *resultobj = 0;
20873 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20874 int arg2 ;
20875 int arg3 ;
20876 int arg4 ;
20877 PyObject *arg5 = (PyObject *) 0 ;
20878 void *argp1 = 0 ;
20879 int res1 = 0 ;
20880 int val2 ;
20881 int ecode2 = 0 ;
20882 int val3 ;
20883 int ecode3 = 0 ;
20884 int val4 ;
20885 int ecode4 = 0 ;
20886 PyObject * obj0 = 0 ;
20887 PyObject * obj1 = 0 ;
20888 PyObject * obj2 = 0 ;
20889 PyObject * obj3 = 0 ;
20890 PyObject * obj4 = 0 ;
20891 char * kwnames[] = {
20892 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20893 };
20894
20895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20897 if (!SWIG_IsOK(res1)) {
20898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20899 }
20900 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20901 ecode2 = SWIG_AsVal_int(obj1, &val2);
20902 if (!SWIG_IsOK(ecode2)) {
20903 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20904 }
20905 arg2 = static_cast< int >(val2);
20906 ecode3 = SWIG_AsVal_int(obj2, &val3);
20907 if (!SWIG_IsOK(ecode3)) {
20908 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20909 }
20910 arg3 = static_cast< int >(val3);
20911 ecode4 = SWIG_AsVal_int(obj3, &val4);
20912 if (!SWIG_IsOK(ecode4)) {
20913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20914 }
20915 arg4 = static_cast< int >(val4);
20916 arg5 = obj4;
20917 {
20918 PyThreadState* __tstate = wxPyBeginAllowThreads();
20919 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20920 wxPyEndAllowThreads(__tstate);
20921 if (PyErr_Occurred()) SWIG_fail;
20922 }
20923 resultobj = SWIG_Py_Void();
20924 return resultobj;
20925 fail:
20926 return NULL;
20927 }
20928
20929
20930 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20931 PyObject *resultobj = 0;
20932 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20933 int arg2 ;
20934 int arg3 = (int) -1 ;
20935 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20936 bool result;
20937 void *argp1 = 0 ;
20938 int res1 = 0 ;
20939 int val2 ;
20940 int ecode2 = 0 ;
20941 int val3 ;
20942 int ecode3 = 0 ;
20943 int val4 ;
20944 int ecode4 = 0 ;
20945 PyObject * obj0 = 0 ;
20946 PyObject * obj1 = 0 ;
20947 PyObject * obj2 = 0 ;
20948 PyObject * obj3 = 0 ;
20949 char * kwnames[] = {
20950 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20951 };
20952
20953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20955 if (!SWIG_IsOK(res1)) {
20956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20957 }
20958 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20959 ecode2 = SWIG_AsVal_int(obj1, &val2);
20960 if (!SWIG_IsOK(ecode2)) {
20961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20962 }
20963 arg2 = static_cast< int >(val2);
20964 if (obj2) {
20965 ecode3 = SWIG_AsVal_int(obj2, &val3);
20966 if (!SWIG_IsOK(ecode3)) {
20967 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20968 }
20969 arg3 = static_cast< int >(val3);
20970 }
20971 if (obj3) {
20972 ecode4 = SWIG_AsVal_int(obj3, &val4);
20973 if (!SWIG_IsOK(ecode4)) {
20974 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20975 }
20976 arg4 = static_cast< wxEventType >(val4);
20977 }
20978 {
20979 PyThreadState* __tstate = wxPyBeginAllowThreads();
20980 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20981 wxPyEndAllowThreads(__tstate);
20982 if (PyErr_Occurred()) SWIG_fail;
20983 }
20984 {
20985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20986 }
20987 return resultobj;
20988 fail:
20989 return NULL;
20990 }
20991
20992
20993 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20994 PyObject *resultobj = 0;
20995 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20996 PyObject *arg2 = (PyObject *) 0 ;
20997 bool arg3 = (bool) true ;
20998 void *argp1 = 0 ;
20999 int res1 = 0 ;
21000 bool val3 ;
21001 int ecode3 = 0 ;
21002 PyObject * obj0 = 0 ;
21003 PyObject * obj1 = 0 ;
21004 PyObject * obj2 = 0 ;
21005 char * kwnames[] = {
21006 (char *) "self",(char *) "_self",(char *) "incref", NULL
21007 };
21008
21009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21011 if (!SWIG_IsOK(res1)) {
21012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21013 }
21014 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21015 arg2 = obj1;
21016 if (obj2) {
21017 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21018 if (!SWIG_IsOK(ecode3)) {
21019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21020 }
21021 arg3 = static_cast< bool >(val3);
21022 }
21023 {
21024 PyThreadState* __tstate = wxPyBeginAllowThreads();
21025 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21026 wxPyEndAllowThreads(__tstate);
21027 if (PyErr_Occurred()) SWIG_fail;
21028 }
21029 resultobj = SWIG_Py_Void();
21030 return resultobj;
21031 fail:
21032 return NULL;
21033 }
21034
21035
21036 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21037 PyObject *obj;
21038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21039 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21040 return SWIG_Py_Void();
21041 }
21042
21043 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21044 return SWIG_Python_InitShadowInstance(args);
21045 }
21046
21047 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21048 PyObject *resultobj = 0;
21049 wxEventType result;
21050
21051 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21052 {
21053 PyThreadState* __tstate = wxPyBeginAllowThreads();
21054 result = (wxEventType)wxNewEventType();
21055 wxPyEndAllowThreads(__tstate);
21056 if (PyErr_Occurred()) SWIG_fail;
21057 }
21058 resultobj = SWIG_From_int(static_cast< int >(result));
21059 return resultobj;
21060 fail:
21061 return NULL;
21062 }
21063
21064
21065 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21066 PyObject *resultobj = 0;
21067 wxEvent *arg1 = (wxEvent *) 0 ;
21068 void *argp1 = 0 ;
21069 int res1 = 0 ;
21070 PyObject *swig_obj[1] ;
21071
21072 if (!args) SWIG_fail;
21073 swig_obj[0] = args;
21074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21075 if (!SWIG_IsOK(res1)) {
21076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21077 }
21078 arg1 = reinterpret_cast< wxEvent * >(argp1);
21079 {
21080 PyThreadState* __tstate = wxPyBeginAllowThreads();
21081 delete arg1;
21082
21083 wxPyEndAllowThreads(__tstate);
21084 if (PyErr_Occurred()) SWIG_fail;
21085 }
21086 resultobj = SWIG_Py_Void();
21087 return resultobj;
21088 fail:
21089 return NULL;
21090 }
21091
21092
21093 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21094 PyObject *resultobj = 0;
21095 wxEvent *arg1 = (wxEvent *) 0 ;
21096 wxEventType arg2 ;
21097 void *argp1 = 0 ;
21098 int res1 = 0 ;
21099 int val2 ;
21100 int ecode2 = 0 ;
21101 PyObject * obj0 = 0 ;
21102 PyObject * obj1 = 0 ;
21103 char * kwnames[] = {
21104 (char *) "self",(char *) "typ", NULL
21105 };
21106
21107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21109 if (!SWIG_IsOK(res1)) {
21110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21111 }
21112 arg1 = reinterpret_cast< wxEvent * >(argp1);
21113 ecode2 = SWIG_AsVal_int(obj1, &val2);
21114 if (!SWIG_IsOK(ecode2)) {
21115 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21116 }
21117 arg2 = static_cast< wxEventType >(val2);
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 (arg1)->SetEventType(arg2);
21121 wxPyEndAllowThreads(__tstate);
21122 if (PyErr_Occurred()) SWIG_fail;
21123 }
21124 resultobj = SWIG_Py_Void();
21125 return resultobj;
21126 fail:
21127 return NULL;
21128 }
21129
21130
21131 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21132 PyObject *resultobj = 0;
21133 wxEvent *arg1 = (wxEvent *) 0 ;
21134 wxEventType result;
21135 void *argp1 = 0 ;
21136 int res1 = 0 ;
21137 PyObject *swig_obj[1] ;
21138
21139 if (!args) SWIG_fail;
21140 swig_obj[0] = args;
21141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21142 if (!SWIG_IsOK(res1)) {
21143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21144 }
21145 arg1 = reinterpret_cast< wxEvent * >(argp1);
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21149 wxPyEndAllowThreads(__tstate);
21150 if (PyErr_Occurred()) SWIG_fail;
21151 }
21152 resultobj = SWIG_From_int(static_cast< int >(result));
21153 return resultobj;
21154 fail:
21155 return NULL;
21156 }
21157
21158
21159 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21160 PyObject *resultobj = 0;
21161 wxEvent *arg1 = (wxEvent *) 0 ;
21162 wxObject *result = 0 ;
21163 void *argp1 = 0 ;
21164 int res1 = 0 ;
21165 PyObject *swig_obj[1] ;
21166
21167 if (!args) SWIG_fail;
21168 swig_obj[0] = args;
21169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21170 if (!SWIG_IsOK(res1)) {
21171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21172 }
21173 arg1 = reinterpret_cast< wxEvent * >(argp1);
21174 {
21175 PyThreadState* __tstate = wxPyBeginAllowThreads();
21176 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21177 wxPyEndAllowThreads(__tstate);
21178 if (PyErr_Occurred()) SWIG_fail;
21179 }
21180 {
21181 resultobj = wxPyMake_wxObject(result, (bool)0);
21182 }
21183 return resultobj;
21184 fail:
21185 return NULL;
21186 }
21187
21188
21189 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21190 PyObject *resultobj = 0;
21191 wxEvent *arg1 = (wxEvent *) 0 ;
21192 wxObject *arg2 = (wxObject *) 0 ;
21193 void *argp1 = 0 ;
21194 int res1 = 0 ;
21195 void *argp2 = 0 ;
21196 int res2 = 0 ;
21197 PyObject * obj0 = 0 ;
21198 PyObject * obj1 = 0 ;
21199 char * kwnames[] = {
21200 (char *) "self",(char *) "obj", NULL
21201 };
21202
21203 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21205 if (!SWIG_IsOK(res1)) {
21206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21207 }
21208 arg1 = reinterpret_cast< wxEvent * >(argp1);
21209 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21210 if (!SWIG_IsOK(res2)) {
21211 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21212 }
21213 arg2 = reinterpret_cast< wxObject * >(argp2);
21214 {
21215 PyThreadState* __tstate = wxPyBeginAllowThreads();
21216 (arg1)->SetEventObject(arg2);
21217 wxPyEndAllowThreads(__tstate);
21218 if (PyErr_Occurred()) SWIG_fail;
21219 }
21220 resultobj = SWIG_Py_Void();
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxEvent *arg1 = (wxEvent *) 0 ;
21230 long result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21240 }
21241 arg1 = reinterpret_cast< wxEvent * >(argp1);
21242 {
21243 PyThreadState* __tstate = wxPyBeginAllowThreads();
21244 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21245 wxPyEndAllowThreads(__tstate);
21246 if (PyErr_Occurred()) SWIG_fail;
21247 }
21248 resultobj = SWIG_From_long(static_cast< long >(result));
21249 return resultobj;
21250 fail:
21251 return NULL;
21252 }
21253
21254
21255 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21256 PyObject *resultobj = 0;
21257 wxEvent *arg1 = (wxEvent *) 0 ;
21258 long arg2 = (long) 0 ;
21259 void *argp1 = 0 ;
21260 int res1 = 0 ;
21261 long val2 ;
21262 int ecode2 = 0 ;
21263 PyObject * obj0 = 0 ;
21264 PyObject * obj1 = 0 ;
21265 char * kwnames[] = {
21266 (char *) "self",(char *) "ts", NULL
21267 };
21268
21269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21271 if (!SWIG_IsOK(res1)) {
21272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21273 }
21274 arg1 = reinterpret_cast< wxEvent * >(argp1);
21275 if (obj1) {
21276 ecode2 = SWIG_AsVal_long(obj1, &val2);
21277 if (!SWIG_IsOK(ecode2)) {
21278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21279 }
21280 arg2 = static_cast< long >(val2);
21281 }
21282 {
21283 PyThreadState* __tstate = wxPyBeginAllowThreads();
21284 (arg1)->SetTimestamp(arg2);
21285 wxPyEndAllowThreads(__tstate);
21286 if (PyErr_Occurred()) SWIG_fail;
21287 }
21288 resultobj = SWIG_Py_Void();
21289 return resultobj;
21290 fail:
21291 return NULL;
21292 }
21293
21294
21295 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21296 PyObject *resultobj = 0;
21297 wxEvent *arg1 = (wxEvent *) 0 ;
21298 int result;
21299 void *argp1 = 0 ;
21300 int res1 = 0 ;
21301 PyObject *swig_obj[1] ;
21302
21303 if (!args) SWIG_fail;
21304 swig_obj[0] = args;
21305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21306 if (!SWIG_IsOK(res1)) {
21307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21308 }
21309 arg1 = reinterpret_cast< wxEvent * >(argp1);
21310 {
21311 PyThreadState* __tstate = wxPyBeginAllowThreads();
21312 result = (int)((wxEvent const *)arg1)->GetId();
21313 wxPyEndAllowThreads(__tstate);
21314 if (PyErr_Occurred()) SWIG_fail;
21315 }
21316 resultobj = SWIG_From_int(static_cast< int >(result));
21317 return resultobj;
21318 fail:
21319 return NULL;
21320 }
21321
21322
21323 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21324 PyObject *resultobj = 0;
21325 wxEvent *arg1 = (wxEvent *) 0 ;
21326 int arg2 ;
21327 void *argp1 = 0 ;
21328 int res1 = 0 ;
21329 int val2 ;
21330 int ecode2 = 0 ;
21331 PyObject * obj0 = 0 ;
21332 PyObject * obj1 = 0 ;
21333 char * kwnames[] = {
21334 (char *) "self",(char *) "Id", NULL
21335 };
21336
21337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21339 if (!SWIG_IsOK(res1)) {
21340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21341 }
21342 arg1 = reinterpret_cast< wxEvent * >(argp1);
21343 ecode2 = SWIG_AsVal_int(obj1, &val2);
21344 if (!SWIG_IsOK(ecode2)) {
21345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21346 }
21347 arg2 = static_cast< int >(val2);
21348 {
21349 PyThreadState* __tstate = wxPyBeginAllowThreads();
21350 (arg1)->SetId(arg2);
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 resultobj = SWIG_Py_Void();
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21362 PyObject *resultobj = 0;
21363 wxEvent *arg1 = (wxEvent *) 0 ;
21364 bool result;
21365 void *argp1 = 0 ;
21366 int res1 = 0 ;
21367 PyObject *swig_obj[1] ;
21368
21369 if (!args) SWIG_fail;
21370 swig_obj[0] = args;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21374 }
21375 arg1 = reinterpret_cast< wxEvent * >(argp1);
21376 {
21377 PyThreadState* __tstate = wxPyBeginAllowThreads();
21378 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21379 wxPyEndAllowThreads(__tstate);
21380 if (PyErr_Occurred()) SWIG_fail;
21381 }
21382 {
21383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21384 }
21385 return resultobj;
21386 fail:
21387 return NULL;
21388 }
21389
21390
21391 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21392 PyObject *resultobj = 0;
21393 wxEvent *arg1 = (wxEvent *) 0 ;
21394 bool arg2 = (bool) true ;
21395 void *argp1 = 0 ;
21396 int res1 = 0 ;
21397 bool val2 ;
21398 int ecode2 = 0 ;
21399 PyObject * obj0 = 0 ;
21400 PyObject * obj1 = 0 ;
21401 char * kwnames[] = {
21402 (char *) "self",(char *) "skip", NULL
21403 };
21404
21405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21407 if (!SWIG_IsOK(res1)) {
21408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21409 }
21410 arg1 = reinterpret_cast< wxEvent * >(argp1);
21411 if (obj1) {
21412 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21413 if (!SWIG_IsOK(ecode2)) {
21414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21415 }
21416 arg2 = static_cast< bool >(val2);
21417 }
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 (arg1)->Skip(arg2);
21421 wxPyEndAllowThreads(__tstate);
21422 if (PyErr_Occurred()) SWIG_fail;
21423 }
21424 resultobj = SWIG_Py_Void();
21425 return resultobj;
21426 fail:
21427 return NULL;
21428 }
21429
21430
21431 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21432 PyObject *resultobj = 0;
21433 wxEvent *arg1 = (wxEvent *) 0 ;
21434 bool result;
21435 void *argp1 = 0 ;
21436 int res1 = 0 ;
21437 PyObject *swig_obj[1] ;
21438
21439 if (!args) SWIG_fail;
21440 swig_obj[0] = args;
21441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21442 if (!SWIG_IsOK(res1)) {
21443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21444 }
21445 arg1 = reinterpret_cast< wxEvent * >(argp1);
21446 {
21447 PyThreadState* __tstate = wxPyBeginAllowThreads();
21448 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21449 wxPyEndAllowThreads(__tstate);
21450 if (PyErr_Occurred()) SWIG_fail;
21451 }
21452 {
21453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21454 }
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(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_ShouldPropagate" "', 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)->ShouldPropagate();
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_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21492 PyObject *resultobj = 0;
21493 wxEvent *arg1 = (wxEvent *) 0 ;
21494 int result;
21495 void *argp1 = 0 ;
21496 int res1 = 0 ;
21497 PyObject *swig_obj[1] ;
21498
21499 if (!args) SWIG_fail;
21500 swig_obj[0] = args;
21501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21502 if (!SWIG_IsOK(res1)) {
21503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21504 }
21505 arg1 = reinterpret_cast< wxEvent * >(argp1);
21506 {
21507 PyThreadState* __tstate = wxPyBeginAllowThreads();
21508 result = (int)(arg1)->StopPropagation();
21509 wxPyEndAllowThreads(__tstate);
21510 if (PyErr_Occurred()) SWIG_fail;
21511 }
21512 resultobj = SWIG_From_int(static_cast< int >(result));
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21520 PyObject *resultobj = 0;
21521 wxEvent *arg1 = (wxEvent *) 0 ;
21522 int arg2 ;
21523 void *argp1 = 0 ;
21524 int res1 = 0 ;
21525 int val2 ;
21526 int ecode2 = 0 ;
21527 PyObject * obj0 = 0 ;
21528 PyObject * obj1 = 0 ;
21529 char * kwnames[] = {
21530 (char *) "self",(char *) "propagationLevel", NULL
21531 };
21532
21533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21537 }
21538 arg1 = reinterpret_cast< wxEvent * >(argp1);
21539 ecode2 = SWIG_AsVal_int(obj1, &val2);
21540 if (!SWIG_IsOK(ecode2)) {
21541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21542 }
21543 arg2 = static_cast< int >(val2);
21544 {
21545 PyThreadState* __tstate = wxPyBeginAllowThreads();
21546 (arg1)->ResumePropagation(arg2);
21547 wxPyEndAllowThreads(__tstate);
21548 if (PyErr_Occurred()) SWIG_fail;
21549 }
21550 resultobj = SWIG_Py_Void();
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxEvent *arg1 = (wxEvent *) 0 ;
21560 wxEvent *result = 0 ;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxEvent * >(argp1);
21572 {
21573 PyThreadState* __tstate = wxPyBeginAllowThreads();
21574 result = (wxEvent *)(arg1)->Clone();
21575 wxPyEndAllowThreads(__tstate);
21576 if (PyErr_Occurred()) SWIG_fail;
21577 }
21578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21579 return resultobj;
21580 fail:
21581 return NULL;
21582 }
21583
21584
21585 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21586 PyObject *obj;
21587 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21588 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21589 return SWIG_Py_Void();
21590 }
21591
21592 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj = 0;
21594 wxEvent *arg1 = 0 ;
21595 wxPropagationDisabler *result = 0 ;
21596 void *argp1 = 0 ;
21597 int res1 = 0 ;
21598 PyObject * obj0 = 0 ;
21599 char * kwnames[] = {
21600 (char *) "event", NULL
21601 };
21602
21603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21604 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21605 if (!SWIG_IsOK(res1)) {
21606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21607 }
21608 if (!argp1) {
21609 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21610 }
21611 arg1 = reinterpret_cast< wxEvent * >(argp1);
21612 {
21613 PyThreadState* __tstate = wxPyBeginAllowThreads();
21614 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21615 wxPyEndAllowThreads(__tstate);
21616 if (PyErr_Occurred()) SWIG_fail;
21617 }
21618 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21619 return resultobj;
21620 fail:
21621 return NULL;
21622 }
21623
21624
21625 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21626 PyObject *resultobj = 0;
21627 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21628 void *argp1 = 0 ;
21629 int res1 = 0 ;
21630 PyObject *swig_obj[1] ;
21631
21632 if (!args) SWIG_fail;
21633 swig_obj[0] = args;
21634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21635 if (!SWIG_IsOK(res1)) {
21636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21637 }
21638 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21639 {
21640 PyThreadState* __tstate = wxPyBeginAllowThreads();
21641 delete arg1;
21642
21643 wxPyEndAllowThreads(__tstate);
21644 if (PyErr_Occurred()) SWIG_fail;
21645 }
21646 resultobj = SWIG_Py_Void();
21647 return resultobj;
21648 fail:
21649 return NULL;
21650 }
21651
21652
21653 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21654 PyObject *obj;
21655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21656 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21657 return SWIG_Py_Void();
21658 }
21659
21660 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21661 return SWIG_Python_InitShadowInstance(args);
21662 }
21663
21664 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21665 PyObject *resultobj = 0;
21666 wxEvent *arg1 = 0 ;
21667 wxPropagateOnce *result = 0 ;
21668 void *argp1 = 0 ;
21669 int res1 = 0 ;
21670 PyObject * obj0 = 0 ;
21671 char * kwnames[] = {
21672 (char *) "event", NULL
21673 };
21674
21675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21676 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21677 if (!SWIG_IsOK(res1)) {
21678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21679 }
21680 if (!argp1) {
21681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21682 }
21683 arg1 = reinterpret_cast< wxEvent * >(argp1);
21684 {
21685 PyThreadState* __tstate = wxPyBeginAllowThreads();
21686 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21687 wxPyEndAllowThreads(__tstate);
21688 if (PyErr_Occurred()) SWIG_fail;
21689 }
21690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21691 return resultobj;
21692 fail:
21693 return NULL;
21694 }
21695
21696
21697 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21698 PyObject *resultobj = 0;
21699 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21700 void *argp1 = 0 ;
21701 int res1 = 0 ;
21702 PyObject *swig_obj[1] ;
21703
21704 if (!args) SWIG_fail;
21705 swig_obj[0] = args;
21706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21707 if (!SWIG_IsOK(res1)) {
21708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21709 }
21710 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21711 {
21712 PyThreadState* __tstate = wxPyBeginAllowThreads();
21713 delete arg1;
21714
21715 wxPyEndAllowThreads(__tstate);
21716 if (PyErr_Occurred()) SWIG_fail;
21717 }
21718 resultobj = SWIG_Py_Void();
21719 return resultobj;
21720 fail:
21721 return NULL;
21722 }
21723
21724
21725 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21726 PyObject *obj;
21727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21728 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21729 return SWIG_Py_Void();
21730 }
21731
21732 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21733 return SWIG_Python_InitShadowInstance(args);
21734 }
21735
21736 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21737 PyObject *resultobj = 0;
21738 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21739 int arg2 = (int) 0 ;
21740 wxCommandEvent *result = 0 ;
21741 int val1 ;
21742 int ecode1 = 0 ;
21743 int val2 ;
21744 int ecode2 = 0 ;
21745 PyObject * obj0 = 0 ;
21746 PyObject * obj1 = 0 ;
21747 char * kwnames[] = {
21748 (char *) "commandType",(char *) "winid", NULL
21749 };
21750
21751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21752 if (obj0) {
21753 ecode1 = SWIG_AsVal_int(obj0, &val1);
21754 if (!SWIG_IsOK(ecode1)) {
21755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21756 }
21757 arg1 = static_cast< wxEventType >(val1);
21758 }
21759 if (obj1) {
21760 ecode2 = SWIG_AsVal_int(obj1, &val2);
21761 if (!SWIG_IsOK(ecode2)) {
21762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21763 }
21764 arg2 = static_cast< int >(val2);
21765 }
21766 {
21767 PyThreadState* __tstate = wxPyBeginAllowThreads();
21768 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21769 wxPyEndAllowThreads(__tstate);
21770 if (PyErr_Occurred()) SWIG_fail;
21771 }
21772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21773 return resultobj;
21774 fail:
21775 return NULL;
21776 }
21777
21778
21779 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21780 PyObject *resultobj = 0;
21781 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21782 int result;
21783 void *argp1 = 0 ;
21784 int res1 = 0 ;
21785 PyObject *swig_obj[1] ;
21786
21787 if (!args) SWIG_fail;
21788 swig_obj[0] = args;
21789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21790 if (!SWIG_IsOK(res1)) {
21791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21792 }
21793 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21794 {
21795 PyThreadState* __tstate = wxPyBeginAllowThreads();
21796 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21797 wxPyEndAllowThreads(__tstate);
21798 if (PyErr_Occurred()) SWIG_fail;
21799 }
21800 resultobj = SWIG_From_int(static_cast< int >(result));
21801 return resultobj;
21802 fail:
21803 return NULL;
21804 }
21805
21806
21807 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21808 PyObject *resultobj = 0;
21809 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21810 wxString *arg2 = 0 ;
21811 void *argp1 = 0 ;
21812 int res1 = 0 ;
21813 bool temp2 = false ;
21814 PyObject * obj0 = 0 ;
21815 PyObject * obj1 = 0 ;
21816 char * kwnames[] = {
21817 (char *) "self",(char *) "s", NULL
21818 };
21819
21820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21822 if (!SWIG_IsOK(res1)) {
21823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21824 }
21825 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21826 {
21827 arg2 = wxString_in_helper(obj1);
21828 if (arg2 == NULL) SWIG_fail;
21829 temp2 = true;
21830 }
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->SetString((wxString const &)*arg2);
21834 wxPyEndAllowThreads(__tstate);
21835 if (PyErr_Occurred()) SWIG_fail;
21836 }
21837 resultobj = SWIG_Py_Void();
21838 {
21839 if (temp2)
21840 delete arg2;
21841 }
21842 return resultobj;
21843 fail:
21844 {
21845 if (temp2)
21846 delete arg2;
21847 }
21848 return NULL;
21849 }
21850
21851
21852 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21853 PyObject *resultobj = 0;
21854 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21855 wxString result;
21856 void *argp1 = 0 ;
21857 int res1 = 0 ;
21858 PyObject *swig_obj[1] ;
21859
21860 if (!args) SWIG_fail;
21861 swig_obj[0] = args;
21862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21863 if (!SWIG_IsOK(res1)) {
21864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21865 }
21866 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21867 {
21868 PyThreadState* __tstate = wxPyBeginAllowThreads();
21869 result = ((wxCommandEvent const *)arg1)->GetString();
21870 wxPyEndAllowThreads(__tstate);
21871 if (PyErr_Occurred()) SWIG_fail;
21872 }
21873 {
21874 #if wxUSE_UNICODE
21875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21876 #else
21877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21878 #endif
21879 }
21880 return resultobj;
21881 fail:
21882 return NULL;
21883 }
21884
21885
21886 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21887 PyObject *resultobj = 0;
21888 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21889 bool result;
21890 void *argp1 = 0 ;
21891 int res1 = 0 ;
21892 PyObject *swig_obj[1] ;
21893
21894 if (!args) SWIG_fail;
21895 swig_obj[0] = args;
21896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21897 if (!SWIG_IsOK(res1)) {
21898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21899 }
21900 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21901 {
21902 PyThreadState* __tstate = wxPyBeginAllowThreads();
21903 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21904 wxPyEndAllowThreads(__tstate);
21905 if (PyErr_Occurred()) SWIG_fail;
21906 }
21907 {
21908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21909 }
21910 return resultobj;
21911 fail:
21912 return NULL;
21913 }
21914
21915
21916 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21917 PyObject *resultobj = 0;
21918 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21919 bool result;
21920 void *argp1 = 0 ;
21921 int res1 = 0 ;
21922 PyObject *swig_obj[1] ;
21923
21924 if (!args) SWIG_fail;
21925 swig_obj[0] = args;
21926 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21927 if (!SWIG_IsOK(res1)) {
21928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21929 }
21930 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21931 {
21932 PyThreadState* __tstate = wxPyBeginAllowThreads();
21933 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 {
21938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21939 }
21940 return resultobj;
21941 fail:
21942 return NULL;
21943 }
21944
21945
21946 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21947 PyObject *resultobj = 0;
21948 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21949 long arg2 ;
21950 void *argp1 = 0 ;
21951 int res1 = 0 ;
21952 long val2 ;
21953 int ecode2 = 0 ;
21954 PyObject * obj0 = 0 ;
21955 PyObject * obj1 = 0 ;
21956 char * kwnames[] = {
21957 (char *) "self",(char *) "extraLong", NULL
21958 };
21959
21960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21962 if (!SWIG_IsOK(res1)) {
21963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21964 }
21965 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21966 ecode2 = SWIG_AsVal_long(obj1, &val2);
21967 if (!SWIG_IsOK(ecode2)) {
21968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21969 }
21970 arg2 = static_cast< long >(val2);
21971 {
21972 PyThreadState* __tstate = wxPyBeginAllowThreads();
21973 (arg1)->SetExtraLong(arg2);
21974 wxPyEndAllowThreads(__tstate);
21975 if (PyErr_Occurred()) SWIG_fail;
21976 }
21977 resultobj = SWIG_Py_Void();
21978 return resultobj;
21979 fail:
21980 return NULL;
21981 }
21982
21983
21984 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21985 PyObject *resultobj = 0;
21986 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21987 long result;
21988 void *argp1 = 0 ;
21989 int res1 = 0 ;
21990 PyObject *swig_obj[1] ;
21991
21992 if (!args) SWIG_fail;
21993 swig_obj[0] = args;
21994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21995 if (!SWIG_IsOK(res1)) {
21996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21997 }
21998 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21999 {
22000 PyThreadState* __tstate = wxPyBeginAllowThreads();
22001 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22002 wxPyEndAllowThreads(__tstate);
22003 if (PyErr_Occurred()) SWIG_fail;
22004 }
22005 resultobj = SWIG_From_long(static_cast< long >(result));
22006 return resultobj;
22007 fail:
22008 return NULL;
22009 }
22010
22011
22012 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22013 PyObject *resultobj = 0;
22014 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22015 int arg2 ;
22016 void *argp1 = 0 ;
22017 int res1 = 0 ;
22018 int val2 ;
22019 int ecode2 = 0 ;
22020 PyObject * obj0 = 0 ;
22021 PyObject * obj1 = 0 ;
22022 char * kwnames[] = {
22023 (char *) "self",(char *) "i", NULL
22024 };
22025
22026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22028 if (!SWIG_IsOK(res1)) {
22029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22030 }
22031 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22032 ecode2 = SWIG_AsVal_int(obj1, &val2);
22033 if (!SWIG_IsOK(ecode2)) {
22034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22035 }
22036 arg2 = static_cast< int >(val2);
22037 {
22038 PyThreadState* __tstate = wxPyBeginAllowThreads();
22039 (arg1)->SetInt(arg2);
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 resultobj = SWIG_Py_Void();
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22051 PyObject *resultobj = 0;
22052 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22053 int result;
22054 void *argp1 = 0 ;
22055 int res1 = 0 ;
22056 PyObject *swig_obj[1] ;
22057
22058 if (!args) SWIG_fail;
22059 swig_obj[0] = args;
22060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22061 if (!SWIG_IsOK(res1)) {
22062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22063 }
22064 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22065 {
22066 PyThreadState* __tstate = wxPyBeginAllowThreads();
22067 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22068 wxPyEndAllowThreads(__tstate);
22069 if (PyErr_Occurred()) SWIG_fail;
22070 }
22071 resultobj = SWIG_From_int(static_cast< int >(result));
22072 return resultobj;
22073 fail:
22074 return NULL;
22075 }
22076
22077
22078 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22079 PyObject *resultobj = 0;
22080 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22081 PyObject *result = 0 ;
22082 void *argp1 = 0 ;
22083 int res1 = 0 ;
22084 PyObject *swig_obj[1] ;
22085
22086 if (!args) SWIG_fail;
22087 swig_obj[0] = args;
22088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22089 if (!SWIG_IsOK(res1)) {
22090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22091 }
22092 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22093 {
22094 PyThreadState* __tstate = wxPyBeginAllowThreads();
22095 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22096 wxPyEndAllowThreads(__tstate);
22097 if (PyErr_Occurred()) SWIG_fail;
22098 }
22099 resultobj = result;
22100 return resultobj;
22101 fail:
22102 return NULL;
22103 }
22104
22105
22106 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22107 PyObject *resultobj = 0;
22108 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22109 PyObject *arg2 = (PyObject *) 0 ;
22110 void *argp1 = 0 ;
22111 int res1 = 0 ;
22112 PyObject * obj0 = 0 ;
22113 PyObject * obj1 = 0 ;
22114 char * kwnames[] = {
22115 (char *) "self",(char *) "clientData", NULL
22116 };
22117
22118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22120 if (!SWIG_IsOK(res1)) {
22121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22122 }
22123 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22124 arg2 = obj1;
22125 {
22126 PyThreadState* __tstate = wxPyBeginAllowThreads();
22127 wxCommandEvent_SetClientData(arg1,arg2);
22128 wxPyEndAllowThreads(__tstate);
22129 if (PyErr_Occurred()) SWIG_fail;
22130 }
22131 resultobj = SWIG_Py_Void();
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22139 PyObject *resultobj = 0;
22140 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22141 wxEvent *result = 0 ;
22142 void *argp1 = 0 ;
22143 int res1 = 0 ;
22144 PyObject *swig_obj[1] ;
22145
22146 if (!args) SWIG_fail;
22147 swig_obj[0] = args;
22148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22149 if (!SWIG_IsOK(res1)) {
22150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22151 }
22152 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22153 {
22154 PyThreadState* __tstate = wxPyBeginAllowThreads();
22155 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22156 wxPyEndAllowThreads(__tstate);
22157 if (PyErr_Occurred()) SWIG_fail;
22158 }
22159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22160 return resultobj;
22161 fail:
22162 return NULL;
22163 }
22164
22165
22166 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22167 PyObject *obj;
22168 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22169 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22170 return SWIG_Py_Void();
22171 }
22172
22173 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22174 return SWIG_Python_InitShadowInstance(args);
22175 }
22176
22177 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj = 0;
22179 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22180 int arg2 = (int) 0 ;
22181 wxNotifyEvent *result = 0 ;
22182 int val1 ;
22183 int ecode1 = 0 ;
22184 int val2 ;
22185 int ecode2 = 0 ;
22186 PyObject * obj0 = 0 ;
22187 PyObject * obj1 = 0 ;
22188 char * kwnames[] = {
22189 (char *) "commandType",(char *) "winid", NULL
22190 };
22191
22192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22193 if (obj0) {
22194 ecode1 = SWIG_AsVal_int(obj0, &val1);
22195 if (!SWIG_IsOK(ecode1)) {
22196 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22197 }
22198 arg1 = static_cast< wxEventType >(val1);
22199 }
22200 if (obj1) {
22201 ecode2 = SWIG_AsVal_int(obj1, &val2);
22202 if (!SWIG_IsOK(ecode2)) {
22203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22204 }
22205 arg2 = static_cast< int >(val2);
22206 }
22207 {
22208 PyThreadState* __tstate = wxPyBeginAllowThreads();
22209 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22210 wxPyEndAllowThreads(__tstate);
22211 if (PyErr_Occurred()) SWIG_fail;
22212 }
22213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22214 return resultobj;
22215 fail:
22216 return NULL;
22217 }
22218
22219
22220 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22221 PyObject *resultobj = 0;
22222 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22223 void *argp1 = 0 ;
22224 int res1 = 0 ;
22225 PyObject *swig_obj[1] ;
22226
22227 if (!args) SWIG_fail;
22228 swig_obj[0] = args;
22229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22230 if (!SWIG_IsOK(res1)) {
22231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22232 }
22233 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22234 {
22235 PyThreadState* __tstate = wxPyBeginAllowThreads();
22236 (arg1)->Veto();
22237 wxPyEndAllowThreads(__tstate);
22238 if (PyErr_Occurred()) SWIG_fail;
22239 }
22240 resultobj = SWIG_Py_Void();
22241 return resultobj;
22242 fail:
22243 return NULL;
22244 }
22245
22246
22247 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22248 PyObject *resultobj = 0;
22249 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22250 void *argp1 = 0 ;
22251 int res1 = 0 ;
22252 PyObject *swig_obj[1] ;
22253
22254 if (!args) SWIG_fail;
22255 swig_obj[0] = args;
22256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22257 if (!SWIG_IsOK(res1)) {
22258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22259 }
22260 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22261 {
22262 PyThreadState* __tstate = wxPyBeginAllowThreads();
22263 (arg1)->Allow();
22264 wxPyEndAllowThreads(__tstate);
22265 if (PyErr_Occurred()) SWIG_fail;
22266 }
22267 resultobj = SWIG_Py_Void();
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22275 PyObject *resultobj = 0;
22276 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22277 bool result;
22278 void *argp1 = 0 ;
22279 int res1 = 0 ;
22280 PyObject *swig_obj[1] ;
22281
22282 if (!args) SWIG_fail;
22283 swig_obj[0] = args;
22284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22285 if (!SWIG_IsOK(res1)) {
22286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22287 }
22288 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22289 {
22290 PyThreadState* __tstate = wxPyBeginAllowThreads();
22291 result = (bool)(arg1)->IsAllowed();
22292 wxPyEndAllowThreads(__tstate);
22293 if (PyErr_Occurred()) SWIG_fail;
22294 }
22295 {
22296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22297 }
22298 return resultobj;
22299 fail:
22300 return NULL;
22301 }
22302
22303
22304 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22305 PyObject *obj;
22306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22307 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22308 return SWIG_Py_Void();
22309 }
22310
22311 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 return SWIG_Python_InitShadowInstance(args);
22313 }
22314
22315 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22316 PyObject *resultobj = 0;
22317 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22318 int arg2 = (int) 0 ;
22319 int arg3 = (int) 0 ;
22320 int arg4 = (int) 0 ;
22321 wxScrollEvent *result = 0 ;
22322 int val1 ;
22323 int ecode1 = 0 ;
22324 int val2 ;
22325 int ecode2 = 0 ;
22326 int val3 ;
22327 int ecode3 = 0 ;
22328 int val4 ;
22329 int ecode4 = 0 ;
22330 PyObject * obj0 = 0 ;
22331 PyObject * obj1 = 0 ;
22332 PyObject * obj2 = 0 ;
22333 PyObject * obj3 = 0 ;
22334 char * kwnames[] = {
22335 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22336 };
22337
22338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22339 if (obj0) {
22340 ecode1 = SWIG_AsVal_int(obj0, &val1);
22341 if (!SWIG_IsOK(ecode1)) {
22342 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22343 }
22344 arg1 = static_cast< wxEventType >(val1);
22345 }
22346 if (obj1) {
22347 ecode2 = SWIG_AsVal_int(obj1, &val2);
22348 if (!SWIG_IsOK(ecode2)) {
22349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22350 }
22351 arg2 = static_cast< int >(val2);
22352 }
22353 if (obj2) {
22354 ecode3 = SWIG_AsVal_int(obj2, &val3);
22355 if (!SWIG_IsOK(ecode3)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22357 }
22358 arg3 = static_cast< int >(val3);
22359 }
22360 if (obj3) {
22361 ecode4 = SWIG_AsVal_int(obj3, &val4);
22362 if (!SWIG_IsOK(ecode4)) {
22363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22364 }
22365 arg4 = static_cast< int >(val4);
22366 }
22367 {
22368 PyThreadState* __tstate = wxPyBeginAllowThreads();
22369 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22370 wxPyEndAllowThreads(__tstate);
22371 if (PyErr_Occurred()) SWIG_fail;
22372 }
22373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22374 return resultobj;
22375 fail:
22376 return NULL;
22377 }
22378
22379
22380 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22381 PyObject *resultobj = 0;
22382 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22383 int result;
22384 void *argp1 = 0 ;
22385 int res1 = 0 ;
22386 PyObject *swig_obj[1] ;
22387
22388 if (!args) SWIG_fail;
22389 swig_obj[0] = args;
22390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22391 if (!SWIG_IsOK(res1)) {
22392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22393 }
22394 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22395 {
22396 PyThreadState* __tstate = wxPyBeginAllowThreads();
22397 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22398 wxPyEndAllowThreads(__tstate);
22399 if (PyErr_Occurred()) SWIG_fail;
22400 }
22401 resultobj = SWIG_From_int(static_cast< int >(result));
22402 return resultobj;
22403 fail:
22404 return NULL;
22405 }
22406
22407
22408 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22409 PyObject *resultobj = 0;
22410 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22411 int result;
22412 void *argp1 = 0 ;
22413 int res1 = 0 ;
22414 PyObject *swig_obj[1] ;
22415
22416 if (!args) SWIG_fail;
22417 swig_obj[0] = args;
22418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22419 if (!SWIG_IsOK(res1)) {
22420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22421 }
22422 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22423 {
22424 PyThreadState* __tstate = wxPyBeginAllowThreads();
22425 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22426 wxPyEndAllowThreads(__tstate);
22427 if (PyErr_Occurred()) SWIG_fail;
22428 }
22429 resultobj = SWIG_From_int(static_cast< int >(result));
22430 return resultobj;
22431 fail:
22432 return NULL;
22433 }
22434
22435
22436 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22437 PyObject *resultobj = 0;
22438 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22439 int arg2 ;
22440 void *argp1 = 0 ;
22441 int res1 = 0 ;
22442 int val2 ;
22443 int ecode2 = 0 ;
22444 PyObject * obj0 = 0 ;
22445 PyObject * obj1 = 0 ;
22446 char * kwnames[] = {
22447 (char *) "self",(char *) "orient", NULL
22448 };
22449
22450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22452 if (!SWIG_IsOK(res1)) {
22453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22454 }
22455 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22456 ecode2 = SWIG_AsVal_int(obj1, &val2);
22457 if (!SWIG_IsOK(ecode2)) {
22458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22459 }
22460 arg2 = static_cast< int >(val2);
22461 {
22462 PyThreadState* __tstate = wxPyBeginAllowThreads();
22463 (arg1)->SetOrientation(arg2);
22464 wxPyEndAllowThreads(__tstate);
22465 if (PyErr_Occurred()) SWIG_fail;
22466 }
22467 resultobj = SWIG_Py_Void();
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22475 PyObject *resultobj = 0;
22476 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22477 int arg2 ;
22478 void *argp1 = 0 ;
22479 int res1 = 0 ;
22480 int val2 ;
22481 int ecode2 = 0 ;
22482 PyObject * obj0 = 0 ;
22483 PyObject * obj1 = 0 ;
22484 char * kwnames[] = {
22485 (char *) "self",(char *) "pos", NULL
22486 };
22487
22488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22490 if (!SWIG_IsOK(res1)) {
22491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22492 }
22493 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22494 ecode2 = SWIG_AsVal_int(obj1, &val2);
22495 if (!SWIG_IsOK(ecode2)) {
22496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22497 }
22498 arg2 = static_cast< int >(val2);
22499 {
22500 PyThreadState* __tstate = wxPyBeginAllowThreads();
22501 (arg1)->SetPosition(arg2);
22502 wxPyEndAllowThreads(__tstate);
22503 if (PyErr_Occurred()) SWIG_fail;
22504 }
22505 resultobj = SWIG_Py_Void();
22506 return resultobj;
22507 fail:
22508 return NULL;
22509 }
22510
22511
22512 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22513 PyObject *obj;
22514 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22515 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22516 return SWIG_Py_Void();
22517 }
22518
22519 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22520 return SWIG_Python_InitShadowInstance(args);
22521 }
22522
22523 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22524 PyObject *resultobj = 0;
22525 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22526 int arg2 = (int) 0 ;
22527 int arg3 = (int) 0 ;
22528 wxScrollWinEvent *result = 0 ;
22529 int val1 ;
22530 int ecode1 = 0 ;
22531 int val2 ;
22532 int ecode2 = 0 ;
22533 int val3 ;
22534 int ecode3 = 0 ;
22535 PyObject * obj0 = 0 ;
22536 PyObject * obj1 = 0 ;
22537 PyObject * obj2 = 0 ;
22538 char * kwnames[] = {
22539 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22540 };
22541
22542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22543 if (obj0) {
22544 ecode1 = SWIG_AsVal_int(obj0, &val1);
22545 if (!SWIG_IsOK(ecode1)) {
22546 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22547 }
22548 arg1 = static_cast< wxEventType >(val1);
22549 }
22550 if (obj1) {
22551 ecode2 = SWIG_AsVal_int(obj1, &val2);
22552 if (!SWIG_IsOK(ecode2)) {
22553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22554 }
22555 arg2 = static_cast< int >(val2);
22556 }
22557 if (obj2) {
22558 ecode3 = SWIG_AsVal_int(obj2, &val3);
22559 if (!SWIG_IsOK(ecode3)) {
22560 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22561 }
22562 arg3 = static_cast< int >(val3);
22563 }
22564 {
22565 PyThreadState* __tstate = wxPyBeginAllowThreads();
22566 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22567 wxPyEndAllowThreads(__tstate);
22568 if (PyErr_Occurred()) SWIG_fail;
22569 }
22570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22571 return resultobj;
22572 fail:
22573 return NULL;
22574 }
22575
22576
22577 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22578 PyObject *resultobj = 0;
22579 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22580 int result;
22581 void *argp1 = 0 ;
22582 int res1 = 0 ;
22583 PyObject *swig_obj[1] ;
22584
22585 if (!args) SWIG_fail;
22586 swig_obj[0] = args;
22587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22588 if (!SWIG_IsOK(res1)) {
22589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22590 }
22591 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22592 {
22593 PyThreadState* __tstate = wxPyBeginAllowThreads();
22594 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22595 wxPyEndAllowThreads(__tstate);
22596 if (PyErr_Occurred()) SWIG_fail;
22597 }
22598 resultobj = SWIG_From_int(static_cast< int >(result));
22599 return resultobj;
22600 fail:
22601 return NULL;
22602 }
22603
22604
22605 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22606 PyObject *resultobj = 0;
22607 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22608 int result;
22609 void *argp1 = 0 ;
22610 int res1 = 0 ;
22611 PyObject *swig_obj[1] ;
22612
22613 if (!args) SWIG_fail;
22614 swig_obj[0] = args;
22615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22616 if (!SWIG_IsOK(res1)) {
22617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22618 }
22619 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22620 {
22621 PyThreadState* __tstate = wxPyBeginAllowThreads();
22622 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_From_int(static_cast< int >(result));
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj = 0;
22635 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22636 int arg2 ;
22637 void *argp1 = 0 ;
22638 int res1 = 0 ;
22639 int val2 ;
22640 int ecode2 = 0 ;
22641 PyObject * obj0 = 0 ;
22642 PyObject * obj1 = 0 ;
22643 char * kwnames[] = {
22644 (char *) "self",(char *) "orient", NULL
22645 };
22646
22647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22649 if (!SWIG_IsOK(res1)) {
22650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22651 }
22652 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22653 ecode2 = SWIG_AsVal_int(obj1, &val2);
22654 if (!SWIG_IsOK(ecode2)) {
22655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22656 }
22657 arg2 = static_cast< int >(val2);
22658 {
22659 PyThreadState* __tstate = wxPyBeginAllowThreads();
22660 (arg1)->SetOrientation(arg2);
22661 wxPyEndAllowThreads(__tstate);
22662 if (PyErr_Occurred()) SWIG_fail;
22663 }
22664 resultobj = SWIG_Py_Void();
22665 return resultobj;
22666 fail:
22667 return NULL;
22668 }
22669
22670
22671 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22672 PyObject *resultobj = 0;
22673 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22674 int arg2 ;
22675 void *argp1 = 0 ;
22676 int res1 = 0 ;
22677 int val2 ;
22678 int ecode2 = 0 ;
22679 PyObject * obj0 = 0 ;
22680 PyObject * obj1 = 0 ;
22681 char * kwnames[] = {
22682 (char *) "self",(char *) "pos", NULL
22683 };
22684
22685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22687 if (!SWIG_IsOK(res1)) {
22688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22689 }
22690 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22691 ecode2 = SWIG_AsVal_int(obj1, &val2);
22692 if (!SWIG_IsOK(ecode2)) {
22693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22694 }
22695 arg2 = static_cast< int >(val2);
22696 {
22697 PyThreadState* __tstate = wxPyBeginAllowThreads();
22698 (arg1)->SetPosition(arg2);
22699 wxPyEndAllowThreads(__tstate);
22700 if (PyErr_Occurred()) SWIG_fail;
22701 }
22702 resultobj = SWIG_Py_Void();
22703 return resultobj;
22704 fail:
22705 return NULL;
22706 }
22707
22708
22709 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22710 PyObject *obj;
22711 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22712 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22713 return SWIG_Py_Void();
22714 }
22715
22716 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22717 return SWIG_Python_InitShadowInstance(args);
22718 }
22719
22720 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22721 PyObject *resultobj = 0;
22722 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22723 wxMouseEvent *result = 0 ;
22724 int val1 ;
22725 int ecode1 = 0 ;
22726 PyObject * obj0 = 0 ;
22727 char * kwnames[] = {
22728 (char *) "mouseType", NULL
22729 };
22730
22731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22732 if (obj0) {
22733 ecode1 = SWIG_AsVal_int(obj0, &val1);
22734 if (!SWIG_IsOK(ecode1)) {
22735 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22736 }
22737 arg1 = static_cast< wxEventType >(val1);
22738 }
22739 {
22740 PyThreadState* __tstate = wxPyBeginAllowThreads();
22741 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22742 wxPyEndAllowThreads(__tstate);
22743 if (PyErr_Occurred()) SWIG_fail;
22744 }
22745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22746 return resultobj;
22747 fail:
22748 return NULL;
22749 }
22750
22751
22752 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22753 PyObject *resultobj = 0;
22754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22755 bool result;
22756 void *argp1 = 0 ;
22757 int res1 = 0 ;
22758 PyObject *swig_obj[1] ;
22759
22760 if (!args) SWIG_fail;
22761 swig_obj[0] = args;
22762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22763 if (!SWIG_IsOK(res1)) {
22764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22765 }
22766 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22767 {
22768 PyThreadState* __tstate = wxPyBeginAllowThreads();
22769 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22770 wxPyEndAllowThreads(__tstate);
22771 if (PyErr_Occurred()) SWIG_fail;
22772 }
22773 {
22774 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22775 }
22776 return resultobj;
22777 fail:
22778 return NULL;
22779 }
22780
22781
22782 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22783 PyObject *resultobj = 0;
22784 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22785 int arg2 = (int) wxMOUSE_BTN_ANY ;
22786 bool result;
22787 void *argp1 = 0 ;
22788 int res1 = 0 ;
22789 int val2 ;
22790 int ecode2 = 0 ;
22791 PyObject * obj0 = 0 ;
22792 PyObject * obj1 = 0 ;
22793 char * kwnames[] = {
22794 (char *) "self",(char *) "but", NULL
22795 };
22796
22797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22799 if (!SWIG_IsOK(res1)) {
22800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22801 }
22802 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22803 if (obj1) {
22804 ecode2 = SWIG_AsVal_int(obj1, &val2);
22805 if (!SWIG_IsOK(ecode2)) {
22806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22807 }
22808 arg2 = static_cast< int >(val2);
22809 }
22810 {
22811 PyThreadState* __tstate = wxPyBeginAllowThreads();
22812 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22813 wxPyEndAllowThreads(__tstate);
22814 if (PyErr_Occurred()) SWIG_fail;
22815 }
22816 {
22817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22818 }
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22826 PyObject *resultobj = 0;
22827 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22828 int arg2 = (int) wxMOUSE_BTN_ANY ;
22829 bool result;
22830 void *argp1 = 0 ;
22831 int res1 = 0 ;
22832 int val2 ;
22833 int ecode2 = 0 ;
22834 PyObject * obj0 = 0 ;
22835 PyObject * obj1 = 0 ;
22836 char * kwnames[] = {
22837 (char *) "self",(char *) "but", NULL
22838 };
22839
22840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22842 if (!SWIG_IsOK(res1)) {
22843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22844 }
22845 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22846 if (obj1) {
22847 ecode2 = SWIG_AsVal_int(obj1, &val2);
22848 if (!SWIG_IsOK(ecode2)) {
22849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22850 }
22851 arg2 = static_cast< int >(val2);
22852 }
22853 {
22854 PyThreadState* __tstate = wxPyBeginAllowThreads();
22855 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22856 wxPyEndAllowThreads(__tstate);
22857 if (PyErr_Occurred()) SWIG_fail;
22858 }
22859 {
22860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22861 }
22862 return resultobj;
22863 fail:
22864 return NULL;
22865 }
22866
22867
22868 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22869 PyObject *resultobj = 0;
22870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22871 int arg2 = (int) wxMOUSE_BTN_ANY ;
22872 bool result;
22873 void *argp1 = 0 ;
22874 int res1 = 0 ;
22875 int val2 ;
22876 int ecode2 = 0 ;
22877 PyObject * obj0 = 0 ;
22878 PyObject * obj1 = 0 ;
22879 char * kwnames[] = {
22880 (char *) "self",(char *) "but", NULL
22881 };
22882
22883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22885 if (!SWIG_IsOK(res1)) {
22886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22887 }
22888 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22889 if (obj1) {
22890 ecode2 = SWIG_AsVal_int(obj1, &val2);
22891 if (!SWIG_IsOK(ecode2)) {
22892 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22893 }
22894 arg2 = static_cast< int >(val2);
22895 }
22896 {
22897 PyThreadState* __tstate = wxPyBeginAllowThreads();
22898 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22899 wxPyEndAllowThreads(__tstate);
22900 if (PyErr_Occurred()) SWIG_fail;
22901 }
22902 {
22903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22904 }
22905 return resultobj;
22906 fail:
22907 return NULL;
22908 }
22909
22910
22911 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22912 PyObject *resultobj = 0;
22913 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22914 int arg2 ;
22915 bool result;
22916 void *argp1 = 0 ;
22917 int res1 = 0 ;
22918 int val2 ;
22919 int ecode2 = 0 ;
22920 PyObject * obj0 = 0 ;
22921 PyObject * obj1 = 0 ;
22922 char * kwnames[] = {
22923 (char *) "self",(char *) "button", NULL
22924 };
22925
22926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22928 if (!SWIG_IsOK(res1)) {
22929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22930 }
22931 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22932 ecode2 = SWIG_AsVal_int(obj1, &val2);
22933 if (!SWIG_IsOK(ecode2)) {
22934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22935 }
22936 arg2 = static_cast< int >(val2);
22937 {
22938 PyThreadState* __tstate = wxPyBeginAllowThreads();
22939 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22940 wxPyEndAllowThreads(__tstate);
22941 if (PyErr_Occurred()) SWIG_fail;
22942 }
22943 {
22944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22945 }
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22953 PyObject *resultobj = 0;
22954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22955 int arg2 ;
22956 bool result;
22957 void *argp1 = 0 ;
22958 int res1 = 0 ;
22959 int val2 ;
22960 int ecode2 = 0 ;
22961 PyObject * obj0 = 0 ;
22962 PyObject * obj1 = 0 ;
22963 char * kwnames[] = {
22964 (char *) "self",(char *) "but", NULL
22965 };
22966
22967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22969 if (!SWIG_IsOK(res1)) {
22970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22971 }
22972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22973 ecode2 = SWIG_AsVal_int(obj1, &val2);
22974 if (!SWIG_IsOK(ecode2)) {
22975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22976 }
22977 arg2 = static_cast< int >(val2);
22978 {
22979 PyThreadState* __tstate = wxPyBeginAllowThreads();
22980 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 {
22985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22994 PyObject *resultobj = 0;
22995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22996 int result;
22997 void *argp1 = 0 ;
22998 int res1 = 0 ;
22999 PyObject *swig_obj[1] ;
23000
23001 if (!args) SWIG_fail;
23002 swig_obj[0] = args;
23003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23004 if (!SWIG_IsOK(res1)) {
23005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23006 }
23007 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23008 {
23009 PyThreadState* __tstate = wxPyBeginAllowThreads();
23010 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23011 wxPyEndAllowThreads(__tstate);
23012 if (PyErr_Occurred()) SWIG_fail;
23013 }
23014 resultobj = SWIG_From_int(static_cast< int >(result));
23015 return resultobj;
23016 fail:
23017 return NULL;
23018 }
23019
23020
23021 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23022 PyObject *resultobj = 0;
23023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23024 bool result;
23025 void *argp1 = 0 ;
23026 int res1 = 0 ;
23027 PyObject *swig_obj[1] ;
23028
23029 if (!args) SWIG_fail;
23030 swig_obj[0] = args;
23031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23032 if (!SWIG_IsOK(res1)) {
23033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23034 }
23035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23036 {
23037 PyThreadState* __tstate = wxPyBeginAllowThreads();
23038 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23039 wxPyEndAllowThreads(__tstate);
23040 if (PyErr_Occurred()) SWIG_fail;
23041 }
23042 {
23043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23044 }
23045 return resultobj;
23046 fail:
23047 return NULL;
23048 }
23049
23050
23051 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23052 PyObject *resultobj = 0;
23053 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23054 bool result;
23055 void *argp1 = 0 ;
23056 int res1 = 0 ;
23057 PyObject *swig_obj[1] ;
23058
23059 if (!args) SWIG_fail;
23060 swig_obj[0] = args;
23061 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23062 if (!SWIG_IsOK(res1)) {
23063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23064 }
23065 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23069 wxPyEndAllowThreads(__tstate);
23070 if (PyErr_Occurred()) SWIG_fail;
23071 }
23072 {
23073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23074 }
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23084 bool result;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23094 }
23095 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 {
23103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23104 }
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23112 PyObject *resultobj = 0;
23113 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23114 bool result;
23115 void *argp1 = 0 ;
23116 int res1 = 0 ;
23117 PyObject *swig_obj[1] ;
23118
23119 if (!args) SWIG_fail;
23120 swig_obj[0] = args;
23121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23122 if (!SWIG_IsOK(res1)) {
23123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23124 }
23125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23129 wxPyEndAllowThreads(__tstate);
23130 if (PyErr_Occurred()) SWIG_fail;
23131 }
23132 {
23133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23134 }
23135 return resultobj;
23136 fail:
23137 return NULL;
23138 }
23139
23140
23141 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23142 PyObject *resultobj = 0;
23143 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23144 bool result;
23145 void *argp1 = 0 ;
23146 int res1 = 0 ;
23147 PyObject *swig_obj[1] ;
23148
23149 if (!args) SWIG_fail;
23150 swig_obj[0] = args;
23151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23152 if (!SWIG_IsOK(res1)) {
23153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23154 }
23155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23156 {
23157 PyThreadState* __tstate = wxPyBeginAllowThreads();
23158 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23159 wxPyEndAllowThreads(__tstate);
23160 if (PyErr_Occurred()) SWIG_fail;
23161 }
23162 {
23163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23164 }
23165 return resultobj;
23166 fail:
23167 return NULL;
23168 }
23169
23170
23171 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23172 PyObject *resultobj = 0;
23173 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23174 bool result;
23175 void *argp1 = 0 ;
23176 int res1 = 0 ;
23177 PyObject *swig_obj[1] ;
23178
23179 if (!args) SWIG_fail;
23180 swig_obj[0] = args;
23181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23182 if (!SWIG_IsOK(res1)) {
23183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23184 }
23185 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23186 {
23187 PyThreadState* __tstate = wxPyBeginAllowThreads();
23188 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23189 wxPyEndAllowThreads(__tstate);
23190 if (PyErr_Occurred()) SWIG_fail;
23191 }
23192 {
23193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23194 }
23195 return resultobj;
23196 fail:
23197 return NULL;
23198 }
23199
23200
23201 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23202 PyObject *resultobj = 0;
23203 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23204 bool result;
23205 void *argp1 = 0 ;
23206 int res1 = 0 ;
23207 PyObject *swig_obj[1] ;
23208
23209 if (!args) SWIG_fail;
23210 swig_obj[0] = args;
23211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23212 if (!SWIG_IsOK(res1)) {
23213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23214 }
23215 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 {
23223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23224 }
23225 return resultobj;
23226 fail:
23227 return NULL;
23228 }
23229
23230
23231 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23232 PyObject *resultobj = 0;
23233 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23234 bool result;
23235 void *argp1 = 0 ;
23236 int res1 = 0 ;
23237 PyObject *swig_obj[1] ;
23238
23239 if (!args) SWIG_fail;
23240 swig_obj[0] = args;
23241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23242 if (!SWIG_IsOK(res1)) {
23243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23244 }
23245 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23249 wxPyEndAllowThreads(__tstate);
23250 if (PyErr_Occurred()) SWIG_fail;
23251 }
23252 {
23253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23254 }
23255 return resultobj;
23256 fail:
23257 return NULL;
23258 }
23259
23260
23261 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23262 PyObject *resultobj = 0;
23263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23264 bool result;
23265 void *argp1 = 0 ;
23266 int res1 = 0 ;
23267 PyObject *swig_obj[1] ;
23268
23269 if (!args) SWIG_fail;
23270 swig_obj[0] = args;
23271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23272 if (!SWIG_IsOK(res1)) {
23273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23274 }
23275 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23276 {
23277 PyThreadState* __tstate = wxPyBeginAllowThreads();
23278 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23279 wxPyEndAllowThreads(__tstate);
23280 if (PyErr_Occurred()) SWIG_fail;
23281 }
23282 {
23283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23284 }
23285 return resultobj;
23286 fail:
23287 return NULL;
23288 }
23289
23290
23291 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23292 PyObject *resultobj = 0;
23293 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23294 bool result;
23295 void *argp1 = 0 ;
23296 int res1 = 0 ;
23297 PyObject *swig_obj[1] ;
23298
23299 if (!args) SWIG_fail;
23300 swig_obj[0] = args;
23301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23302 if (!SWIG_IsOK(res1)) {
23303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23304 }
23305 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23306 {
23307 PyThreadState* __tstate = wxPyBeginAllowThreads();
23308 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 {
23313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23314 }
23315 return resultobj;
23316 fail:
23317 return NULL;
23318 }
23319
23320
23321 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23322 PyObject *resultobj = 0;
23323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23324 bool result;
23325 void *argp1 = 0 ;
23326 int res1 = 0 ;
23327 PyObject *swig_obj[1] ;
23328
23329 if (!args) SWIG_fail;
23330 swig_obj[0] = args;
23331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23332 if (!SWIG_IsOK(res1)) {
23333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23334 }
23335 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23336 {
23337 PyThreadState* __tstate = wxPyBeginAllowThreads();
23338 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23339 wxPyEndAllowThreads(__tstate);
23340 if (PyErr_Occurred()) SWIG_fail;
23341 }
23342 {
23343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23344 }
23345 return resultobj;
23346 fail:
23347 return NULL;
23348 }
23349
23350
23351 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23352 PyObject *resultobj = 0;
23353 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23354 bool result;
23355 void *argp1 = 0 ;
23356 int res1 = 0 ;
23357 PyObject *swig_obj[1] ;
23358
23359 if (!args) SWIG_fail;
23360 swig_obj[0] = args;
23361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23362 if (!SWIG_IsOK(res1)) {
23363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23364 }
23365 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23366 {
23367 PyThreadState* __tstate = wxPyBeginAllowThreads();
23368 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23369 wxPyEndAllowThreads(__tstate);
23370 if (PyErr_Occurred()) SWIG_fail;
23371 }
23372 {
23373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23374 }
23375 return resultobj;
23376 fail:
23377 return NULL;
23378 }
23379
23380
23381 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23382 PyObject *resultobj = 0;
23383 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23384 bool result;
23385 void *argp1 = 0 ;
23386 int res1 = 0 ;
23387 PyObject *swig_obj[1] ;
23388
23389 if (!args) SWIG_fail;
23390 swig_obj[0] = args;
23391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23392 if (!SWIG_IsOK(res1)) {
23393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23394 }
23395 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 {
23403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23404 }
23405 return resultobj;
23406 fail:
23407 return NULL;
23408 }
23409
23410
23411 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23412 PyObject *resultobj = 0;
23413 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23414 bool result;
23415 void *argp1 = 0 ;
23416 int res1 = 0 ;
23417 PyObject *swig_obj[1] ;
23418
23419 if (!args) SWIG_fail;
23420 swig_obj[0] = args;
23421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23422 if (!SWIG_IsOK(res1)) {
23423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23424 }
23425 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23426 {
23427 PyThreadState* __tstate = wxPyBeginAllowThreads();
23428 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23429 wxPyEndAllowThreads(__tstate);
23430 if (PyErr_Occurred()) SWIG_fail;
23431 }
23432 {
23433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23434 }
23435 return resultobj;
23436 fail:
23437 return NULL;
23438 }
23439
23440
23441 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23442 PyObject *resultobj = 0;
23443 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23444 bool result;
23445 void *argp1 = 0 ;
23446 int res1 = 0 ;
23447 PyObject *swig_obj[1] ;
23448
23449 if (!args) SWIG_fail;
23450 swig_obj[0] = args;
23451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23452 if (!SWIG_IsOK(res1)) {
23453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23454 }
23455 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23456 {
23457 PyThreadState* __tstate = wxPyBeginAllowThreads();
23458 result = (bool)(arg1)->LeftIsDown();
23459 wxPyEndAllowThreads(__tstate);
23460 if (PyErr_Occurred()) SWIG_fail;
23461 }
23462 {
23463 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23464 }
23465 return resultobj;
23466 fail:
23467 return NULL;
23468 }
23469
23470
23471 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23472 PyObject *resultobj = 0;
23473 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23474 bool result;
23475 void *argp1 = 0 ;
23476 int res1 = 0 ;
23477 PyObject *swig_obj[1] ;
23478
23479 if (!args) SWIG_fail;
23480 swig_obj[0] = args;
23481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23482 if (!SWIG_IsOK(res1)) {
23483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23484 }
23485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23486 {
23487 PyThreadState* __tstate = wxPyBeginAllowThreads();
23488 result = (bool)(arg1)->MiddleIsDown();
23489 wxPyEndAllowThreads(__tstate);
23490 if (PyErr_Occurred()) SWIG_fail;
23491 }
23492 {
23493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23494 }
23495 return resultobj;
23496 fail:
23497 return NULL;
23498 }
23499
23500
23501 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23502 PyObject *resultobj = 0;
23503 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23504 bool result;
23505 void *argp1 = 0 ;
23506 int res1 = 0 ;
23507 PyObject *swig_obj[1] ;
23508
23509 if (!args) SWIG_fail;
23510 swig_obj[0] = args;
23511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23512 if (!SWIG_IsOK(res1)) {
23513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23514 }
23515 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 result = (bool)(arg1)->RightIsDown();
23519 wxPyEndAllowThreads(__tstate);
23520 if (PyErr_Occurred()) SWIG_fail;
23521 }
23522 {
23523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23524 }
23525 return resultobj;
23526 fail:
23527 return NULL;
23528 }
23529
23530
23531 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23532 PyObject *resultobj = 0;
23533 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23534 bool result;
23535 void *argp1 = 0 ;
23536 int res1 = 0 ;
23537 PyObject *swig_obj[1] ;
23538
23539 if (!args) SWIG_fail;
23540 swig_obj[0] = args;
23541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23542 if (!SWIG_IsOK(res1)) {
23543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23544 }
23545 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 {
23553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23554 }
23555 return resultobj;
23556 fail:
23557 return NULL;
23558 }
23559
23560
23561 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23562 PyObject *resultobj = 0;
23563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23564 bool result;
23565 void *argp1 = 0 ;
23566 int res1 = 0 ;
23567 PyObject *swig_obj[1] ;
23568
23569 if (!args) SWIG_fail;
23570 swig_obj[0] = args;
23571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23572 if (!SWIG_IsOK(res1)) {
23573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23574 }
23575 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23576 {
23577 PyThreadState* __tstate = wxPyBeginAllowThreads();
23578 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 {
23583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23584 }
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23594 bool result;
23595 void *argp1 = 0 ;
23596 int res1 = 0 ;
23597 PyObject *swig_obj[1] ;
23598
23599 if (!args) SWIG_fail;
23600 swig_obj[0] = args;
23601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23604 }
23605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *resultobj = 0;
23623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23624 bool result;
23625 void *argp1 = 0 ;
23626 int res1 = 0 ;
23627 PyObject *swig_obj[1] ;
23628
23629 if (!args) SWIG_fail;
23630 swig_obj[0] = args;
23631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23632 if (!SWIG_IsOK(res1)) {
23633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23634 }
23635 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23636 {
23637 PyThreadState* __tstate = wxPyBeginAllowThreads();
23638 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23639 wxPyEndAllowThreads(__tstate);
23640 if (PyErr_Occurred()) SWIG_fail;
23641 }
23642 {
23643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23644 }
23645 return resultobj;
23646 fail:
23647 return NULL;
23648 }
23649
23650
23651 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23652 PyObject *resultobj = 0;
23653 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23654 wxPoint result;
23655 void *argp1 = 0 ;
23656 int res1 = 0 ;
23657 PyObject *swig_obj[1] ;
23658
23659 if (!args) SWIG_fail;
23660 swig_obj[0] = args;
23661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23662 if (!SWIG_IsOK(res1)) {
23663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23664 }
23665 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23666 {
23667 PyThreadState* __tstate = wxPyBeginAllowThreads();
23668 result = (arg1)->GetPosition();
23669 wxPyEndAllowThreads(__tstate);
23670 if (PyErr_Occurred()) SWIG_fail;
23671 }
23672 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23680 PyObject *resultobj = 0;
23681 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23682 long *arg2 = (long *) 0 ;
23683 long *arg3 = (long *) 0 ;
23684 void *argp1 = 0 ;
23685 int res1 = 0 ;
23686 long temp2 ;
23687 int res2 = SWIG_TMPOBJ ;
23688 long temp3 ;
23689 int res3 = SWIG_TMPOBJ ;
23690 PyObject *swig_obj[1] ;
23691
23692 arg2 = &temp2;
23693 arg3 = &temp3;
23694 if (!args) SWIG_fail;
23695 swig_obj[0] = args;
23696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23697 if (!SWIG_IsOK(res1)) {
23698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23699 }
23700 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 (arg1)->GetPosition(arg2,arg3);
23704 wxPyEndAllowThreads(__tstate);
23705 if (PyErr_Occurred()) SWIG_fail;
23706 }
23707 resultobj = SWIG_Py_Void();
23708 if (SWIG_IsTmpObj(res2)) {
23709 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23710 } else {
23711 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23712 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23713 }
23714 if (SWIG_IsTmpObj(res3)) {
23715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23716 } else {
23717 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23719 }
23720 return resultobj;
23721 fail:
23722 return NULL;
23723 }
23724
23725
23726 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23727 PyObject *resultobj = 0;
23728 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23729 wxDC *arg2 = 0 ;
23730 wxPoint result;
23731 void *argp1 = 0 ;
23732 int res1 = 0 ;
23733 void *argp2 = 0 ;
23734 int res2 = 0 ;
23735 PyObject * obj0 = 0 ;
23736 PyObject * obj1 = 0 ;
23737 char * kwnames[] = {
23738 (char *) "self",(char *) "dc", NULL
23739 };
23740
23741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23743 if (!SWIG_IsOK(res1)) {
23744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23745 }
23746 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23747 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23748 if (!SWIG_IsOK(res2)) {
23749 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23750 }
23751 if (!argp2) {
23752 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23753 }
23754 arg2 = reinterpret_cast< wxDC * >(argp2);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23762 return resultobj;
23763 fail:
23764 return NULL;
23765 }
23766
23767
23768 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23769 PyObject *resultobj = 0;
23770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23771 int result;
23772 void *argp1 = 0 ;
23773 int res1 = 0 ;
23774 PyObject *swig_obj[1] ;
23775
23776 if (!args) SWIG_fail;
23777 swig_obj[0] = args;
23778 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23779 if (!SWIG_IsOK(res1)) {
23780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23781 }
23782 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = (int)((wxMouseEvent const *)arg1)->GetX();
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 resultobj = SWIG_From_int(static_cast< int >(result));
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *resultobj = 0;
23798 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23799 int result;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 PyObject *swig_obj[1] ;
23803
23804 if (!args) SWIG_fail;
23805 swig_obj[0] = args;
23806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23807 if (!SWIG_IsOK(res1)) {
23808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23809 }
23810 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (int)((wxMouseEvent const *)arg1)->GetY();
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 resultobj = SWIG_From_int(static_cast< int >(result));
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23825 PyObject *resultobj = 0;
23826 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23827 int result;
23828 void *argp1 = 0 ;
23829 int res1 = 0 ;
23830 PyObject *swig_obj[1] ;
23831
23832 if (!args) SWIG_fail;
23833 swig_obj[0] = args;
23834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23837 }
23838 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23842 wxPyEndAllowThreads(__tstate);
23843 if (PyErr_Occurred()) SWIG_fail;
23844 }
23845 resultobj = SWIG_From_int(static_cast< int >(result));
23846 return resultobj;
23847 fail:
23848 return NULL;
23849 }
23850
23851
23852 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23855 int result;
23856 void *argp1 = 0 ;
23857 int res1 = 0 ;
23858 PyObject *swig_obj[1] ;
23859
23860 if (!args) SWIG_fail;
23861 swig_obj[0] = args;
23862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 resultobj = SWIG_From_int(static_cast< int >(result));
23874 return resultobj;
23875 fail:
23876 return NULL;
23877 }
23878
23879
23880 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23881 PyObject *resultobj = 0;
23882 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23883 int result;
23884 void *argp1 = 0 ;
23885 int res1 = 0 ;
23886 PyObject *swig_obj[1] ;
23887
23888 if (!args) SWIG_fail;
23889 swig_obj[0] = args;
23890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23891 if (!SWIG_IsOK(res1)) {
23892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23893 }
23894 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23895 {
23896 PyThreadState* __tstate = wxPyBeginAllowThreads();
23897 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23898 wxPyEndAllowThreads(__tstate);
23899 if (PyErr_Occurred()) SWIG_fail;
23900 }
23901 resultobj = SWIG_From_int(static_cast< int >(result));
23902 return resultobj;
23903 fail:
23904 return NULL;
23905 }
23906
23907
23908 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23909 PyObject *resultobj = 0;
23910 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23911 bool result;
23912 void *argp1 = 0 ;
23913 int res1 = 0 ;
23914 PyObject *swig_obj[1] ;
23915
23916 if (!args) SWIG_fail;
23917 swig_obj[0] = args;
23918 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23919 if (!SWIG_IsOK(res1)) {
23920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23921 }
23922 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23923 {
23924 PyThreadState* __tstate = wxPyBeginAllowThreads();
23925 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23926 wxPyEndAllowThreads(__tstate);
23927 if (PyErr_Occurred()) SWIG_fail;
23928 }
23929 {
23930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23931 }
23932 return resultobj;
23933 fail:
23934 return NULL;
23935 }
23936
23937
23938 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23939 PyObject *resultobj = 0;
23940 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23941 int arg2 ;
23942 void *argp1 = 0 ;
23943 int res1 = 0 ;
23944 int val2 ;
23945 int ecode2 = 0 ;
23946 PyObject *swig_obj[2] ;
23947
23948 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23950 if (!SWIG_IsOK(res1)) {
23951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23952 }
23953 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23954 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23955 if (!SWIG_IsOK(ecode2)) {
23956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23957 }
23958 arg2 = static_cast< int >(val2);
23959 if (arg1) (arg1)->m_x = arg2;
23960
23961 resultobj = SWIG_Py_Void();
23962 return resultobj;
23963 fail:
23964 return NULL;
23965 }
23966
23967
23968 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23969 PyObject *resultobj = 0;
23970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23971 int result;
23972 void *argp1 = 0 ;
23973 int res1 = 0 ;
23974 PyObject *swig_obj[1] ;
23975
23976 if (!args) SWIG_fail;
23977 swig_obj[0] = args;
23978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23979 if (!SWIG_IsOK(res1)) {
23980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23981 }
23982 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23983 result = (int) ((arg1)->m_x);
23984 resultobj = SWIG_From_int(static_cast< int >(result));
23985 return resultobj;
23986 fail:
23987 return NULL;
23988 }
23989
23990
23991 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23992 PyObject *resultobj = 0;
23993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23994 int arg2 ;
23995 void *argp1 = 0 ;
23996 int res1 = 0 ;
23997 int val2 ;
23998 int ecode2 = 0 ;
23999 PyObject *swig_obj[2] ;
24000
24001 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24003 if (!SWIG_IsOK(res1)) {
24004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24005 }
24006 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24007 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24008 if (!SWIG_IsOK(ecode2)) {
24009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24010 }
24011 arg2 = static_cast< int >(val2);
24012 if (arg1) (arg1)->m_y = arg2;
24013
24014 resultobj = SWIG_Py_Void();
24015 return resultobj;
24016 fail:
24017 return NULL;
24018 }
24019
24020
24021 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24022 PyObject *resultobj = 0;
24023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24024 int result;
24025 void *argp1 = 0 ;
24026 int res1 = 0 ;
24027 PyObject *swig_obj[1] ;
24028
24029 if (!args) SWIG_fail;
24030 swig_obj[0] = args;
24031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24032 if (!SWIG_IsOK(res1)) {
24033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24034 }
24035 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24036 result = (int) ((arg1)->m_y);
24037 resultobj = SWIG_From_int(static_cast< int >(result));
24038 return resultobj;
24039 fail:
24040 return NULL;
24041 }
24042
24043
24044 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24045 PyObject *resultobj = 0;
24046 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24047 bool arg2 ;
24048 void *argp1 = 0 ;
24049 int res1 = 0 ;
24050 bool val2 ;
24051 int ecode2 = 0 ;
24052 PyObject *swig_obj[2] ;
24053
24054 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24056 if (!SWIG_IsOK(res1)) {
24057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24058 }
24059 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24060 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24061 if (!SWIG_IsOK(ecode2)) {
24062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24063 }
24064 arg2 = static_cast< bool >(val2);
24065 if (arg1) (arg1)->m_leftDown = arg2;
24066
24067 resultobj = SWIG_Py_Void();
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24075 PyObject *resultobj = 0;
24076 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24077 bool result;
24078 void *argp1 = 0 ;
24079 int res1 = 0 ;
24080 PyObject *swig_obj[1] ;
24081
24082 if (!args) SWIG_fail;
24083 swig_obj[0] = args;
24084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24085 if (!SWIG_IsOK(res1)) {
24086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24087 }
24088 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24089 result = (bool) ((arg1)->m_leftDown);
24090 {
24091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24092 }
24093 return resultobj;
24094 fail:
24095 return NULL;
24096 }
24097
24098
24099 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24100 PyObject *resultobj = 0;
24101 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24102 bool arg2 ;
24103 void *argp1 = 0 ;
24104 int res1 = 0 ;
24105 bool val2 ;
24106 int ecode2 = 0 ;
24107 PyObject *swig_obj[2] ;
24108
24109 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24113 }
24114 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24115 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24116 if (!SWIG_IsOK(ecode2)) {
24117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24118 }
24119 arg2 = static_cast< bool >(val2);
24120 if (arg1) (arg1)->m_middleDown = arg2;
24121
24122 resultobj = SWIG_Py_Void();
24123 return resultobj;
24124 fail:
24125 return NULL;
24126 }
24127
24128
24129 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24130 PyObject *resultobj = 0;
24131 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24132 bool result;
24133 void *argp1 = 0 ;
24134 int res1 = 0 ;
24135 PyObject *swig_obj[1] ;
24136
24137 if (!args) SWIG_fail;
24138 swig_obj[0] = args;
24139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24140 if (!SWIG_IsOK(res1)) {
24141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24142 }
24143 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24144 result = (bool) ((arg1)->m_middleDown);
24145 {
24146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24147 }
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24155 PyObject *resultobj = 0;
24156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24157 bool arg2 ;
24158 void *argp1 = 0 ;
24159 int res1 = 0 ;
24160 bool val2 ;
24161 int ecode2 = 0 ;
24162 PyObject *swig_obj[2] ;
24163
24164 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24166 if (!SWIG_IsOK(res1)) {
24167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24168 }
24169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24170 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24171 if (!SWIG_IsOK(ecode2)) {
24172 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24173 }
24174 arg2 = static_cast< bool >(val2);
24175 if (arg1) (arg1)->m_rightDown = arg2;
24176
24177 resultobj = SWIG_Py_Void();
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24187 bool result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24197 }
24198 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24199 result = (bool) ((arg1)->m_rightDown);
24200 {
24201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24202 }
24203 return resultobj;
24204 fail:
24205 return NULL;
24206 }
24207
24208
24209 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24210 PyObject *resultobj = 0;
24211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24212 bool arg2 ;
24213 void *argp1 = 0 ;
24214 int res1 = 0 ;
24215 bool val2 ;
24216 int ecode2 = 0 ;
24217 PyObject *swig_obj[2] ;
24218
24219 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24221 if (!SWIG_IsOK(res1)) {
24222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24223 }
24224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24225 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24226 if (!SWIG_IsOK(ecode2)) {
24227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24228 }
24229 arg2 = static_cast< bool >(val2);
24230 if (arg1) (arg1)->m_controlDown = arg2;
24231
24232 resultobj = SWIG_Py_Void();
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24240 PyObject *resultobj = 0;
24241 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24242 bool result;
24243 void *argp1 = 0 ;
24244 int res1 = 0 ;
24245 PyObject *swig_obj[1] ;
24246
24247 if (!args) SWIG_fail;
24248 swig_obj[0] = args;
24249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24250 if (!SWIG_IsOK(res1)) {
24251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24252 }
24253 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24254 result = (bool) ((arg1)->m_controlDown);
24255 {
24256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24257 }
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24267 bool arg2 ;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 bool val2 ;
24271 int ecode2 = 0 ;
24272 PyObject *swig_obj[2] ;
24273
24274 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24278 }
24279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24280 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24281 if (!SWIG_IsOK(ecode2)) {
24282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24283 }
24284 arg2 = static_cast< bool >(val2);
24285 if (arg1) (arg1)->m_shiftDown = arg2;
24286
24287 resultobj = SWIG_Py_Void();
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *resultobj = 0;
24296 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24297 bool result;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 PyObject *swig_obj[1] ;
24301
24302 if (!args) SWIG_fail;
24303 swig_obj[0] = args;
24304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24305 if (!SWIG_IsOK(res1)) {
24306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24307 }
24308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24309 result = (bool) ((arg1)->m_shiftDown);
24310 {
24311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24312 }
24313 return resultobj;
24314 fail:
24315 return NULL;
24316 }
24317
24318
24319 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24320 PyObject *resultobj = 0;
24321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24322 bool arg2 ;
24323 void *argp1 = 0 ;
24324 int res1 = 0 ;
24325 bool val2 ;
24326 int ecode2 = 0 ;
24327 PyObject *swig_obj[2] ;
24328
24329 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24331 if (!SWIG_IsOK(res1)) {
24332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24333 }
24334 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24335 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24336 if (!SWIG_IsOK(ecode2)) {
24337 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24338 }
24339 arg2 = static_cast< bool >(val2);
24340 if (arg1) (arg1)->m_altDown = arg2;
24341
24342 resultobj = SWIG_Py_Void();
24343 return resultobj;
24344 fail:
24345 return NULL;
24346 }
24347
24348
24349 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24350 PyObject *resultobj = 0;
24351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24352 bool result;
24353 void *argp1 = 0 ;
24354 int res1 = 0 ;
24355 PyObject *swig_obj[1] ;
24356
24357 if (!args) SWIG_fail;
24358 swig_obj[0] = args;
24359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24360 if (!SWIG_IsOK(res1)) {
24361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24362 }
24363 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24364 result = (bool) ((arg1)->m_altDown);
24365 {
24366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24367 }
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24375 PyObject *resultobj = 0;
24376 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24377 bool arg2 ;
24378 void *argp1 = 0 ;
24379 int res1 = 0 ;
24380 bool val2 ;
24381 int ecode2 = 0 ;
24382 PyObject *swig_obj[2] ;
24383
24384 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24388 }
24389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24390 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24391 if (!SWIG_IsOK(ecode2)) {
24392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24393 }
24394 arg2 = static_cast< bool >(val2);
24395 if (arg1) (arg1)->m_metaDown = arg2;
24396
24397 resultobj = SWIG_Py_Void();
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *resultobj = 0;
24406 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24407 bool result;
24408 void *argp1 = 0 ;
24409 int res1 = 0 ;
24410 PyObject *swig_obj[1] ;
24411
24412 if (!args) SWIG_fail;
24413 swig_obj[0] = args;
24414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24415 if (!SWIG_IsOK(res1)) {
24416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24417 }
24418 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24419 result = (bool) ((arg1)->m_metaDown);
24420 {
24421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24422 }
24423 return resultobj;
24424 fail:
24425 return NULL;
24426 }
24427
24428
24429 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24430 PyObject *resultobj = 0;
24431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24432 int arg2 ;
24433 void *argp1 = 0 ;
24434 int res1 = 0 ;
24435 int val2 ;
24436 int ecode2 = 0 ;
24437 PyObject *swig_obj[2] ;
24438
24439 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24441 if (!SWIG_IsOK(res1)) {
24442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24443 }
24444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24445 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24446 if (!SWIG_IsOK(ecode2)) {
24447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24448 }
24449 arg2 = static_cast< int >(val2);
24450 if (arg1) (arg1)->m_wheelRotation = arg2;
24451
24452 resultobj = SWIG_Py_Void();
24453 return resultobj;
24454 fail:
24455 return NULL;
24456 }
24457
24458
24459 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24460 PyObject *resultobj = 0;
24461 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24462 int result;
24463 void *argp1 = 0 ;
24464 int res1 = 0 ;
24465 PyObject *swig_obj[1] ;
24466
24467 if (!args) SWIG_fail;
24468 swig_obj[0] = args;
24469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24470 if (!SWIG_IsOK(res1)) {
24471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24472 }
24473 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24474 result = (int) ((arg1)->m_wheelRotation);
24475 resultobj = SWIG_From_int(static_cast< int >(result));
24476 return resultobj;
24477 fail:
24478 return NULL;
24479 }
24480
24481
24482 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24483 PyObject *resultobj = 0;
24484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24485 int arg2 ;
24486 void *argp1 = 0 ;
24487 int res1 = 0 ;
24488 int val2 ;
24489 int ecode2 = 0 ;
24490 PyObject *swig_obj[2] ;
24491
24492 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24494 if (!SWIG_IsOK(res1)) {
24495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24496 }
24497 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24498 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24499 if (!SWIG_IsOK(ecode2)) {
24500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24501 }
24502 arg2 = static_cast< int >(val2);
24503 if (arg1) (arg1)->m_wheelDelta = arg2;
24504
24505 resultobj = SWIG_Py_Void();
24506 return resultobj;
24507 fail:
24508 return NULL;
24509 }
24510
24511
24512 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24513 PyObject *resultobj = 0;
24514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24515 int result;
24516 void *argp1 = 0 ;
24517 int res1 = 0 ;
24518 PyObject *swig_obj[1] ;
24519
24520 if (!args) SWIG_fail;
24521 swig_obj[0] = args;
24522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24523 if (!SWIG_IsOK(res1)) {
24524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24525 }
24526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24527 result = (int) ((arg1)->m_wheelDelta);
24528 resultobj = SWIG_From_int(static_cast< int >(result));
24529 return resultobj;
24530 fail:
24531 return NULL;
24532 }
24533
24534
24535 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24536 PyObject *resultobj = 0;
24537 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24538 int arg2 ;
24539 void *argp1 = 0 ;
24540 int res1 = 0 ;
24541 int val2 ;
24542 int ecode2 = 0 ;
24543 PyObject *swig_obj[2] ;
24544
24545 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24547 if (!SWIG_IsOK(res1)) {
24548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24549 }
24550 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24551 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24552 if (!SWIG_IsOK(ecode2)) {
24553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24554 }
24555 arg2 = static_cast< int >(val2);
24556 if (arg1) (arg1)->m_linesPerAction = arg2;
24557
24558 resultobj = SWIG_Py_Void();
24559 return resultobj;
24560 fail:
24561 return NULL;
24562 }
24563
24564
24565 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24566 PyObject *resultobj = 0;
24567 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24568 int result;
24569 void *argp1 = 0 ;
24570 int res1 = 0 ;
24571 PyObject *swig_obj[1] ;
24572
24573 if (!args) SWIG_fail;
24574 swig_obj[0] = args;
24575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24576 if (!SWIG_IsOK(res1)) {
24577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24578 }
24579 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24580 result = (int) ((arg1)->m_linesPerAction);
24581 resultobj = SWIG_From_int(static_cast< int >(result));
24582 return resultobj;
24583 fail:
24584 return NULL;
24585 }
24586
24587
24588 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24589 PyObject *obj;
24590 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24591 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24592 return SWIG_Py_Void();
24593 }
24594
24595 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24596 return SWIG_Python_InitShadowInstance(args);
24597 }
24598
24599 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj = 0;
24601 int arg1 = (int) 0 ;
24602 int arg2 = (int) 0 ;
24603 wxSetCursorEvent *result = 0 ;
24604 int val1 ;
24605 int ecode1 = 0 ;
24606 int val2 ;
24607 int ecode2 = 0 ;
24608 PyObject * obj0 = 0 ;
24609 PyObject * obj1 = 0 ;
24610 char * kwnames[] = {
24611 (char *) "x",(char *) "y", NULL
24612 };
24613
24614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24615 if (obj0) {
24616 ecode1 = SWIG_AsVal_int(obj0, &val1);
24617 if (!SWIG_IsOK(ecode1)) {
24618 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24619 }
24620 arg1 = static_cast< int >(val1);
24621 }
24622 if (obj1) {
24623 ecode2 = SWIG_AsVal_int(obj1, &val2);
24624 if (!SWIG_IsOK(ecode2)) {
24625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24626 }
24627 arg2 = static_cast< int >(val2);
24628 }
24629 {
24630 PyThreadState* __tstate = wxPyBeginAllowThreads();
24631 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24632 wxPyEndAllowThreads(__tstate);
24633 if (PyErr_Occurred()) SWIG_fail;
24634 }
24635 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24636 return resultobj;
24637 fail:
24638 return NULL;
24639 }
24640
24641
24642 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24643 PyObject *resultobj = 0;
24644 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24645 int result;
24646 void *argp1 = 0 ;
24647 int res1 = 0 ;
24648 PyObject *swig_obj[1] ;
24649
24650 if (!args) SWIG_fail;
24651 swig_obj[0] = args;
24652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24653 if (!SWIG_IsOK(res1)) {
24654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24655 }
24656 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24657 {
24658 PyThreadState* __tstate = wxPyBeginAllowThreads();
24659 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24660 wxPyEndAllowThreads(__tstate);
24661 if (PyErr_Occurred()) SWIG_fail;
24662 }
24663 resultobj = SWIG_From_int(static_cast< int >(result));
24664 return resultobj;
24665 fail:
24666 return NULL;
24667 }
24668
24669
24670 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24671 PyObject *resultobj = 0;
24672 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24673 int result;
24674 void *argp1 = 0 ;
24675 int res1 = 0 ;
24676 PyObject *swig_obj[1] ;
24677
24678 if (!args) SWIG_fail;
24679 swig_obj[0] = args;
24680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24681 if (!SWIG_IsOK(res1)) {
24682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24683 }
24684 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24685 {
24686 PyThreadState* __tstate = wxPyBeginAllowThreads();
24687 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24688 wxPyEndAllowThreads(__tstate);
24689 if (PyErr_Occurred()) SWIG_fail;
24690 }
24691 resultobj = SWIG_From_int(static_cast< int >(result));
24692 return resultobj;
24693 fail:
24694 return NULL;
24695 }
24696
24697
24698 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24699 PyObject *resultobj = 0;
24700 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24701 wxCursor *arg2 = 0 ;
24702 void *argp1 = 0 ;
24703 int res1 = 0 ;
24704 void *argp2 = 0 ;
24705 int res2 = 0 ;
24706 PyObject * obj0 = 0 ;
24707 PyObject * obj1 = 0 ;
24708 char * kwnames[] = {
24709 (char *) "self",(char *) "cursor", NULL
24710 };
24711
24712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24714 if (!SWIG_IsOK(res1)) {
24715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24716 }
24717 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24718 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24719 if (!SWIG_IsOK(res2)) {
24720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24721 }
24722 if (!argp2) {
24723 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24724 }
24725 arg2 = reinterpret_cast< wxCursor * >(argp2);
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 (arg1)->SetCursor((wxCursor const &)*arg2);
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_Py_Void();
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24740 PyObject *resultobj = 0;
24741 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24742 wxCursor *result = 0 ;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 PyObject *swig_obj[1] ;
24746
24747 if (!args) SWIG_fail;
24748 swig_obj[0] = args;
24749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24752 }
24753 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 {
24757 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24758 result = (wxCursor *) &_result_ref;
24759 }
24760 wxPyEndAllowThreads(__tstate);
24761 if (PyErr_Occurred()) SWIG_fail;
24762 }
24763 {
24764 wxCursor* resultptr = new wxCursor(*result);
24765 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24766 }
24767 return resultobj;
24768 fail:
24769 return NULL;
24770 }
24771
24772
24773 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24774 PyObject *resultobj = 0;
24775 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24776 bool result;
24777 void *argp1 = 0 ;
24778 int res1 = 0 ;
24779 PyObject *swig_obj[1] ;
24780
24781 if (!args) SWIG_fail;
24782 swig_obj[0] = args;
24783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24784 if (!SWIG_IsOK(res1)) {
24785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24786 }
24787 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24788 {
24789 PyThreadState* __tstate = wxPyBeginAllowThreads();
24790 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24791 wxPyEndAllowThreads(__tstate);
24792 if (PyErr_Occurred()) SWIG_fail;
24793 }
24794 {
24795 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24796 }
24797 return resultobj;
24798 fail:
24799 return NULL;
24800 }
24801
24802
24803 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24804 PyObject *obj;
24805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24806 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24807 return SWIG_Py_Void();
24808 }
24809
24810 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24811 return SWIG_Python_InitShadowInstance(args);
24812 }
24813
24814 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj = 0;
24816 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24817 wxKeyEvent *result = 0 ;
24818 int val1 ;
24819 int ecode1 = 0 ;
24820 PyObject * obj0 = 0 ;
24821 char * kwnames[] = {
24822 (char *) "eventType", NULL
24823 };
24824
24825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24826 if (obj0) {
24827 ecode1 = SWIG_AsVal_int(obj0, &val1);
24828 if (!SWIG_IsOK(ecode1)) {
24829 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24830 }
24831 arg1 = static_cast< wxEventType >(val1);
24832 }
24833 {
24834 PyThreadState* __tstate = wxPyBeginAllowThreads();
24835 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24836 wxPyEndAllowThreads(__tstate);
24837 if (PyErr_Occurred()) SWIG_fail;
24838 }
24839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24840 return resultobj;
24841 fail:
24842 return NULL;
24843 }
24844
24845
24846 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24847 PyObject *resultobj = 0;
24848 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24849 int result;
24850 void *argp1 = 0 ;
24851 int res1 = 0 ;
24852 PyObject *swig_obj[1] ;
24853
24854 if (!args) SWIG_fail;
24855 swig_obj[0] = args;
24856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24857 if (!SWIG_IsOK(res1)) {
24858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24859 }
24860 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24861 {
24862 PyThreadState* __tstate = wxPyBeginAllowThreads();
24863 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24864 wxPyEndAllowThreads(__tstate);
24865 if (PyErr_Occurred()) SWIG_fail;
24866 }
24867 resultobj = SWIG_From_int(static_cast< int >(result));
24868 return resultobj;
24869 fail:
24870 return NULL;
24871 }
24872
24873
24874 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24875 PyObject *resultobj = 0;
24876 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24877 bool result;
24878 void *argp1 = 0 ;
24879 int res1 = 0 ;
24880 PyObject *swig_obj[1] ;
24881
24882 if (!args) SWIG_fail;
24883 swig_obj[0] = args;
24884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24885 if (!SWIG_IsOK(res1)) {
24886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24887 }
24888 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24892 wxPyEndAllowThreads(__tstate);
24893 if (PyErr_Occurred()) SWIG_fail;
24894 }
24895 {
24896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24897 }
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24905 PyObject *resultobj = 0;
24906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24907 bool result;
24908 void *argp1 = 0 ;
24909 int res1 = 0 ;
24910 PyObject *swig_obj[1] ;
24911
24912 if (!args) SWIG_fail;
24913 swig_obj[0] = args;
24914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24915 if (!SWIG_IsOK(res1)) {
24916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24917 }
24918 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24919 {
24920 PyThreadState* __tstate = wxPyBeginAllowThreads();
24921 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24922 wxPyEndAllowThreads(__tstate);
24923 if (PyErr_Occurred()) SWIG_fail;
24924 }
24925 {
24926 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24927 }
24928 return resultobj;
24929 fail:
24930 return NULL;
24931 }
24932
24933
24934 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24935 PyObject *resultobj = 0;
24936 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24937 bool result;
24938 void *argp1 = 0 ;
24939 int res1 = 0 ;
24940 PyObject *swig_obj[1] ;
24941
24942 if (!args) SWIG_fail;
24943 swig_obj[0] = args;
24944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24945 if (!SWIG_IsOK(res1)) {
24946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24947 }
24948 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24949 {
24950 PyThreadState* __tstate = wxPyBeginAllowThreads();
24951 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24952 wxPyEndAllowThreads(__tstate);
24953 if (PyErr_Occurred()) SWIG_fail;
24954 }
24955 {
24956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24957 }
24958 return resultobj;
24959 fail:
24960 return NULL;
24961 }
24962
24963
24964 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24965 PyObject *resultobj = 0;
24966 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24967 bool result;
24968 void *argp1 = 0 ;
24969 int res1 = 0 ;
24970 PyObject *swig_obj[1] ;
24971
24972 if (!args) SWIG_fail;
24973 swig_obj[0] = args;
24974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24975 if (!SWIG_IsOK(res1)) {
24976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24977 }
24978 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24979 {
24980 PyThreadState* __tstate = wxPyBeginAllowThreads();
24981 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
24982 wxPyEndAllowThreads(__tstate);
24983 if (PyErr_Occurred()) SWIG_fail;
24984 }
24985 {
24986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24987 }
24988 return resultobj;
24989 fail:
24990 return NULL;
24991 }
24992
24993
24994 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24995 PyObject *resultobj = 0;
24996 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24997 bool result;
24998 void *argp1 = 0 ;
24999 int res1 = 0 ;
25000 PyObject *swig_obj[1] ;
25001
25002 if (!args) SWIG_fail;
25003 swig_obj[0] = args;
25004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25005 if (!SWIG_IsOK(res1)) {
25006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25007 }
25008 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25012 wxPyEndAllowThreads(__tstate);
25013 if (PyErr_Occurred()) SWIG_fail;
25014 }
25015 {
25016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25017 }
25018 return resultobj;
25019 fail:
25020 return NULL;
25021 }
25022
25023
25024 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25025 PyObject *resultobj = 0;
25026 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25027 bool result;
25028 void *argp1 = 0 ;
25029 int res1 = 0 ;
25030 PyObject *swig_obj[1] ;
25031
25032 if (!args) SWIG_fail;
25033 swig_obj[0] = args;
25034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25035 if (!SWIG_IsOK(res1)) {
25036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25037 }
25038 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25039 {
25040 PyThreadState* __tstate = wxPyBeginAllowThreads();
25041 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25042 wxPyEndAllowThreads(__tstate);
25043 if (PyErr_Occurred()) SWIG_fail;
25044 }
25045 {
25046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25047 }
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25055 PyObject *resultobj = 0;
25056 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25057 int result;
25058 void *argp1 = 0 ;
25059 int res1 = 0 ;
25060 PyObject *swig_obj[1] ;
25061
25062 if (!args) SWIG_fail;
25063 swig_obj[0] = args;
25064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25065 if (!SWIG_IsOK(res1)) {
25066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25067 }
25068 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25069 {
25070 PyThreadState* __tstate = wxPyBeginAllowThreads();
25071 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25072 wxPyEndAllowThreads(__tstate);
25073 if (PyErr_Occurred()) SWIG_fail;
25074 }
25075 resultobj = SWIG_From_int(static_cast< int >(result));
25076 return resultobj;
25077 fail:
25078 return NULL;
25079 }
25080
25081
25082 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25083 PyObject *resultobj = 0;
25084 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25085 int result;
25086 void *argp1 = 0 ;
25087 int res1 = 0 ;
25088 PyObject *swig_obj[1] ;
25089
25090 if (!args) SWIG_fail;
25091 swig_obj[0] = args;
25092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25093 if (!SWIG_IsOK(res1)) {
25094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25095 }
25096 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25097 {
25098 PyThreadState* __tstate = wxPyBeginAllowThreads();
25099 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25100 wxPyEndAllowThreads(__tstate);
25101 if (PyErr_Occurred()) SWIG_fail;
25102 }
25103 resultobj = SWIG_From_int(static_cast< int >(result));
25104 return resultobj;
25105 fail:
25106 return NULL;
25107 }
25108
25109
25110 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25111 PyObject *resultobj = 0;
25112 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25113 int arg2 ;
25114 void *argp1 = 0 ;
25115 int res1 = 0 ;
25116 int val2 ;
25117 int ecode2 = 0 ;
25118 PyObject * obj0 = 0 ;
25119 PyObject * obj1 = 0 ;
25120 char * kwnames[] = {
25121 (char *) "self",(char *) "uniChar", NULL
25122 };
25123
25124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25126 if (!SWIG_IsOK(res1)) {
25127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25128 }
25129 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25130 ecode2 = SWIG_AsVal_int(obj1, &val2);
25131 if (!SWIG_IsOK(ecode2)) {
25132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25133 }
25134 arg2 = static_cast< int >(val2);
25135 {
25136 PyThreadState* __tstate = wxPyBeginAllowThreads();
25137 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25138 wxPyEndAllowThreads(__tstate);
25139 if (PyErr_Occurred()) SWIG_fail;
25140 }
25141 resultobj = SWIG_Py_Void();
25142 return resultobj;
25143 fail:
25144 return NULL;
25145 }
25146
25147
25148 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25149 PyObject *resultobj = 0;
25150 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25151 unsigned int result;
25152 void *argp1 = 0 ;
25153 int res1 = 0 ;
25154 PyObject *swig_obj[1] ;
25155
25156 if (!args) SWIG_fail;
25157 swig_obj[0] = args;
25158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25159 if (!SWIG_IsOK(res1)) {
25160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25161 }
25162 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25163 {
25164 PyThreadState* __tstate = wxPyBeginAllowThreads();
25165 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25166 wxPyEndAllowThreads(__tstate);
25167 if (PyErr_Occurred()) SWIG_fail;
25168 }
25169 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25170 return resultobj;
25171 fail:
25172 return NULL;
25173 }
25174
25175
25176 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25177 PyObject *resultobj = 0;
25178 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25179 unsigned int result;
25180 void *argp1 = 0 ;
25181 int res1 = 0 ;
25182 PyObject *swig_obj[1] ;
25183
25184 if (!args) SWIG_fail;
25185 swig_obj[0] = args;
25186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25187 if (!SWIG_IsOK(res1)) {
25188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25189 }
25190 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25191 {
25192 PyThreadState* __tstate = wxPyBeginAllowThreads();
25193 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25194 wxPyEndAllowThreads(__tstate);
25195 if (PyErr_Occurred()) SWIG_fail;
25196 }
25197 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25198 return resultobj;
25199 fail:
25200 return NULL;
25201 }
25202
25203
25204 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25205 PyObject *resultobj = 0;
25206 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25207 wxPoint result;
25208 void *argp1 = 0 ;
25209 int res1 = 0 ;
25210 PyObject *swig_obj[1] ;
25211
25212 if (!args) SWIG_fail;
25213 swig_obj[0] = args;
25214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25215 if (!SWIG_IsOK(res1)) {
25216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25217 }
25218 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25219 {
25220 PyThreadState* __tstate = wxPyBeginAllowThreads();
25221 result = (arg1)->GetPosition();
25222 wxPyEndAllowThreads(__tstate);
25223 if (PyErr_Occurred()) SWIG_fail;
25224 }
25225 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25226 return resultobj;
25227 fail:
25228 return NULL;
25229 }
25230
25231
25232 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25233 PyObject *resultobj = 0;
25234 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25235 long *arg2 = (long *) 0 ;
25236 long *arg3 = (long *) 0 ;
25237 void *argp1 = 0 ;
25238 int res1 = 0 ;
25239 long temp2 ;
25240 int res2 = SWIG_TMPOBJ ;
25241 long temp3 ;
25242 int res3 = SWIG_TMPOBJ ;
25243 PyObject *swig_obj[1] ;
25244
25245 arg2 = &temp2;
25246 arg3 = &temp3;
25247 if (!args) SWIG_fail;
25248 swig_obj[0] = args;
25249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25250 if (!SWIG_IsOK(res1)) {
25251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25252 }
25253 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25254 {
25255 PyThreadState* __tstate = wxPyBeginAllowThreads();
25256 (arg1)->GetPosition(arg2,arg3);
25257 wxPyEndAllowThreads(__tstate);
25258 if (PyErr_Occurred()) SWIG_fail;
25259 }
25260 resultobj = SWIG_Py_Void();
25261 if (SWIG_IsTmpObj(res2)) {
25262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25263 } else {
25264 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25266 }
25267 if (SWIG_IsTmpObj(res3)) {
25268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25269 } else {
25270 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25272 }
25273 return resultobj;
25274 fail:
25275 return NULL;
25276 }
25277
25278
25279 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25280 PyObject *resultobj = 0;
25281 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25282 int result;
25283 void *argp1 = 0 ;
25284 int res1 = 0 ;
25285 PyObject *swig_obj[1] ;
25286
25287 if (!args) SWIG_fail;
25288 swig_obj[0] = args;
25289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25290 if (!SWIG_IsOK(res1)) {
25291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25292 }
25293 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25294 {
25295 PyThreadState* __tstate = wxPyBeginAllowThreads();
25296 result = (int)((wxKeyEvent const *)arg1)->GetX();
25297 wxPyEndAllowThreads(__tstate);
25298 if (PyErr_Occurred()) SWIG_fail;
25299 }
25300 resultobj = SWIG_From_int(static_cast< int >(result));
25301 return resultobj;
25302 fail:
25303 return NULL;
25304 }
25305
25306
25307 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25308 PyObject *resultobj = 0;
25309 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25310 int result;
25311 void *argp1 = 0 ;
25312 int res1 = 0 ;
25313 PyObject *swig_obj[1] ;
25314
25315 if (!args) SWIG_fail;
25316 swig_obj[0] = args;
25317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25318 if (!SWIG_IsOK(res1)) {
25319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25320 }
25321 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25322 {
25323 PyThreadState* __tstate = wxPyBeginAllowThreads();
25324 result = (int)((wxKeyEvent const *)arg1)->GetY();
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 resultobj = SWIG_From_int(static_cast< int >(result));
25329 return resultobj;
25330 fail:
25331 return NULL;
25332 }
25333
25334
25335 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *resultobj = 0;
25337 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25338 int arg2 ;
25339 void *argp1 = 0 ;
25340 int res1 = 0 ;
25341 int val2 ;
25342 int ecode2 = 0 ;
25343 PyObject *swig_obj[2] ;
25344
25345 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25347 if (!SWIG_IsOK(res1)) {
25348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25349 }
25350 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25351 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25352 if (!SWIG_IsOK(ecode2)) {
25353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25354 }
25355 arg2 = static_cast< int >(val2);
25356 if (arg1) (arg1)->m_x = arg2;
25357
25358 resultobj = SWIG_Py_Void();
25359 return resultobj;
25360 fail:
25361 return NULL;
25362 }
25363
25364
25365 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25366 PyObject *resultobj = 0;
25367 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25368 int result;
25369 void *argp1 = 0 ;
25370 int res1 = 0 ;
25371 PyObject *swig_obj[1] ;
25372
25373 if (!args) SWIG_fail;
25374 swig_obj[0] = args;
25375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25376 if (!SWIG_IsOK(res1)) {
25377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25378 }
25379 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25380 result = (int) ((arg1)->m_x);
25381 resultobj = SWIG_From_int(static_cast< int >(result));
25382 return resultobj;
25383 fail:
25384 return NULL;
25385 }
25386
25387
25388 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25389 PyObject *resultobj = 0;
25390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25391 int arg2 ;
25392 void *argp1 = 0 ;
25393 int res1 = 0 ;
25394 int val2 ;
25395 int ecode2 = 0 ;
25396 PyObject *swig_obj[2] ;
25397
25398 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25400 if (!SWIG_IsOK(res1)) {
25401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25402 }
25403 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25404 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25405 if (!SWIG_IsOK(ecode2)) {
25406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25407 }
25408 arg2 = static_cast< int >(val2);
25409 if (arg1) (arg1)->m_y = arg2;
25410
25411 resultobj = SWIG_Py_Void();
25412 return resultobj;
25413 fail:
25414 return NULL;
25415 }
25416
25417
25418 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25419 PyObject *resultobj = 0;
25420 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25421 int result;
25422 void *argp1 = 0 ;
25423 int res1 = 0 ;
25424 PyObject *swig_obj[1] ;
25425
25426 if (!args) SWIG_fail;
25427 swig_obj[0] = args;
25428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25429 if (!SWIG_IsOK(res1)) {
25430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25431 }
25432 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25433 result = (int) ((arg1)->m_y);
25434 resultobj = SWIG_From_int(static_cast< int >(result));
25435 return resultobj;
25436 fail:
25437 return NULL;
25438 }
25439
25440
25441 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25442 PyObject *resultobj = 0;
25443 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25444 long arg2 ;
25445 void *argp1 = 0 ;
25446 int res1 = 0 ;
25447 long val2 ;
25448 int ecode2 = 0 ;
25449 PyObject *swig_obj[2] ;
25450
25451 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25453 if (!SWIG_IsOK(res1)) {
25454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25455 }
25456 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25457 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25458 if (!SWIG_IsOK(ecode2)) {
25459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25460 }
25461 arg2 = static_cast< long >(val2);
25462 if (arg1) (arg1)->m_keyCode = arg2;
25463
25464 resultobj = SWIG_Py_Void();
25465 return resultobj;
25466 fail:
25467 return NULL;
25468 }
25469
25470
25471 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 PyObject *resultobj = 0;
25473 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25474 long result;
25475 void *argp1 = 0 ;
25476 int res1 = 0 ;
25477 PyObject *swig_obj[1] ;
25478
25479 if (!args) SWIG_fail;
25480 swig_obj[0] = args;
25481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25482 if (!SWIG_IsOK(res1)) {
25483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25484 }
25485 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25486 result = (long) ((arg1)->m_keyCode);
25487 resultobj = SWIG_From_long(static_cast< long >(result));
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25497 bool arg2 ;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 bool val2 ;
25501 int ecode2 = 0 ;
25502 PyObject *swig_obj[2] ;
25503
25504 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25506 if (!SWIG_IsOK(res1)) {
25507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25508 }
25509 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25510 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25511 if (!SWIG_IsOK(ecode2)) {
25512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25513 }
25514 arg2 = static_cast< bool >(val2);
25515 if (arg1) (arg1)->m_controlDown = arg2;
25516
25517 resultobj = SWIG_Py_Void();
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 PyObject *resultobj = 0;
25526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25527 bool result;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 PyObject *swig_obj[1] ;
25531
25532 if (!args) SWIG_fail;
25533 swig_obj[0] = args;
25534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25535 if (!SWIG_IsOK(res1)) {
25536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25537 }
25538 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25539 result = (bool) ((arg1)->m_controlDown);
25540 {
25541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25542 }
25543 return resultobj;
25544 fail:
25545 return NULL;
25546 }
25547
25548
25549 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25550 PyObject *resultobj = 0;
25551 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25552 bool arg2 ;
25553 void *argp1 = 0 ;
25554 int res1 = 0 ;
25555 bool val2 ;
25556 int ecode2 = 0 ;
25557 PyObject *swig_obj[2] ;
25558
25559 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25563 }
25564 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25565 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25566 if (!SWIG_IsOK(ecode2)) {
25567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25568 }
25569 arg2 = static_cast< bool >(val2);
25570 if (arg1) (arg1)->m_shiftDown = arg2;
25571
25572 resultobj = SWIG_Py_Void();
25573 return resultobj;
25574 fail:
25575 return NULL;
25576 }
25577
25578
25579 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25580 PyObject *resultobj = 0;
25581 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25582 bool result;
25583 void *argp1 = 0 ;
25584 int res1 = 0 ;
25585 PyObject *swig_obj[1] ;
25586
25587 if (!args) SWIG_fail;
25588 swig_obj[0] = args;
25589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25590 if (!SWIG_IsOK(res1)) {
25591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25592 }
25593 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25594 result = (bool) ((arg1)->m_shiftDown);
25595 {
25596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25597 }
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25605 PyObject *resultobj = 0;
25606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25607 bool arg2 ;
25608 void *argp1 = 0 ;
25609 int res1 = 0 ;
25610 bool val2 ;
25611 int ecode2 = 0 ;
25612 PyObject *swig_obj[2] ;
25613
25614 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25618 }
25619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25620 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25621 if (!SWIG_IsOK(ecode2)) {
25622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25623 }
25624 arg2 = static_cast< bool >(val2);
25625 if (arg1) (arg1)->m_altDown = arg2;
25626
25627 resultobj = SWIG_Py_Void();
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25635 PyObject *resultobj = 0;
25636 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25637 bool result;
25638 void *argp1 = 0 ;
25639 int res1 = 0 ;
25640 PyObject *swig_obj[1] ;
25641
25642 if (!args) SWIG_fail;
25643 swig_obj[0] = args;
25644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25645 if (!SWIG_IsOK(res1)) {
25646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25647 }
25648 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25649 result = (bool) ((arg1)->m_altDown);
25650 {
25651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25652 }
25653 return resultobj;
25654 fail:
25655 return NULL;
25656 }
25657
25658
25659 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25660 PyObject *resultobj = 0;
25661 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25662 bool arg2 ;
25663 void *argp1 = 0 ;
25664 int res1 = 0 ;
25665 bool val2 ;
25666 int ecode2 = 0 ;
25667 PyObject *swig_obj[2] ;
25668
25669 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25671 if (!SWIG_IsOK(res1)) {
25672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25673 }
25674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25675 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25676 if (!SWIG_IsOK(ecode2)) {
25677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25678 }
25679 arg2 = static_cast< bool >(val2);
25680 if (arg1) (arg1)->m_metaDown = arg2;
25681
25682 resultobj = SWIG_Py_Void();
25683 return resultobj;
25684 fail:
25685 return NULL;
25686 }
25687
25688
25689 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25690 PyObject *resultobj = 0;
25691 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25692 bool result;
25693 void *argp1 = 0 ;
25694 int res1 = 0 ;
25695 PyObject *swig_obj[1] ;
25696
25697 if (!args) SWIG_fail;
25698 swig_obj[0] = args;
25699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25700 if (!SWIG_IsOK(res1)) {
25701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25702 }
25703 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25704 result = (bool) ((arg1)->m_metaDown);
25705 {
25706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25707 }
25708 return resultobj;
25709 fail:
25710 return NULL;
25711 }
25712
25713
25714 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25715 PyObject *resultobj = 0;
25716 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25717 bool arg2 ;
25718 void *argp1 = 0 ;
25719 int res1 = 0 ;
25720 bool val2 ;
25721 int ecode2 = 0 ;
25722 PyObject *swig_obj[2] ;
25723
25724 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25726 if (!SWIG_IsOK(res1)) {
25727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25728 }
25729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25730 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25731 if (!SWIG_IsOK(ecode2)) {
25732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25733 }
25734 arg2 = static_cast< bool >(val2);
25735 if (arg1) (arg1)->m_scanCode = arg2;
25736
25737 resultobj = SWIG_Py_Void();
25738 return resultobj;
25739 fail:
25740 return NULL;
25741 }
25742
25743
25744 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25745 PyObject *resultobj = 0;
25746 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25747 bool result;
25748 void *argp1 = 0 ;
25749 int res1 = 0 ;
25750 PyObject *swig_obj[1] ;
25751
25752 if (!args) SWIG_fail;
25753 swig_obj[0] = args;
25754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25755 if (!SWIG_IsOK(res1)) {
25756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25757 }
25758 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25759 result = (bool) ((arg1)->m_scanCode);
25760 {
25761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25762 }
25763 return resultobj;
25764 fail:
25765 return NULL;
25766 }
25767
25768
25769 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25770 PyObject *resultobj = 0;
25771 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25772 unsigned int arg2 ;
25773 void *argp1 = 0 ;
25774 int res1 = 0 ;
25775 unsigned int val2 ;
25776 int ecode2 = 0 ;
25777 PyObject *swig_obj[2] ;
25778
25779 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25781 if (!SWIG_IsOK(res1)) {
25782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25783 }
25784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25785 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25786 if (!SWIG_IsOK(ecode2)) {
25787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25788 }
25789 arg2 = static_cast< unsigned int >(val2);
25790 if (arg1) (arg1)->m_rawCode = arg2;
25791
25792 resultobj = SWIG_Py_Void();
25793 return resultobj;
25794 fail:
25795 return NULL;
25796 }
25797
25798
25799 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25800 PyObject *resultobj = 0;
25801 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25802 unsigned int result;
25803 void *argp1 = 0 ;
25804 int res1 = 0 ;
25805 PyObject *swig_obj[1] ;
25806
25807 if (!args) SWIG_fail;
25808 swig_obj[0] = args;
25809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25810 if (!SWIG_IsOK(res1)) {
25811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25812 }
25813 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25814 result = (unsigned int) ((arg1)->m_rawCode);
25815 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25816 return resultobj;
25817 fail:
25818 return NULL;
25819 }
25820
25821
25822 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25823 PyObject *resultobj = 0;
25824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25825 unsigned int arg2 ;
25826 void *argp1 = 0 ;
25827 int res1 = 0 ;
25828 unsigned int val2 ;
25829 int ecode2 = 0 ;
25830 PyObject *swig_obj[2] ;
25831
25832 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25834 if (!SWIG_IsOK(res1)) {
25835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25836 }
25837 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25838 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25839 if (!SWIG_IsOK(ecode2)) {
25840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25841 }
25842 arg2 = static_cast< unsigned int >(val2);
25843 if (arg1) (arg1)->m_rawFlags = arg2;
25844
25845 resultobj = SWIG_Py_Void();
25846 return resultobj;
25847 fail:
25848 return NULL;
25849 }
25850
25851
25852 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25853 PyObject *resultobj = 0;
25854 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25855 unsigned int result;
25856 void *argp1 = 0 ;
25857 int res1 = 0 ;
25858 PyObject *swig_obj[1] ;
25859
25860 if (!args) SWIG_fail;
25861 swig_obj[0] = args;
25862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25863 if (!SWIG_IsOK(res1)) {
25864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25865 }
25866 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25867 result = (unsigned int) ((arg1)->m_rawFlags);
25868 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25869 return resultobj;
25870 fail:
25871 return NULL;
25872 }
25873
25874
25875 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25876 PyObject *obj;
25877 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25878 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25879 return SWIG_Py_Void();
25880 }
25881
25882 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25883 return SWIG_Python_InitShadowInstance(args);
25884 }
25885
25886 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25887 PyObject *resultobj = 0;
25888 wxSize const &arg1_defvalue = wxDefaultSize ;
25889 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25890 int arg2 = (int) 0 ;
25891 wxSizeEvent *result = 0 ;
25892 wxSize temp1 ;
25893 int val2 ;
25894 int ecode2 = 0 ;
25895 PyObject * obj0 = 0 ;
25896 PyObject * obj1 = 0 ;
25897 char * kwnames[] = {
25898 (char *) "sz",(char *) "winid", NULL
25899 };
25900
25901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25902 if (obj0) {
25903 {
25904 arg1 = &temp1;
25905 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25906 }
25907 }
25908 if (obj1) {
25909 ecode2 = SWIG_AsVal_int(obj1, &val2);
25910 if (!SWIG_IsOK(ecode2)) {
25911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25912 }
25913 arg2 = static_cast< int >(val2);
25914 }
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25918 wxPyEndAllowThreads(__tstate);
25919 if (PyErr_Occurred()) SWIG_fail;
25920 }
25921 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25922 return resultobj;
25923 fail:
25924 return NULL;
25925 }
25926
25927
25928 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25929 PyObject *resultobj = 0;
25930 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25931 wxSize result;
25932 void *argp1 = 0 ;
25933 int res1 = 0 ;
25934 PyObject *swig_obj[1] ;
25935
25936 if (!args) SWIG_fail;
25937 swig_obj[0] = args;
25938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25939 if (!SWIG_IsOK(res1)) {
25940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25941 }
25942 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25943 {
25944 PyThreadState* __tstate = wxPyBeginAllowThreads();
25945 result = ((wxSizeEvent const *)arg1)->GetSize();
25946 wxPyEndAllowThreads(__tstate);
25947 if (PyErr_Occurred()) SWIG_fail;
25948 }
25949 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25950 return resultobj;
25951 fail:
25952 return NULL;
25953 }
25954
25955
25956 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25957 PyObject *resultobj = 0;
25958 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25959 wxRect result;
25960 void *argp1 = 0 ;
25961 int res1 = 0 ;
25962 PyObject *swig_obj[1] ;
25963
25964 if (!args) SWIG_fail;
25965 swig_obj[0] = args;
25966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25967 if (!SWIG_IsOK(res1)) {
25968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25969 }
25970 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 result = ((wxSizeEvent const *)arg1)->GetRect();
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25985 PyObject *resultobj = 0;
25986 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25987 wxRect arg2 ;
25988 void *argp1 = 0 ;
25989 int res1 = 0 ;
25990 void *argp2 ;
25991 int res2 = 0 ;
25992 PyObject * obj0 = 0 ;
25993 PyObject * obj1 = 0 ;
25994 char * kwnames[] = {
25995 (char *) "self",(char *) "rect", NULL
25996 };
25997
25998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
25999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26000 if (!SWIG_IsOK(res1)) {
26001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26002 }
26003 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26004 {
26005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26006 if (!SWIG_IsOK(res2)) {
26007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26008 }
26009 if (!argp2) {
26010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26011 } else {
26012 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26013 arg2 = *temp;
26014 if (SWIG_IsNewObj(res2)) delete temp;
26015 }
26016 }
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 (arg1)->SetRect(arg2);
26020 wxPyEndAllowThreads(__tstate);
26021 if (PyErr_Occurred()) SWIG_fail;
26022 }
26023 resultobj = SWIG_Py_Void();
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26031 PyObject *resultobj = 0;
26032 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26033 wxSize arg2 ;
26034 void *argp1 = 0 ;
26035 int res1 = 0 ;
26036 void *argp2 ;
26037 int res2 = 0 ;
26038 PyObject * obj0 = 0 ;
26039 PyObject * obj1 = 0 ;
26040 char * kwnames[] = {
26041 (char *) "self",(char *) "size", NULL
26042 };
26043
26044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26046 if (!SWIG_IsOK(res1)) {
26047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26048 }
26049 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26050 {
26051 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26052 if (!SWIG_IsOK(res2)) {
26053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26054 }
26055 if (!argp2) {
26056 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26057 } else {
26058 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26059 arg2 = *temp;
26060 if (SWIG_IsNewObj(res2)) delete temp;
26061 }
26062 }
26063 {
26064 PyThreadState* __tstate = wxPyBeginAllowThreads();
26065 wxSizeEvent_SetSize(arg1,arg2);
26066 wxPyEndAllowThreads(__tstate);
26067 if (PyErr_Occurred()) SWIG_fail;
26068 }
26069 resultobj = SWIG_Py_Void();
26070 return resultobj;
26071 fail:
26072 return NULL;
26073 }
26074
26075
26076 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26077 PyObject *resultobj = 0;
26078 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26079 wxSize *arg2 = (wxSize *) 0 ;
26080 void *argp1 = 0 ;
26081 int res1 = 0 ;
26082 void *argp2 = 0 ;
26083 int res2 = 0 ;
26084 PyObject *swig_obj[2] ;
26085
26086 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26088 if (!SWIG_IsOK(res1)) {
26089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26090 }
26091 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26092 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26093 if (!SWIG_IsOK(res2)) {
26094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26095 }
26096 arg2 = reinterpret_cast< wxSize * >(argp2);
26097 if (arg1) (arg1)->m_size = *arg2;
26098
26099 resultobj = SWIG_Py_Void();
26100 return resultobj;
26101 fail:
26102 return NULL;
26103 }
26104
26105
26106 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26107 PyObject *resultobj = 0;
26108 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26109 wxSize *result = 0 ;
26110 void *argp1 = 0 ;
26111 int res1 = 0 ;
26112 PyObject *swig_obj[1] ;
26113
26114 if (!args) SWIG_fail;
26115 swig_obj[0] = args;
26116 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26117 if (!SWIG_IsOK(res1)) {
26118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26119 }
26120 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26121 result = (wxSize *)& ((arg1)->m_size);
26122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26123 return resultobj;
26124 fail:
26125 return NULL;
26126 }
26127
26128
26129 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26130 PyObject *resultobj = 0;
26131 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26132 wxRect *arg2 = (wxRect *) 0 ;
26133 void *argp1 = 0 ;
26134 int res1 = 0 ;
26135 void *argp2 = 0 ;
26136 int res2 = 0 ;
26137 PyObject *swig_obj[2] ;
26138
26139 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26141 if (!SWIG_IsOK(res1)) {
26142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26143 }
26144 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26145 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26146 if (!SWIG_IsOK(res2)) {
26147 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26148 }
26149 arg2 = reinterpret_cast< wxRect * >(argp2);
26150 if (arg1) (arg1)->m_rect = *arg2;
26151
26152 resultobj = SWIG_Py_Void();
26153 return resultobj;
26154 fail:
26155 return NULL;
26156 }
26157
26158
26159 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26160 PyObject *resultobj = 0;
26161 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26162 wxRect *result = 0 ;
26163 void *argp1 = 0 ;
26164 int res1 = 0 ;
26165 PyObject *swig_obj[1] ;
26166
26167 if (!args) SWIG_fail;
26168 swig_obj[0] = args;
26169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26172 }
26173 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26174 result = (wxRect *)& ((arg1)->m_rect);
26175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26176 return resultobj;
26177 fail:
26178 return NULL;
26179 }
26180
26181
26182 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26183 PyObject *obj;
26184 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26185 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26186 return SWIG_Py_Void();
26187 }
26188
26189 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26190 return SWIG_Python_InitShadowInstance(args);
26191 }
26192
26193 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26194 PyObject *resultobj = 0;
26195 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26196 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26197 int arg2 = (int) 0 ;
26198 wxMoveEvent *result = 0 ;
26199 wxPoint temp1 ;
26200 int val2 ;
26201 int ecode2 = 0 ;
26202 PyObject * obj0 = 0 ;
26203 PyObject * obj1 = 0 ;
26204 char * kwnames[] = {
26205 (char *) "pos",(char *) "winid", NULL
26206 };
26207
26208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26209 if (obj0) {
26210 {
26211 arg1 = &temp1;
26212 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26213 }
26214 }
26215 if (obj1) {
26216 ecode2 = SWIG_AsVal_int(obj1, &val2);
26217 if (!SWIG_IsOK(ecode2)) {
26218 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26219 }
26220 arg2 = static_cast< int >(val2);
26221 }
26222 {
26223 PyThreadState* __tstate = wxPyBeginAllowThreads();
26224 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26225 wxPyEndAllowThreads(__tstate);
26226 if (PyErr_Occurred()) SWIG_fail;
26227 }
26228 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26229 return resultobj;
26230 fail:
26231 return NULL;
26232 }
26233
26234
26235 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26236 PyObject *resultobj = 0;
26237 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26238 wxPoint result;
26239 void *argp1 = 0 ;
26240 int res1 = 0 ;
26241 PyObject *swig_obj[1] ;
26242
26243 if (!args) SWIG_fail;
26244 swig_obj[0] = args;
26245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26246 if (!SWIG_IsOK(res1)) {
26247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26248 }
26249 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26250 {
26251 PyThreadState* __tstate = wxPyBeginAllowThreads();
26252 result = ((wxMoveEvent const *)arg1)->GetPosition();
26253 wxPyEndAllowThreads(__tstate);
26254 if (PyErr_Occurred()) SWIG_fail;
26255 }
26256 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26257 return resultobj;
26258 fail:
26259 return NULL;
26260 }
26261
26262
26263 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26264 PyObject *resultobj = 0;
26265 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26266 wxRect result;
26267 void *argp1 = 0 ;
26268 int res1 = 0 ;
26269 PyObject *swig_obj[1] ;
26270
26271 if (!args) SWIG_fail;
26272 swig_obj[0] = args;
26273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26274 if (!SWIG_IsOK(res1)) {
26275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26276 }
26277 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26278 {
26279 PyThreadState* __tstate = wxPyBeginAllowThreads();
26280 result = ((wxMoveEvent const *)arg1)->GetRect();
26281 wxPyEndAllowThreads(__tstate);
26282 if (PyErr_Occurred()) SWIG_fail;
26283 }
26284 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26285 return resultobj;
26286 fail:
26287 return NULL;
26288 }
26289
26290
26291 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26292 PyObject *resultobj = 0;
26293 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26294 wxRect *arg2 = 0 ;
26295 void *argp1 = 0 ;
26296 int res1 = 0 ;
26297 wxRect temp2 ;
26298 PyObject * obj0 = 0 ;
26299 PyObject * obj1 = 0 ;
26300 char * kwnames[] = {
26301 (char *) "self",(char *) "rect", NULL
26302 };
26303
26304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26306 if (!SWIG_IsOK(res1)) {
26307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26308 }
26309 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26310 {
26311 arg2 = &temp2;
26312 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26313 }
26314 {
26315 PyThreadState* __tstate = wxPyBeginAllowThreads();
26316 (arg1)->SetRect((wxRect const &)*arg2);
26317 wxPyEndAllowThreads(__tstate);
26318 if (PyErr_Occurred()) SWIG_fail;
26319 }
26320 resultobj = SWIG_Py_Void();
26321 return resultobj;
26322 fail:
26323 return NULL;
26324 }
26325
26326
26327 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26328 PyObject *resultobj = 0;
26329 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26330 wxPoint *arg2 = 0 ;
26331 void *argp1 = 0 ;
26332 int res1 = 0 ;
26333 wxPoint temp2 ;
26334 PyObject * obj0 = 0 ;
26335 PyObject * obj1 = 0 ;
26336 char * kwnames[] = {
26337 (char *) "self",(char *) "pos", NULL
26338 };
26339
26340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26342 if (!SWIG_IsOK(res1)) {
26343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26344 }
26345 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26346 {
26347 arg2 = &temp2;
26348 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26349 }
26350 {
26351 PyThreadState* __tstate = wxPyBeginAllowThreads();
26352 (arg1)->SetPosition((wxPoint const &)*arg2);
26353 wxPyEndAllowThreads(__tstate);
26354 if (PyErr_Occurred()) SWIG_fail;
26355 }
26356 resultobj = SWIG_Py_Void();
26357 return resultobj;
26358 fail:
26359 return NULL;
26360 }
26361
26362
26363 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26364 PyObject *obj;
26365 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26366 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26367 return SWIG_Py_Void();
26368 }
26369
26370 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26371 return SWIG_Python_InitShadowInstance(args);
26372 }
26373
26374 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26375 PyObject *resultobj = 0;
26376 int arg1 = (int) 0 ;
26377 wxPaintEvent *result = 0 ;
26378 int val1 ;
26379 int ecode1 = 0 ;
26380 PyObject * obj0 = 0 ;
26381 char * kwnames[] = {
26382 (char *) "Id", NULL
26383 };
26384
26385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26386 if (obj0) {
26387 ecode1 = SWIG_AsVal_int(obj0, &val1);
26388 if (!SWIG_IsOK(ecode1)) {
26389 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26390 }
26391 arg1 = static_cast< int >(val1);
26392 }
26393 {
26394 PyThreadState* __tstate = wxPyBeginAllowThreads();
26395 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26396 wxPyEndAllowThreads(__tstate);
26397 if (PyErr_Occurred()) SWIG_fail;
26398 }
26399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26400 return resultobj;
26401 fail:
26402 return NULL;
26403 }
26404
26405
26406 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26407 PyObject *obj;
26408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26409 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26410 return SWIG_Py_Void();
26411 }
26412
26413 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26414 return SWIG_Python_InitShadowInstance(args);
26415 }
26416
26417 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26418 PyObject *resultobj = 0;
26419 int arg1 = (int) 0 ;
26420 wxNcPaintEvent *result = 0 ;
26421 int val1 ;
26422 int ecode1 = 0 ;
26423 PyObject * obj0 = 0 ;
26424 char * kwnames[] = {
26425 (char *) "winid", NULL
26426 };
26427
26428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26429 if (obj0) {
26430 ecode1 = SWIG_AsVal_int(obj0, &val1);
26431 if (!SWIG_IsOK(ecode1)) {
26432 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26433 }
26434 arg1 = static_cast< int >(val1);
26435 }
26436 {
26437 PyThreadState* __tstate = wxPyBeginAllowThreads();
26438 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26439 wxPyEndAllowThreads(__tstate);
26440 if (PyErr_Occurred()) SWIG_fail;
26441 }
26442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26443 return resultobj;
26444 fail:
26445 return NULL;
26446 }
26447
26448
26449 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26450 PyObject *obj;
26451 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26452 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26453 return SWIG_Py_Void();
26454 }
26455
26456 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26457 return SWIG_Python_InitShadowInstance(args);
26458 }
26459
26460 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26461 PyObject *resultobj = 0;
26462 int arg1 = (int) 0 ;
26463 wxDC *arg2 = (wxDC *) NULL ;
26464 wxEraseEvent *result = 0 ;
26465 int val1 ;
26466 int ecode1 = 0 ;
26467 void *argp2 = 0 ;
26468 int res2 = 0 ;
26469 PyObject * obj0 = 0 ;
26470 PyObject * obj1 = 0 ;
26471 char * kwnames[] = {
26472 (char *) "Id",(char *) "dc", NULL
26473 };
26474
26475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26476 if (obj0) {
26477 ecode1 = SWIG_AsVal_int(obj0, &val1);
26478 if (!SWIG_IsOK(ecode1)) {
26479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26480 }
26481 arg1 = static_cast< int >(val1);
26482 }
26483 if (obj1) {
26484 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26485 if (!SWIG_IsOK(res2)) {
26486 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26487 }
26488 arg2 = reinterpret_cast< wxDC * >(argp2);
26489 }
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26493 wxPyEndAllowThreads(__tstate);
26494 if (PyErr_Occurred()) SWIG_fail;
26495 }
26496 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26497 return resultobj;
26498 fail:
26499 return NULL;
26500 }
26501
26502
26503 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26504 PyObject *resultobj = 0;
26505 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26506 wxDC *result = 0 ;
26507 void *argp1 = 0 ;
26508 int res1 = 0 ;
26509 PyObject *swig_obj[1] ;
26510
26511 if (!args) SWIG_fail;
26512 swig_obj[0] = args;
26513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26514 if (!SWIG_IsOK(res1)) {
26515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26516 }
26517 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26521 wxPyEndAllowThreads(__tstate);
26522 if (PyErr_Occurred()) SWIG_fail;
26523 }
26524 {
26525 resultobj = wxPyMake_wxObject(result, (bool)0);
26526 }
26527 return resultobj;
26528 fail:
26529 return NULL;
26530 }
26531
26532
26533 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26534 PyObject *obj;
26535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26536 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26537 return SWIG_Py_Void();
26538 }
26539
26540 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26541 return SWIG_Python_InitShadowInstance(args);
26542 }
26543
26544 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26545 PyObject *resultobj = 0;
26546 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26547 int arg2 = (int) 0 ;
26548 wxFocusEvent *result = 0 ;
26549 int val1 ;
26550 int ecode1 = 0 ;
26551 int val2 ;
26552 int ecode2 = 0 ;
26553 PyObject * obj0 = 0 ;
26554 PyObject * obj1 = 0 ;
26555 char * kwnames[] = {
26556 (char *) "type",(char *) "winid", NULL
26557 };
26558
26559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26560 if (obj0) {
26561 ecode1 = SWIG_AsVal_int(obj0, &val1);
26562 if (!SWIG_IsOK(ecode1)) {
26563 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26564 }
26565 arg1 = static_cast< wxEventType >(val1);
26566 }
26567 if (obj1) {
26568 ecode2 = SWIG_AsVal_int(obj1, &val2);
26569 if (!SWIG_IsOK(ecode2)) {
26570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26571 }
26572 arg2 = static_cast< int >(val2);
26573 }
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26577 wxPyEndAllowThreads(__tstate);
26578 if (PyErr_Occurred()) SWIG_fail;
26579 }
26580 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26581 return resultobj;
26582 fail:
26583 return NULL;
26584 }
26585
26586
26587 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26588 PyObject *resultobj = 0;
26589 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26590 wxWindow *result = 0 ;
26591 void *argp1 = 0 ;
26592 int res1 = 0 ;
26593 PyObject *swig_obj[1] ;
26594
26595 if (!args) SWIG_fail;
26596 swig_obj[0] = args;
26597 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26598 if (!SWIG_IsOK(res1)) {
26599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26600 }
26601 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26605 wxPyEndAllowThreads(__tstate);
26606 if (PyErr_Occurred()) SWIG_fail;
26607 }
26608 {
26609 resultobj = wxPyMake_wxObject(result, (bool)0);
26610 }
26611 return resultobj;
26612 fail:
26613 return NULL;
26614 }
26615
26616
26617 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26618 PyObject *resultobj = 0;
26619 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26620 wxWindow *arg2 = (wxWindow *) 0 ;
26621 void *argp1 = 0 ;
26622 int res1 = 0 ;
26623 void *argp2 = 0 ;
26624 int res2 = 0 ;
26625 PyObject * obj0 = 0 ;
26626 PyObject * obj1 = 0 ;
26627 char * kwnames[] = {
26628 (char *) "self",(char *) "win", NULL
26629 };
26630
26631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26633 if (!SWIG_IsOK(res1)) {
26634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26635 }
26636 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26638 if (!SWIG_IsOK(res2)) {
26639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26640 }
26641 arg2 = reinterpret_cast< wxWindow * >(argp2);
26642 {
26643 PyThreadState* __tstate = wxPyBeginAllowThreads();
26644 (arg1)->SetWindow(arg2);
26645 wxPyEndAllowThreads(__tstate);
26646 if (PyErr_Occurred()) SWIG_fail;
26647 }
26648 resultobj = SWIG_Py_Void();
26649 return resultobj;
26650 fail:
26651 return NULL;
26652 }
26653
26654
26655 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26656 PyObject *obj;
26657 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26658 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26659 return SWIG_Py_Void();
26660 }
26661
26662 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26663 return SWIG_Python_InitShadowInstance(args);
26664 }
26665
26666 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj = 0;
26668 wxWindow *arg1 = (wxWindow *) NULL ;
26669 wxChildFocusEvent *result = 0 ;
26670 void *argp1 = 0 ;
26671 int res1 = 0 ;
26672 PyObject * obj0 = 0 ;
26673 char * kwnames[] = {
26674 (char *) "win", NULL
26675 };
26676
26677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26678 if (obj0) {
26679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26680 if (!SWIG_IsOK(res1)) {
26681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26682 }
26683 arg1 = reinterpret_cast< wxWindow * >(argp1);
26684 }
26685 {
26686 PyThreadState* __tstate = wxPyBeginAllowThreads();
26687 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26699 PyObject *resultobj = 0;
26700 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26701 wxWindow *result = 0 ;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 PyObject *swig_obj[1] ;
26705
26706 if (!args) SWIG_fail;
26707 swig_obj[0] = args;
26708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26709 if (!SWIG_IsOK(res1)) {
26710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26711 }
26712 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26713 {
26714 PyThreadState* __tstate = wxPyBeginAllowThreads();
26715 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26716 wxPyEndAllowThreads(__tstate);
26717 if (PyErr_Occurred()) SWIG_fail;
26718 }
26719 {
26720 resultobj = wxPyMake_wxObject(result, (bool)0);
26721 }
26722 return resultobj;
26723 fail:
26724 return NULL;
26725 }
26726
26727
26728 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26729 PyObject *obj;
26730 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26731 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26732 return SWIG_Py_Void();
26733 }
26734
26735 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26736 return SWIG_Python_InitShadowInstance(args);
26737 }
26738
26739 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26740 PyObject *resultobj = 0;
26741 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26742 bool arg2 = (bool) true ;
26743 int arg3 = (int) 0 ;
26744 wxActivateEvent *result = 0 ;
26745 int val1 ;
26746 int ecode1 = 0 ;
26747 bool val2 ;
26748 int ecode2 = 0 ;
26749 int val3 ;
26750 int ecode3 = 0 ;
26751 PyObject * obj0 = 0 ;
26752 PyObject * obj1 = 0 ;
26753 PyObject * obj2 = 0 ;
26754 char * kwnames[] = {
26755 (char *) "type",(char *) "active",(char *) "Id", NULL
26756 };
26757
26758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26759 if (obj0) {
26760 ecode1 = SWIG_AsVal_int(obj0, &val1);
26761 if (!SWIG_IsOK(ecode1)) {
26762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26763 }
26764 arg1 = static_cast< wxEventType >(val1);
26765 }
26766 if (obj1) {
26767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26768 if (!SWIG_IsOK(ecode2)) {
26769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26770 }
26771 arg2 = static_cast< bool >(val2);
26772 }
26773 if (obj2) {
26774 ecode3 = SWIG_AsVal_int(obj2, &val3);
26775 if (!SWIG_IsOK(ecode3)) {
26776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26777 }
26778 arg3 = static_cast< int >(val3);
26779 }
26780 {
26781 PyThreadState* __tstate = wxPyBeginAllowThreads();
26782 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26783 wxPyEndAllowThreads(__tstate);
26784 if (PyErr_Occurred()) SWIG_fail;
26785 }
26786 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26787 return resultobj;
26788 fail:
26789 return NULL;
26790 }
26791
26792
26793 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26794 PyObject *resultobj = 0;
26795 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26796 bool result;
26797 void *argp1 = 0 ;
26798 int res1 = 0 ;
26799 PyObject *swig_obj[1] ;
26800
26801 if (!args) SWIG_fail;
26802 swig_obj[0] = args;
26803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26804 if (!SWIG_IsOK(res1)) {
26805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26806 }
26807 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26808 {
26809 PyThreadState* __tstate = wxPyBeginAllowThreads();
26810 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26811 wxPyEndAllowThreads(__tstate);
26812 if (PyErr_Occurred()) SWIG_fail;
26813 }
26814 {
26815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26816 }
26817 return resultobj;
26818 fail:
26819 return NULL;
26820 }
26821
26822
26823 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26824 PyObject *obj;
26825 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26826 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26827 return SWIG_Py_Void();
26828 }
26829
26830 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26831 return SWIG_Python_InitShadowInstance(args);
26832 }
26833
26834 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26835 PyObject *resultobj = 0;
26836 int arg1 = (int) 0 ;
26837 wxInitDialogEvent *result = 0 ;
26838 int val1 ;
26839 int ecode1 = 0 ;
26840 PyObject * obj0 = 0 ;
26841 char * kwnames[] = {
26842 (char *) "Id", NULL
26843 };
26844
26845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26846 if (obj0) {
26847 ecode1 = SWIG_AsVal_int(obj0, &val1);
26848 if (!SWIG_IsOK(ecode1)) {
26849 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26850 }
26851 arg1 = static_cast< int >(val1);
26852 }
26853 {
26854 PyThreadState* __tstate = wxPyBeginAllowThreads();
26855 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26856 wxPyEndAllowThreads(__tstate);
26857 if (PyErr_Occurred()) SWIG_fail;
26858 }
26859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26860 return resultobj;
26861 fail:
26862 return NULL;
26863 }
26864
26865
26866 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26867 PyObject *obj;
26868 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26869 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26870 return SWIG_Py_Void();
26871 }
26872
26873 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26874 return SWIG_Python_InitShadowInstance(args);
26875 }
26876
26877 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26878 PyObject *resultobj = 0;
26879 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26880 int arg2 = (int) 0 ;
26881 wxMenu *arg3 = (wxMenu *) NULL ;
26882 wxMenuEvent *result = 0 ;
26883 int val1 ;
26884 int ecode1 = 0 ;
26885 int val2 ;
26886 int ecode2 = 0 ;
26887 void *argp3 = 0 ;
26888 int res3 = 0 ;
26889 PyObject * obj0 = 0 ;
26890 PyObject * obj1 = 0 ;
26891 PyObject * obj2 = 0 ;
26892 char * kwnames[] = {
26893 (char *) "type",(char *) "winid",(char *) "menu", NULL
26894 };
26895
26896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26897 if (obj0) {
26898 ecode1 = SWIG_AsVal_int(obj0, &val1);
26899 if (!SWIG_IsOK(ecode1)) {
26900 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26901 }
26902 arg1 = static_cast< wxEventType >(val1);
26903 }
26904 if (obj1) {
26905 ecode2 = SWIG_AsVal_int(obj1, &val2);
26906 if (!SWIG_IsOK(ecode2)) {
26907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26908 }
26909 arg2 = static_cast< int >(val2);
26910 }
26911 if (obj2) {
26912 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26913 if (!SWIG_IsOK(res3)) {
26914 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26915 }
26916 arg3 = reinterpret_cast< wxMenu * >(argp3);
26917 }
26918 {
26919 PyThreadState* __tstate = wxPyBeginAllowThreads();
26920 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26921 wxPyEndAllowThreads(__tstate);
26922 if (PyErr_Occurred()) SWIG_fail;
26923 }
26924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26925 return resultobj;
26926 fail:
26927 return NULL;
26928 }
26929
26930
26931 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26932 PyObject *resultobj = 0;
26933 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26934 int result;
26935 void *argp1 = 0 ;
26936 int res1 = 0 ;
26937 PyObject *swig_obj[1] ;
26938
26939 if (!args) SWIG_fail;
26940 swig_obj[0] = args;
26941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26942 if (!SWIG_IsOK(res1)) {
26943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26944 }
26945 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26946 {
26947 PyThreadState* __tstate = wxPyBeginAllowThreads();
26948 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26949 wxPyEndAllowThreads(__tstate);
26950 if (PyErr_Occurred()) SWIG_fail;
26951 }
26952 resultobj = SWIG_From_int(static_cast< int >(result));
26953 return resultobj;
26954 fail:
26955 return NULL;
26956 }
26957
26958
26959 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26960 PyObject *resultobj = 0;
26961 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26962 bool result;
26963 void *argp1 = 0 ;
26964 int res1 = 0 ;
26965 PyObject *swig_obj[1] ;
26966
26967 if (!args) SWIG_fail;
26968 swig_obj[0] = args;
26969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26970 if (!SWIG_IsOK(res1)) {
26971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26972 }
26973 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
26977 wxPyEndAllowThreads(__tstate);
26978 if (PyErr_Occurred()) SWIG_fail;
26979 }
26980 {
26981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26982 }
26983 return resultobj;
26984 fail:
26985 return NULL;
26986 }
26987
26988
26989 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26990 PyObject *resultobj = 0;
26991 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26992 wxMenu *result = 0 ;
26993 void *argp1 = 0 ;
26994 int res1 = 0 ;
26995 PyObject *swig_obj[1] ;
26996
26997 if (!args) SWIG_fail;
26998 swig_obj[0] = args;
26999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27000 if (!SWIG_IsOK(res1)) {
27001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27002 }
27003 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27004 {
27005 PyThreadState* __tstate = wxPyBeginAllowThreads();
27006 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27007 wxPyEndAllowThreads(__tstate);
27008 if (PyErr_Occurred()) SWIG_fail;
27009 }
27010 {
27011 resultobj = wxPyMake_wxObject(result, (bool)0);
27012 }
27013 return resultobj;
27014 fail:
27015 return NULL;
27016 }
27017
27018
27019 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27020 PyObject *obj;
27021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27022 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27023 return SWIG_Py_Void();
27024 }
27025
27026 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27027 return SWIG_Python_InitShadowInstance(args);
27028 }
27029
27030 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27031 PyObject *resultobj = 0;
27032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27033 int arg2 = (int) 0 ;
27034 wxCloseEvent *result = 0 ;
27035 int val1 ;
27036 int ecode1 = 0 ;
27037 int val2 ;
27038 int ecode2 = 0 ;
27039 PyObject * obj0 = 0 ;
27040 PyObject * obj1 = 0 ;
27041 char * kwnames[] = {
27042 (char *) "type",(char *) "winid", NULL
27043 };
27044
27045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27046 if (obj0) {
27047 ecode1 = SWIG_AsVal_int(obj0, &val1);
27048 if (!SWIG_IsOK(ecode1)) {
27049 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27050 }
27051 arg1 = static_cast< wxEventType >(val1);
27052 }
27053 if (obj1) {
27054 ecode2 = SWIG_AsVal_int(obj1, &val2);
27055 if (!SWIG_IsOK(ecode2)) {
27056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27057 }
27058 arg2 = static_cast< int >(val2);
27059 }
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj = 0;
27075 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27076 bool arg2 ;
27077 void *argp1 = 0 ;
27078 int res1 = 0 ;
27079 bool val2 ;
27080 int ecode2 = 0 ;
27081 PyObject * obj0 = 0 ;
27082 PyObject * obj1 = 0 ;
27083 char * kwnames[] = {
27084 (char *) "self",(char *) "logOff", NULL
27085 };
27086
27087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27089 if (!SWIG_IsOK(res1)) {
27090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27091 }
27092 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27093 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27094 if (!SWIG_IsOK(ecode2)) {
27095 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27096 }
27097 arg2 = static_cast< bool >(val2);
27098 {
27099 PyThreadState* __tstate = wxPyBeginAllowThreads();
27100 (arg1)->SetLoggingOff(arg2);
27101 wxPyEndAllowThreads(__tstate);
27102 if (PyErr_Occurred()) SWIG_fail;
27103 }
27104 resultobj = SWIG_Py_Void();
27105 return resultobj;
27106 fail:
27107 return NULL;
27108 }
27109
27110
27111 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27112 PyObject *resultobj = 0;
27113 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27114 bool result;
27115 void *argp1 = 0 ;
27116 int res1 = 0 ;
27117 PyObject *swig_obj[1] ;
27118
27119 if (!args) SWIG_fail;
27120 swig_obj[0] = args;
27121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27122 if (!SWIG_IsOK(res1)) {
27123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27124 }
27125 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27126 {
27127 PyThreadState* __tstate = wxPyBeginAllowThreads();
27128 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27129 wxPyEndAllowThreads(__tstate);
27130 if (PyErr_Occurred()) SWIG_fail;
27131 }
27132 {
27133 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27134 }
27135 return resultobj;
27136 fail:
27137 return NULL;
27138 }
27139
27140
27141 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27142 PyObject *resultobj = 0;
27143 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27144 bool arg2 = (bool) true ;
27145 void *argp1 = 0 ;
27146 int res1 = 0 ;
27147 bool val2 ;
27148 int ecode2 = 0 ;
27149 PyObject * obj0 = 0 ;
27150 PyObject * obj1 = 0 ;
27151 char * kwnames[] = {
27152 (char *) "self",(char *) "veto", NULL
27153 };
27154
27155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27157 if (!SWIG_IsOK(res1)) {
27158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27159 }
27160 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27161 if (obj1) {
27162 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27163 if (!SWIG_IsOK(ecode2)) {
27164 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27165 }
27166 arg2 = static_cast< bool >(val2);
27167 }
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 (arg1)->Veto(arg2);
27171 wxPyEndAllowThreads(__tstate);
27172 if (PyErr_Occurred()) SWIG_fail;
27173 }
27174 resultobj = SWIG_Py_Void();
27175 return resultobj;
27176 fail:
27177 return NULL;
27178 }
27179
27180
27181 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27182 PyObject *resultobj = 0;
27183 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27184 bool result;
27185 void *argp1 = 0 ;
27186 int res1 = 0 ;
27187 PyObject *swig_obj[1] ;
27188
27189 if (!args) SWIG_fail;
27190 swig_obj[0] = args;
27191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27192 if (!SWIG_IsOK(res1)) {
27193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27194 }
27195 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27199 wxPyEndAllowThreads(__tstate);
27200 if (PyErr_Occurred()) SWIG_fail;
27201 }
27202 {
27203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27204 }
27205 return resultobj;
27206 fail:
27207 return NULL;
27208 }
27209
27210
27211 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27212 PyObject *resultobj = 0;
27213 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27214 bool arg2 ;
27215 void *argp1 = 0 ;
27216 int res1 = 0 ;
27217 bool val2 ;
27218 int ecode2 = 0 ;
27219 PyObject * obj0 = 0 ;
27220 PyObject * obj1 = 0 ;
27221 char * kwnames[] = {
27222 (char *) "self",(char *) "canVeto", NULL
27223 };
27224
27225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27227 if (!SWIG_IsOK(res1)) {
27228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27229 }
27230 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27231 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27232 if (!SWIG_IsOK(ecode2)) {
27233 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27234 }
27235 arg2 = static_cast< bool >(val2);
27236 {
27237 PyThreadState* __tstate = wxPyBeginAllowThreads();
27238 (arg1)->SetCanVeto(arg2);
27239 wxPyEndAllowThreads(__tstate);
27240 if (PyErr_Occurred()) SWIG_fail;
27241 }
27242 resultobj = SWIG_Py_Void();
27243 return resultobj;
27244 fail:
27245 return NULL;
27246 }
27247
27248
27249 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27250 PyObject *resultobj = 0;
27251 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27252 bool result;
27253 void *argp1 = 0 ;
27254 int res1 = 0 ;
27255 PyObject *swig_obj[1] ;
27256
27257 if (!args) SWIG_fail;
27258 swig_obj[0] = args;
27259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27260 if (!SWIG_IsOK(res1)) {
27261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27262 }
27263 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27264 {
27265 PyThreadState* __tstate = wxPyBeginAllowThreads();
27266 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27267 wxPyEndAllowThreads(__tstate);
27268 if (PyErr_Occurred()) SWIG_fail;
27269 }
27270 {
27271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27272 }
27273 return resultobj;
27274 fail:
27275 return NULL;
27276 }
27277
27278
27279 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27280 PyObject *obj;
27281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27282 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27283 return SWIG_Py_Void();
27284 }
27285
27286 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27287 return SWIG_Python_InitShadowInstance(args);
27288 }
27289
27290 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27291 PyObject *resultobj = 0;
27292 int arg1 = (int) 0 ;
27293 bool arg2 = (bool) false ;
27294 wxShowEvent *result = 0 ;
27295 int val1 ;
27296 int ecode1 = 0 ;
27297 bool val2 ;
27298 int ecode2 = 0 ;
27299 PyObject * obj0 = 0 ;
27300 PyObject * obj1 = 0 ;
27301 char * kwnames[] = {
27302 (char *) "winid",(char *) "show", NULL
27303 };
27304
27305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27306 if (obj0) {
27307 ecode1 = SWIG_AsVal_int(obj0, &val1);
27308 if (!SWIG_IsOK(ecode1)) {
27309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27310 }
27311 arg1 = static_cast< int >(val1);
27312 }
27313 if (obj1) {
27314 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27315 if (!SWIG_IsOK(ecode2)) {
27316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27317 }
27318 arg2 = static_cast< bool >(val2);
27319 }
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27323 wxPyEndAllowThreads(__tstate);
27324 if (PyErr_Occurred()) SWIG_fail;
27325 }
27326 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27327 return resultobj;
27328 fail:
27329 return NULL;
27330 }
27331
27332
27333 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27334 PyObject *resultobj = 0;
27335 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27336 bool arg2 ;
27337 void *argp1 = 0 ;
27338 int res1 = 0 ;
27339 bool val2 ;
27340 int ecode2 = 0 ;
27341 PyObject * obj0 = 0 ;
27342 PyObject * obj1 = 0 ;
27343 char * kwnames[] = {
27344 (char *) "self",(char *) "show", NULL
27345 };
27346
27347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27349 if (!SWIG_IsOK(res1)) {
27350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27351 }
27352 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27353 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27354 if (!SWIG_IsOK(ecode2)) {
27355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27356 }
27357 arg2 = static_cast< bool >(val2);
27358 {
27359 PyThreadState* __tstate = wxPyBeginAllowThreads();
27360 (arg1)->SetShow(arg2);
27361 wxPyEndAllowThreads(__tstate);
27362 if (PyErr_Occurred()) SWIG_fail;
27363 }
27364 resultobj = SWIG_Py_Void();
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27372 PyObject *resultobj = 0;
27373 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27374 bool result;
27375 void *argp1 = 0 ;
27376 int res1 = 0 ;
27377 PyObject *swig_obj[1] ;
27378
27379 if (!args) SWIG_fail;
27380 swig_obj[0] = args;
27381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27382 if (!SWIG_IsOK(res1)) {
27383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27384 }
27385 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27386 {
27387 PyThreadState* __tstate = wxPyBeginAllowThreads();
27388 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27389 wxPyEndAllowThreads(__tstate);
27390 if (PyErr_Occurred()) SWIG_fail;
27391 }
27392 {
27393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27394 }
27395 return resultobj;
27396 fail:
27397 return NULL;
27398 }
27399
27400
27401 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27402 PyObject *obj;
27403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27404 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27405 return SWIG_Py_Void();
27406 }
27407
27408 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27409 return SWIG_Python_InitShadowInstance(args);
27410 }
27411
27412 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27413 PyObject *resultobj = 0;
27414 int arg1 = (int) 0 ;
27415 bool arg2 = (bool) true ;
27416 wxIconizeEvent *result = 0 ;
27417 int val1 ;
27418 int ecode1 = 0 ;
27419 bool val2 ;
27420 int ecode2 = 0 ;
27421 PyObject * obj0 = 0 ;
27422 PyObject * obj1 = 0 ;
27423 char * kwnames[] = {
27424 (char *) "id",(char *) "iconized", NULL
27425 };
27426
27427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27428 if (obj0) {
27429 ecode1 = SWIG_AsVal_int(obj0, &val1);
27430 if (!SWIG_IsOK(ecode1)) {
27431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27432 }
27433 arg1 = static_cast< int >(val1);
27434 }
27435 if (obj1) {
27436 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27437 if (!SWIG_IsOK(ecode2)) {
27438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27439 }
27440 arg2 = static_cast< bool >(val2);
27441 }
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27445 wxPyEndAllowThreads(__tstate);
27446 if (PyErr_Occurred()) SWIG_fail;
27447 }
27448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27449 return resultobj;
27450 fail:
27451 return NULL;
27452 }
27453
27454
27455 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27456 PyObject *resultobj = 0;
27457 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27458 bool result;
27459 void *argp1 = 0 ;
27460 int res1 = 0 ;
27461 PyObject *swig_obj[1] ;
27462
27463 if (!args) SWIG_fail;
27464 swig_obj[0] = args;
27465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27466 if (!SWIG_IsOK(res1)) {
27467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27468 }
27469 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27470 {
27471 PyThreadState* __tstate = wxPyBeginAllowThreads();
27472 result = (bool)(arg1)->Iconized();
27473 wxPyEndAllowThreads(__tstate);
27474 if (PyErr_Occurred()) SWIG_fail;
27475 }
27476 {
27477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27478 }
27479 return resultobj;
27480 fail:
27481 return NULL;
27482 }
27483
27484
27485 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27486 PyObject *obj;
27487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27488 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27489 return SWIG_Py_Void();
27490 }
27491
27492 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27493 return SWIG_Python_InitShadowInstance(args);
27494 }
27495
27496 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27497 PyObject *resultobj = 0;
27498 int arg1 = (int) 0 ;
27499 wxMaximizeEvent *result = 0 ;
27500 int val1 ;
27501 int ecode1 = 0 ;
27502 PyObject * obj0 = 0 ;
27503 char * kwnames[] = {
27504 (char *) "id", NULL
27505 };
27506
27507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27508 if (obj0) {
27509 ecode1 = SWIG_AsVal_int(obj0, &val1);
27510 if (!SWIG_IsOK(ecode1)) {
27511 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27512 }
27513 arg1 = static_cast< int >(val1);
27514 }
27515 {
27516 PyThreadState* __tstate = wxPyBeginAllowThreads();
27517 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27518 wxPyEndAllowThreads(__tstate);
27519 if (PyErr_Occurred()) SWIG_fail;
27520 }
27521 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27522 return resultobj;
27523 fail:
27524 return NULL;
27525 }
27526
27527
27528 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27529 PyObject *obj;
27530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27531 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27532 return SWIG_Py_Void();
27533 }
27534
27535 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27536 return SWIG_Python_InitShadowInstance(args);
27537 }
27538
27539 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27540 PyObject *resultobj = 0;
27541 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27542 wxPoint result;
27543 void *argp1 = 0 ;
27544 int res1 = 0 ;
27545 PyObject *swig_obj[1] ;
27546
27547 if (!args) SWIG_fail;
27548 swig_obj[0] = args;
27549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27550 if (!SWIG_IsOK(res1)) {
27551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27552 }
27553 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27554 {
27555 PyThreadState* __tstate = wxPyBeginAllowThreads();
27556 result = (arg1)->GetPosition();
27557 wxPyEndAllowThreads(__tstate);
27558 if (PyErr_Occurred()) SWIG_fail;
27559 }
27560 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27561 return resultobj;
27562 fail:
27563 return NULL;
27564 }
27565
27566
27567 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27568 PyObject *resultobj = 0;
27569 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27570 int result;
27571 void *argp1 = 0 ;
27572 int res1 = 0 ;
27573 PyObject *swig_obj[1] ;
27574
27575 if (!args) SWIG_fail;
27576 swig_obj[0] = args;
27577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27578 if (!SWIG_IsOK(res1)) {
27579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27580 }
27581 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27582 {
27583 PyThreadState* __tstate = wxPyBeginAllowThreads();
27584 result = (int)(arg1)->GetNumberOfFiles();
27585 wxPyEndAllowThreads(__tstate);
27586 if (PyErr_Occurred()) SWIG_fail;
27587 }
27588 resultobj = SWIG_From_int(static_cast< int >(result));
27589 return resultobj;
27590 fail:
27591 return NULL;
27592 }
27593
27594
27595 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27596 PyObject *resultobj = 0;
27597 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27598 PyObject *result = 0 ;
27599 void *argp1 = 0 ;
27600 int res1 = 0 ;
27601 PyObject *swig_obj[1] ;
27602
27603 if (!args) SWIG_fail;
27604 swig_obj[0] = args;
27605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27606 if (!SWIG_IsOK(res1)) {
27607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27608 }
27609 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27610 {
27611 PyThreadState* __tstate = wxPyBeginAllowThreads();
27612 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27613 wxPyEndAllowThreads(__tstate);
27614 if (PyErr_Occurred()) SWIG_fail;
27615 }
27616 resultobj = result;
27617 return resultobj;
27618 fail:
27619 return NULL;
27620 }
27621
27622
27623 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27624 PyObject *obj;
27625 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27626 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27627 return SWIG_Py_Void();
27628 }
27629
27630 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27631 PyObject *resultobj = 0;
27632 int arg1 = (int) 0 ;
27633 wxUpdateUIEvent *result = 0 ;
27634 int val1 ;
27635 int ecode1 = 0 ;
27636 PyObject * obj0 = 0 ;
27637 char * kwnames[] = {
27638 (char *) "commandId", NULL
27639 };
27640
27641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27642 if (obj0) {
27643 ecode1 = SWIG_AsVal_int(obj0, &val1);
27644 if (!SWIG_IsOK(ecode1)) {
27645 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27646 }
27647 arg1 = static_cast< int >(val1);
27648 }
27649 {
27650 PyThreadState* __tstate = wxPyBeginAllowThreads();
27651 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27652 wxPyEndAllowThreads(__tstate);
27653 if (PyErr_Occurred()) SWIG_fail;
27654 }
27655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *resultobj = 0;
27664 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27665 bool result;
27666 void *argp1 = 0 ;
27667 int res1 = 0 ;
27668 PyObject *swig_obj[1] ;
27669
27670 if (!args) SWIG_fail;
27671 swig_obj[0] = args;
27672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27673 if (!SWIG_IsOK(res1)) {
27674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27675 }
27676 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27685 }
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27693 PyObject *resultobj = 0;
27694 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27695 bool result;
27696 void *argp1 = 0 ;
27697 int res1 = 0 ;
27698 PyObject *swig_obj[1] ;
27699
27700 if (!args) SWIG_fail;
27701 swig_obj[0] = args;
27702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27703 if (!SWIG_IsOK(res1)) {
27704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27705 }
27706 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27707 {
27708 PyThreadState* __tstate = wxPyBeginAllowThreads();
27709 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27710 wxPyEndAllowThreads(__tstate);
27711 if (PyErr_Occurred()) SWIG_fail;
27712 }
27713 {
27714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27715 }
27716 return resultobj;
27717 fail:
27718 return NULL;
27719 }
27720
27721
27722 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27723 PyObject *resultobj = 0;
27724 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27725 bool result;
27726 void *argp1 = 0 ;
27727 int res1 = 0 ;
27728 PyObject *swig_obj[1] ;
27729
27730 if (!args) SWIG_fail;
27731 swig_obj[0] = args;
27732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27733 if (!SWIG_IsOK(res1)) {
27734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27735 }
27736 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27737 {
27738 PyThreadState* __tstate = wxPyBeginAllowThreads();
27739 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27740 wxPyEndAllowThreads(__tstate);
27741 if (PyErr_Occurred()) SWIG_fail;
27742 }
27743 {
27744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27745 }
27746 return resultobj;
27747 fail:
27748 return NULL;
27749 }
27750
27751
27752 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27753 PyObject *resultobj = 0;
27754 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27755 wxString result;
27756 void *argp1 = 0 ;
27757 int res1 = 0 ;
27758 PyObject *swig_obj[1] ;
27759
27760 if (!args) SWIG_fail;
27761 swig_obj[0] = args;
27762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27763 if (!SWIG_IsOK(res1)) {
27764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27765 }
27766 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27767 {
27768 PyThreadState* __tstate = wxPyBeginAllowThreads();
27769 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27770 wxPyEndAllowThreads(__tstate);
27771 if (PyErr_Occurred()) SWIG_fail;
27772 }
27773 {
27774 #if wxUSE_UNICODE
27775 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27776 #else
27777 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27778 #endif
27779 }
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27787 PyObject *resultobj = 0;
27788 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27789 bool result;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 PyObject *swig_obj[1] ;
27793
27794 if (!args) SWIG_fail;
27795 swig_obj[0] = args;
27796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27797 if (!SWIG_IsOK(res1)) {
27798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27799 }
27800 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27804 wxPyEndAllowThreads(__tstate);
27805 if (PyErr_Occurred()) SWIG_fail;
27806 }
27807 {
27808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27809 }
27810 return resultobj;
27811 fail:
27812 return NULL;
27813 }
27814
27815
27816 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27817 PyObject *resultobj = 0;
27818 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27819 bool result;
27820 void *argp1 = 0 ;
27821 int res1 = 0 ;
27822 PyObject *swig_obj[1] ;
27823
27824 if (!args) SWIG_fail;
27825 swig_obj[0] = args;
27826 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27827 if (!SWIG_IsOK(res1)) {
27828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27829 }
27830 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27831 {
27832 PyThreadState* __tstate = wxPyBeginAllowThreads();
27833 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27834 wxPyEndAllowThreads(__tstate);
27835 if (PyErr_Occurred()) SWIG_fail;
27836 }
27837 {
27838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27839 }
27840 return resultobj;
27841 fail:
27842 return NULL;
27843 }
27844
27845
27846 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27847 PyObject *resultobj = 0;
27848 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27849 bool result;
27850 void *argp1 = 0 ;
27851 int res1 = 0 ;
27852 PyObject *swig_obj[1] ;
27853
27854 if (!args) SWIG_fail;
27855 swig_obj[0] = args;
27856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27857 if (!SWIG_IsOK(res1)) {
27858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27859 }
27860 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27861 {
27862 PyThreadState* __tstate = wxPyBeginAllowThreads();
27863 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27864 wxPyEndAllowThreads(__tstate);
27865 if (PyErr_Occurred()) SWIG_fail;
27866 }
27867 {
27868 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27869 }
27870 return resultobj;
27871 fail:
27872 return NULL;
27873 }
27874
27875
27876 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27877 PyObject *resultobj = 0;
27878 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27879 bool result;
27880 void *argp1 = 0 ;
27881 int res1 = 0 ;
27882 PyObject *swig_obj[1] ;
27883
27884 if (!args) SWIG_fail;
27885 swig_obj[0] = args;
27886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27887 if (!SWIG_IsOK(res1)) {
27888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27889 }
27890 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27891 {
27892 PyThreadState* __tstate = wxPyBeginAllowThreads();
27893 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27894 wxPyEndAllowThreads(__tstate);
27895 if (PyErr_Occurred()) SWIG_fail;
27896 }
27897 {
27898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27899 }
27900 return resultobj;
27901 fail:
27902 return NULL;
27903 }
27904
27905
27906 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27907 PyObject *resultobj = 0;
27908 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27909 bool arg2 ;
27910 void *argp1 = 0 ;
27911 int res1 = 0 ;
27912 bool val2 ;
27913 int ecode2 = 0 ;
27914 PyObject * obj0 = 0 ;
27915 PyObject * obj1 = 0 ;
27916 char * kwnames[] = {
27917 (char *) "self",(char *) "check", NULL
27918 };
27919
27920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27922 if (!SWIG_IsOK(res1)) {
27923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27924 }
27925 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27926 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27927 if (!SWIG_IsOK(ecode2)) {
27928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27929 }
27930 arg2 = static_cast< bool >(val2);
27931 {
27932 PyThreadState* __tstate = wxPyBeginAllowThreads();
27933 (arg1)->Check(arg2);
27934 wxPyEndAllowThreads(__tstate);
27935 if (PyErr_Occurred()) SWIG_fail;
27936 }
27937 resultobj = SWIG_Py_Void();
27938 return resultobj;
27939 fail:
27940 return NULL;
27941 }
27942
27943
27944 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27945 PyObject *resultobj = 0;
27946 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27947 bool arg2 ;
27948 void *argp1 = 0 ;
27949 int res1 = 0 ;
27950 bool val2 ;
27951 int ecode2 = 0 ;
27952 PyObject * obj0 = 0 ;
27953 PyObject * obj1 = 0 ;
27954 char * kwnames[] = {
27955 (char *) "self",(char *) "enable", NULL
27956 };
27957
27958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27960 if (!SWIG_IsOK(res1)) {
27961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27962 }
27963 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27964 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27965 if (!SWIG_IsOK(ecode2)) {
27966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27967 }
27968 arg2 = static_cast< bool >(val2);
27969 {
27970 PyThreadState* __tstate = wxPyBeginAllowThreads();
27971 (arg1)->Enable(arg2);
27972 wxPyEndAllowThreads(__tstate);
27973 if (PyErr_Occurred()) SWIG_fail;
27974 }
27975 resultobj = SWIG_Py_Void();
27976 return resultobj;
27977 fail:
27978 return NULL;
27979 }
27980
27981
27982 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27983 PyObject *resultobj = 0;
27984 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27985 bool arg2 ;
27986 void *argp1 = 0 ;
27987 int res1 = 0 ;
27988 bool val2 ;
27989 int ecode2 = 0 ;
27990 PyObject * obj0 = 0 ;
27991 PyObject * obj1 = 0 ;
27992 char * kwnames[] = {
27993 (char *) "self",(char *) "show", NULL
27994 };
27995
27996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
27997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27998 if (!SWIG_IsOK(res1)) {
27999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28000 }
28001 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28002 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28003 if (!SWIG_IsOK(ecode2)) {
28004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28005 }
28006 arg2 = static_cast< bool >(val2);
28007 {
28008 PyThreadState* __tstate = wxPyBeginAllowThreads();
28009 (arg1)->Show(arg2);
28010 wxPyEndAllowThreads(__tstate);
28011 if (PyErr_Occurred()) SWIG_fail;
28012 }
28013 resultobj = SWIG_Py_Void();
28014 return resultobj;
28015 fail:
28016 return NULL;
28017 }
28018
28019
28020 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28021 PyObject *resultobj = 0;
28022 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28023 wxString *arg2 = 0 ;
28024 void *argp1 = 0 ;
28025 int res1 = 0 ;
28026 bool temp2 = false ;
28027 PyObject * obj0 = 0 ;
28028 PyObject * obj1 = 0 ;
28029 char * kwnames[] = {
28030 (char *) "self",(char *) "text", NULL
28031 };
28032
28033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28035 if (!SWIG_IsOK(res1)) {
28036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28037 }
28038 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28039 {
28040 arg2 = wxString_in_helper(obj1);
28041 if (arg2 == NULL) SWIG_fail;
28042 temp2 = true;
28043 }
28044 {
28045 PyThreadState* __tstate = wxPyBeginAllowThreads();
28046 (arg1)->SetText((wxString const &)*arg2);
28047 wxPyEndAllowThreads(__tstate);
28048 if (PyErr_Occurred()) SWIG_fail;
28049 }
28050 resultobj = SWIG_Py_Void();
28051 {
28052 if (temp2)
28053 delete arg2;
28054 }
28055 return resultobj;
28056 fail:
28057 {
28058 if (temp2)
28059 delete arg2;
28060 }
28061 return NULL;
28062 }
28063
28064
28065 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28066 PyObject *resultobj = 0;
28067 long arg1 ;
28068 long val1 ;
28069 int ecode1 = 0 ;
28070 PyObject * obj0 = 0 ;
28071 char * kwnames[] = {
28072 (char *) "updateInterval", NULL
28073 };
28074
28075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28076 ecode1 = SWIG_AsVal_long(obj0, &val1);
28077 if (!SWIG_IsOK(ecode1)) {
28078 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28079 }
28080 arg1 = static_cast< long >(val1);
28081 {
28082 PyThreadState* __tstate = wxPyBeginAllowThreads();
28083 wxUpdateUIEvent::SetUpdateInterval(arg1);
28084 wxPyEndAllowThreads(__tstate);
28085 if (PyErr_Occurred()) SWIG_fail;
28086 }
28087 resultobj = SWIG_Py_Void();
28088 return resultobj;
28089 fail:
28090 return NULL;
28091 }
28092
28093
28094 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28095 PyObject *resultobj = 0;
28096 long result;
28097
28098 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28099 {
28100 PyThreadState* __tstate = wxPyBeginAllowThreads();
28101 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28102 wxPyEndAllowThreads(__tstate);
28103 if (PyErr_Occurred()) SWIG_fail;
28104 }
28105 resultobj = SWIG_From_long(static_cast< long >(result));
28106 return resultobj;
28107 fail:
28108 return NULL;
28109 }
28110
28111
28112 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28113 PyObject *resultobj = 0;
28114 wxWindow *arg1 = (wxWindow *) 0 ;
28115 bool result;
28116 void *argp1 = 0 ;
28117 int res1 = 0 ;
28118 PyObject * obj0 = 0 ;
28119 char * kwnames[] = {
28120 (char *) "win", NULL
28121 };
28122
28123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28125 if (!SWIG_IsOK(res1)) {
28126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28127 }
28128 arg1 = reinterpret_cast< wxWindow * >(argp1);
28129 {
28130 PyThreadState* __tstate = wxPyBeginAllowThreads();
28131 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28132 wxPyEndAllowThreads(__tstate);
28133 if (PyErr_Occurred()) SWIG_fail;
28134 }
28135 {
28136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28137 }
28138 return resultobj;
28139 fail:
28140 return NULL;
28141 }
28142
28143
28144 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28145 PyObject *resultobj = 0;
28146
28147 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28148 {
28149 PyThreadState* __tstate = wxPyBeginAllowThreads();
28150 wxUpdateUIEvent::ResetUpdateTime();
28151 wxPyEndAllowThreads(__tstate);
28152 if (PyErr_Occurred()) SWIG_fail;
28153 }
28154 resultobj = SWIG_Py_Void();
28155 return resultobj;
28156 fail:
28157 return NULL;
28158 }
28159
28160
28161 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28162 PyObject *resultobj = 0;
28163 wxUpdateUIMode arg1 ;
28164 int val1 ;
28165 int ecode1 = 0 ;
28166 PyObject * obj0 = 0 ;
28167 char * kwnames[] = {
28168 (char *) "mode", NULL
28169 };
28170
28171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28172 ecode1 = SWIG_AsVal_int(obj0, &val1);
28173 if (!SWIG_IsOK(ecode1)) {
28174 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28175 }
28176 arg1 = static_cast< wxUpdateUIMode >(val1);
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 wxUpdateUIEvent::SetMode(arg1);
28180 wxPyEndAllowThreads(__tstate);
28181 if (PyErr_Occurred()) SWIG_fail;
28182 }
28183 resultobj = SWIG_Py_Void();
28184 return resultobj;
28185 fail:
28186 return NULL;
28187 }
28188
28189
28190 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28191 PyObject *resultobj = 0;
28192 wxUpdateUIMode result;
28193
28194 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28195 {
28196 PyThreadState* __tstate = wxPyBeginAllowThreads();
28197 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28198 wxPyEndAllowThreads(__tstate);
28199 if (PyErr_Occurred()) SWIG_fail;
28200 }
28201 resultobj = SWIG_From_int(static_cast< int >(result));
28202 return resultobj;
28203 fail:
28204 return NULL;
28205 }
28206
28207
28208 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28209 PyObject *obj;
28210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28211 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28212 return SWIG_Py_Void();
28213 }
28214
28215 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28216 return SWIG_Python_InitShadowInstance(args);
28217 }
28218
28219 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28220 PyObject *resultobj = 0;
28221 wxSysColourChangedEvent *result = 0 ;
28222
28223 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *obj;
28239 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28240 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28241 return SWIG_Py_Void();
28242 }
28243
28244 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28245 return SWIG_Python_InitShadowInstance(args);
28246 }
28247
28248 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28249 PyObject *resultobj = 0;
28250 int arg1 = (int) 0 ;
28251 wxWindow *arg2 = (wxWindow *) NULL ;
28252 wxMouseCaptureChangedEvent *result = 0 ;
28253 int val1 ;
28254 int ecode1 = 0 ;
28255 void *argp2 = 0 ;
28256 int res2 = 0 ;
28257 PyObject * obj0 = 0 ;
28258 PyObject * obj1 = 0 ;
28259 char * kwnames[] = {
28260 (char *) "winid",(char *) "gainedCapture", NULL
28261 };
28262
28263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28264 if (obj0) {
28265 ecode1 = SWIG_AsVal_int(obj0, &val1);
28266 if (!SWIG_IsOK(ecode1)) {
28267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28268 }
28269 arg1 = static_cast< int >(val1);
28270 }
28271 if (obj1) {
28272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28273 if (!SWIG_IsOK(res2)) {
28274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28275 }
28276 arg2 = reinterpret_cast< wxWindow * >(argp2);
28277 }
28278 {
28279 PyThreadState* __tstate = wxPyBeginAllowThreads();
28280 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28292 PyObject *resultobj = 0;
28293 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28294 wxWindow *result = 0 ;
28295 void *argp1 = 0 ;
28296 int res1 = 0 ;
28297 PyObject *swig_obj[1] ;
28298
28299 if (!args) SWIG_fail;
28300 swig_obj[0] = args;
28301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28302 if (!SWIG_IsOK(res1)) {
28303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28304 }
28305 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28309 wxPyEndAllowThreads(__tstate);
28310 if (PyErr_Occurred()) SWIG_fail;
28311 }
28312 {
28313 resultobj = wxPyMake_wxObject(result, (bool)0);
28314 }
28315 return resultobj;
28316 fail:
28317 return NULL;
28318 }
28319
28320
28321 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28322 PyObject *obj;
28323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28324 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28325 return SWIG_Py_Void();
28326 }
28327
28328 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28329 return SWIG_Python_InitShadowInstance(args);
28330 }
28331
28332 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28333 PyObject *resultobj = 0;
28334 int arg1 = (int) 0 ;
28335 wxMouseCaptureLostEvent *result = 0 ;
28336 int val1 ;
28337 int ecode1 = 0 ;
28338 PyObject * obj0 = 0 ;
28339 char * kwnames[] = {
28340 (char *) "winid", NULL
28341 };
28342
28343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28344 if (obj0) {
28345 ecode1 = SWIG_AsVal_int(obj0, &val1);
28346 if (!SWIG_IsOK(ecode1)) {
28347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28348 }
28349 arg1 = static_cast< int >(val1);
28350 }
28351 {
28352 PyThreadState* __tstate = wxPyBeginAllowThreads();
28353 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28354 wxPyEndAllowThreads(__tstate);
28355 if (PyErr_Occurred()) SWIG_fail;
28356 }
28357 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28358 return resultobj;
28359 fail:
28360 return NULL;
28361 }
28362
28363
28364 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28365 PyObject *obj;
28366 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28367 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28368 return SWIG_Py_Void();
28369 }
28370
28371 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28372 return SWIG_Python_InitShadowInstance(args);
28373 }
28374
28375 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28376 PyObject *resultobj = 0;
28377 wxDisplayChangedEvent *result = 0 ;
28378
28379 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28380 {
28381 PyThreadState* __tstate = wxPyBeginAllowThreads();
28382 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28383 wxPyEndAllowThreads(__tstate);
28384 if (PyErr_Occurred()) SWIG_fail;
28385 }
28386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28387 return resultobj;
28388 fail:
28389 return NULL;
28390 }
28391
28392
28393 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28394 PyObject *obj;
28395 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28396 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28397 return SWIG_Py_Void();
28398 }
28399
28400 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28401 return SWIG_Python_InitShadowInstance(args);
28402 }
28403
28404 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28405 PyObject *resultobj = 0;
28406 int arg1 = (int) 0 ;
28407 wxPaletteChangedEvent *result = 0 ;
28408 int val1 ;
28409 int ecode1 = 0 ;
28410 PyObject * obj0 = 0 ;
28411 char * kwnames[] = {
28412 (char *) "id", NULL
28413 };
28414
28415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28416 if (obj0) {
28417 ecode1 = SWIG_AsVal_int(obj0, &val1);
28418 if (!SWIG_IsOK(ecode1)) {
28419 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28420 }
28421 arg1 = static_cast< int >(val1);
28422 }
28423 {
28424 PyThreadState* __tstate = wxPyBeginAllowThreads();
28425 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28426 wxPyEndAllowThreads(__tstate);
28427 if (PyErr_Occurred()) SWIG_fail;
28428 }
28429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28430 return resultobj;
28431 fail:
28432 return NULL;
28433 }
28434
28435
28436 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28437 PyObject *resultobj = 0;
28438 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28439 wxWindow *arg2 = (wxWindow *) 0 ;
28440 void *argp1 = 0 ;
28441 int res1 = 0 ;
28442 void *argp2 = 0 ;
28443 int res2 = 0 ;
28444 PyObject * obj0 = 0 ;
28445 PyObject * obj1 = 0 ;
28446 char * kwnames[] = {
28447 (char *) "self",(char *) "win", NULL
28448 };
28449
28450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28452 if (!SWIG_IsOK(res1)) {
28453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28454 }
28455 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28456 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28457 if (!SWIG_IsOK(res2)) {
28458 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28459 }
28460 arg2 = reinterpret_cast< wxWindow * >(argp2);
28461 {
28462 PyThreadState* __tstate = wxPyBeginAllowThreads();
28463 (arg1)->SetChangedWindow(arg2);
28464 wxPyEndAllowThreads(__tstate);
28465 if (PyErr_Occurred()) SWIG_fail;
28466 }
28467 resultobj = SWIG_Py_Void();
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28475 PyObject *resultobj = 0;
28476 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28477 wxWindow *result = 0 ;
28478 void *argp1 = 0 ;
28479 int res1 = 0 ;
28480 PyObject *swig_obj[1] ;
28481
28482 if (!args) SWIG_fail;
28483 swig_obj[0] = args;
28484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28485 if (!SWIG_IsOK(res1)) {
28486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28487 }
28488 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28489 {
28490 PyThreadState* __tstate = wxPyBeginAllowThreads();
28491 result = (wxWindow *)(arg1)->GetChangedWindow();
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = wxPyMake_wxObject(result, (bool)0);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28505 PyObject *obj;
28506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28507 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28508 return SWIG_Py_Void();
28509 }
28510
28511 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28512 return SWIG_Python_InitShadowInstance(args);
28513 }
28514
28515 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28516 PyObject *resultobj = 0;
28517 int arg1 = (int) 0 ;
28518 wxQueryNewPaletteEvent *result = 0 ;
28519 int val1 ;
28520 int ecode1 = 0 ;
28521 PyObject * obj0 = 0 ;
28522 char * kwnames[] = {
28523 (char *) "winid", NULL
28524 };
28525
28526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28527 if (obj0) {
28528 ecode1 = SWIG_AsVal_int(obj0, &val1);
28529 if (!SWIG_IsOK(ecode1)) {
28530 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28531 }
28532 arg1 = static_cast< int >(val1);
28533 }
28534 {
28535 PyThreadState* __tstate = wxPyBeginAllowThreads();
28536 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28537 wxPyEndAllowThreads(__tstate);
28538 if (PyErr_Occurred()) SWIG_fail;
28539 }
28540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28541 return resultobj;
28542 fail:
28543 return NULL;
28544 }
28545
28546
28547 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28548 PyObject *resultobj = 0;
28549 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28550 bool arg2 ;
28551 void *argp1 = 0 ;
28552 int res1 = 0 ;
28553 bool val2 ;
28554 int ecode2 = 0 ;
28555 PyObject * obj0 = 0 ;
28556 PyObject * obj1 = 0 ;
28557 char * kwnames[] = {
28558 (char *) "self",(char *) "realized", NULL
28559 };
28560
28561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28563 if (!SWIG_IsOK(res1)) {
28564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28565 }
28566 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28568 if (!SWIG_IsOK(ecode2)) {
28569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28570 }
28571 arg2 = static_cast< bool >(val2);
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 (arg1)->SetPaletteRealized(arg2);
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_Py_Void();
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 PyObject *resultobj = 0;
28587 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28588 bool result;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28598 }
28599 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28616 PyObject *obj;
28617 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28618 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28619 return SWIG_Py_Void();
28620 }
28621
28622 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28623 return SWIG_Python_InitShadowInstance(args);
28624 }
28625
28626 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28627 PyObject *resultobj = 0;
28628 wxNavigationKeyEvent *result = 0 ;
28629
28630 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28638 return resultobj;
28639 fail:
28640 return NULL;
28641 }
28642
28643
28644 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28645 PyObject *resultobj = 0;
28646 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28647 bool result;
28648 void *argp1 = 0 ;
28649 int res1 = 0 ;
28650 PyObject *swig_obj[1] ;
28651
28652 if (!args) SWIG_fail;
28653 swig_obj[0] = args;
28654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28655 if (!SWIG_IsOK(res1)) {
28656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28657 }
28658 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28659 {
28660 PyThreadState* __tstate = wxPyBeginAllowThreads();
28661 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 {
28666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28667 }
28668 return resultobj;
28669 fail:
28670 return NULL;
28671 }
28672
28673
28674 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28675 PyObject *resultobj = 0;
28676 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28677 bool arg2 ;
28678 void *argp1 = 0 ;
28679 int res1 = 0 ;
28680 bool val2 ;
28681 int ecode2 = 0 ;
28682 PyObject * obj0 = 0 ;
28683 PyObject * obj1 = 0 ;
28684 char * kwnames[] = {
28685 (char *) "self",(char *) "forward", NULL
28686 };
28687
28688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28690 if (!SWIG_IsOK(res1)) {
28691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28692 }
28693 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28694 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28695 if (!SWIG_IsOK(ecode2)) {
28696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28697 }
28698 arg2 = static_cast< bool >(val2);
28699 {
28700 PyThreadState* __tstate = wxPyBeginAllowThreads();
28701 (arg1)->SetDirection(arg2);
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 resultobj = SWIG_Py_Void();
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28713 PyObject *resultobj = 0;
28714 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28715 bool result;
28716 void *argp1 = 0 ;
28717 int res1 = 0 ;
28718 PyObject *swig_obj[1] ;
28719
28720 if (!args) SWIG_fail;
28721 swig_obj[0] = args;
28722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28723 if (!SWIG_IsOK(res1)) {
28724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28725 }
28726 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28727 {
28728 PyThreadState* __tstate = wxPyBeginAllowThreads();
28729 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28730 wxPyEndAllowThreads(__tstate);
28731 if (PyErr_Occurred()) SWIG_fail;
28732 }
28733 {
28734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28735 }
28736 return resultobj;
28737 fail:
28738 return NULL;
28739 }
28740
28741
28742 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28743 PyObject *resultobj = 0;
28744 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28745 bool arg2 ;
28746 void *argp1 = 0 ;
28747 int res1 = 0 ;
28748 bool val2 ;
28749 int ecode2 = 0 ;
28750 PyObject * obj0 = 0 ;
28751 PyObject * obj1 = 0 ;
28752 char * kwnames[] = {
28753 (char *) "self",(char *) "ischange", NULL
28754 };
28755
28756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28758 if (!SWIG_IsOK(res1)) {
28759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28760 }
28761 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28762 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28763 if (!SWIG_IsOK(ecode2)) {
28764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28765 }
28766 arg2 = static_cast< bool >(val2);
28767 {
28768 PyThreadState* __tstate = wxPyBeginAllowThreads();
28769 (arg1)->SetWindowChange(arg2);
28770 wxPyEndAllowThreads(__tstate);
28771 if (PyErr_Occurred()) SWIG_fail;
28772 }
28773 resultobj = SWIG_Py_Void();
28774 return resultobj;
28775 fail:
28776 return NULL;
28777 }
28778
28779
28780 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28781 PyObject *resultobj = 0;
28782 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28783 bool result;
28784 void *argp1 = 0 ;
28785 int res1 = 0 ;
28786 PyObject *swig_obj[1] ;
28787
28788 if (!args) SWIG_fail;
28789 swig_obj[0] = args;
28790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28791 if (!SWIG_IsOK(res1)) {
28792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28793 }
28794 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28795 {
28796 PyThreadState* __tstate = wxPyBeginAllowThreads();
28797 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28798 wxPyEndAllowThreads(__tstate);
28799 if (PyErr_Occurred()) SWIG_fail;
28800 }
28801 {
28802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28803 }
28804 return resultobj;
28805 fail:
28806 return NULL;
28807 }
28808
28809
28810 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28811 PyObject *resultobj = 0;
28812 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28813 bool arg2 ;
28814 void *argp1 = 0 ;
28815 int res1 = 0 ;
28816 bool val2 ;
28817 int ecode2 = 0 ;
28818 PyObject * obj0 = 0 ;
28819 PyObject * obj1 = 0 ;
28820 char * kwnames[] = {
28821 (char *) "self",(char *) "bIs", NULL
28822 };
28823
28824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28826 if (!SWIG_IsOK(res1)) {
28827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28828 }
28829 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28830 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28831 if (!SWIG_IsOK(ecode2)) {
28832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28833 }
28834 arg2 = static_cast< bool >(val2);
28835 {
28836 PyThreadState* __tstate = wxPyBeginAllowThreads();
28837 (arg1)->SetFromTab(arg2);
28838 wxPyEndAllowThreads(__tstate);
28839 if (PyErr_Occurred()) SWIG_fail;
28840 }
28841 resultobj = SWIG_Py_Void();
28842 return resultobj;
28843 fail:
28844 return NULL;
28845 }
28846
28847
28848 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28849 PyObject *resultobj = 0;
28850 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28851 long arg2 ;
28852 void *argp1 = 0 ;
28853 int res1 = 0 ;
28854 long val2 ;
28855 int ecode2 = 0 ;
28856 PyObject * obj0 = 0 ;
28857 PyObject * obj1 = 0 ;
28858 char * kwnames[] = {
28859 (char *) "self",(char *) "flags", NULL
28860 };
28861
28862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28864 if (!SWIG_IsOK(res1)) {
28865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28866 }
28867 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28868 ecode2 = SWIG_AsVal_long(obj1, &val2);
28869 if (!SWIG_IsOK(ecode2)) {
28870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28871 }
28872 arg2 = static_cast< long >(val2);
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 (arg1)->SetFlags(arg2);
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_Py_Void();
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28887 PyObject *resultobj = 0;
28888 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28889 wxWindow *result = 0 ;
28890 void *argp1 = 0 ;
28891 int res1 = 0 ;
28892 PyObject *swig_obj[1] ;
28893
28894 if (!args) SWIG_fail;
28895 swig_obj[0] = args;
28896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28897 if (!SWIG_IsOK(res1)) {
28898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28899 }
28900 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28901 {
28902 PyThreadState* __tstate = wxPyBeginAllowThreads();
28903 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28904 wxPyEndAllowThreads(__tstate);
28905 if (PyErr_Occurred()) SWIG_fail;
28906 }
28907 {
28908 resultobj = wxPyMake_wxObject(result, (bool)0);
28909 }
28910 return resultobj;
28911 fail:
28912 return NULL;
28913 }
28914
28915
28916 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28917 PyObject *resultobj = 0;
28918 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28919 wxWindow *arg2 = (wxWindow *) 0 ;
28920 void *argp1 = 0 ;
28921 int res1 = 0 ;
28922 void *argp2 = 0 ;
28923 int res2 = 0 ;
28924 PyObject * obj0 = 0 ;
28925 PyObject * obj1 = 0 ;
28926 char * kwnames[] = {
28927 (char *) "self",(char *) "win", NULL
28928 };
28929
28930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28932 if (!SWIG_IsOK(res1)) {
28933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28934 }
28935 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28936 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28937 if (!SWIG_IsOK(res2)) {
28938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28939 }
28940 arg2 = reinterpret_cast< wxWindow * >(argp2);
28941 {
28942 PyThreadState* __tstate = wxPyBeginAllowThreads();
28943 (arg1)->SetCurrentFocus(arg2);
28944 wxPyEndAllowThreads(__tstate);
28945 if (PyErr_Occurred()) SWIG_fail;
28946 }
28947 resultobj = SWIG_Py_Void();
28948 return resultobj;
28949 fail:
28950 return NULL;
28951 }
28952
28953
28954 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28955 PyObject *obj;
28956 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28957 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28958 return SWIG_Py_Void();
28959 }
28960
28961 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28962 return SWIG_Python_InitShadowInstance(args);
28963 }
28964
28965 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28966 PyObject *resultobj = 0;
28967 wxWindow *arg1 = (wxWindow *) NULL ;
28968 wxWindowCreateEvent *result = 0 ;
28969 void *argp1 = 0 ;
28970 int res1 = 0 ;
28971 PyObject * obj0 = 0 ;
28972 char * kwnames[] = {
28973 (char *) "win", NULL
28974 };
28975
28976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
28977 if (obj0) {
28978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
28981 }
28982 arg1 = reinterpret_cast< wxWindow * >(argp1);
28983 }
28984 {
28985 PyThreadState* __tstate = wxPyBeginAllowThreads();
28986 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
28987 wxPyEndAllowThreads(__tstate);
28988 if (PyErr_Occurred()) SWIG_fail;
28989 }
28990 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28998 PyObject *resultobj = 0;
28999 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29000 wxWindow *result = 0 ;
29001 void *argp1 = 0 ;
29002 int res1 = 0 ;
29003 PyObject *swig_obj[1] ;
29004
29005 if (!args) SWIG_fail;
29006 swig_obj[0] = args;
29007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29008 if (!SWIG_IsOK(res1)) {
29009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29010 }
29011 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29012 {
29013 PyThreadState* __tstate = wxPyBeginAllowThreads();
29014 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29015 wxPyEndAllowThreads(__tstate);
29016 if (PyErr_Occurred()) SWIG_fail;
29017 }
29018 {
29019 resultobj = wxPyMake_wxObject(result, (bool)0);
29020 }
29021 return resultobj;
29022 fail:
29023 return NULL;
29024 }
29025
29026
29027 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29028 PyObject *obj;
29029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29030 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29031 return SWIG_Py_Void();
29032 }
29033
29034 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29035 return SWIG_Python_InitShadowInstance(args);
29036 }
29037
29038 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29039 PyObject *resultobj = 0;
29040 wxWindow *arg1 = (wxWindow *) NULL ;
29041 wxWindowDestroyEvent *result = 0 ;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject * obj0 = 0 ;
29045 char * kwnames[] = {
29046 (char *) "win", NULL
29047 };
29048
29049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29050 if (obj0) {
29051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29052 if (!SWIG_IsOK(res1)) {
29053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29054 }
29055 arg1 = reinterpret_cast< wxWindow * >(argp1);
29056 }
29057 {
29058 PyThreadState* __tstate = wxPyBeginAllowThreads();
29059 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29060 wxPyEndAllowThreads(__tstate);
29061 if (PyErr_Occurred()) SWIG_fail;
29062 }
29063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29064 return resultobj;
29065 fail:
29066 return NULL;
29067 }
29068
29069
29070 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29071 PyObject *resultobj = 0;
29072 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29073 wxWindow *result = 0 ;
29074 void *argp1 = 0 ;
29075 int res1 = 0 ;
29076 PyObject *swig_obj[1] ;
29077
29078 if (!args) SWIG_fail;
29079 swig_obj[0] = args;
29080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29081 if (!SWIG_IsOK(res1)) {
29082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29083 }
29084 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29085 {
29086 PyThreadState* __tstate = wxPyBeginAllowThreads();
29087 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29088 wxPyEndAllowThreads(__tstate);
29089 if (PyErr_Occurred()) SWIG_fail;
29090 }
29091 {
29092 resultobj = wxPyMake_wxObject(result, (bool)0);
29093 }
29094 return resultobj;
29095 fail:
29096 return NULL;
29097 }
29098
29099
29100 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29101 PyObject *obj;
29102 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29103 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29104 return SWIG_Py_Void();
29105 }
29106
29107 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29108 return SWIG_Python_InitShadowInstance(args);
29109 }
29110
29111 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29112 PyObject *resultobj = 0;
29113 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29114 int arg2 = (int) 0 ;
29115 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29116 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29117 wxContextMenuEvent *result = 0 ;
29118 int val1 ;
29119 int ecode1 = 0 ;
29120 int val2 ;
29121 int ecode2 = 0 ;
29122 wxPoint temp3 ;
29123 PyObject * obj0 = 0 ;
29124 PyObject * obj1 = 0 ;
29125 PyObject * obj2 = 0 ;
29126 char * kwnames[] = {
29127 (char *) "type",(char *) "winid",(char *) "pt", NULL
29128 };
29129
29130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29131 if (obj0) {
29132 ecode1 = SWIG_AsVal_int(obj0, &val1);
29133 if (!SWIG_IsOK(ecode1)) {
29134 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29135 }
29136 arg1 = static_cast< wxEventType >(val1);
29137 }
29138 if (obj1) {
29139 ecode2 = SWIG_AsVal_int(obj1, &val2);
29140 if (!SWIG_IsOK(ecode2)) {
29141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29142 }
29143 arg2 = static_cast< int >(val2);
29144 }
29145 if (obj2) {
29146 {
29147 arg3 = &temp3;
29148 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29149 }
29150 }
29151 {
29152 PyThreadState* __tstate = wxPyBeginAllowThreads();
29153 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29165 PyObject *resultobj = 0;
29166 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29167 wxPoint *result = 0 ;
29168 void *argp1 = 0 ;
29169 int res1 = 0 ;
29170 PyObject *swig_obj[1] ;
29171
29172 if (!args) SWIG_fail;
29173 swig_obj[0] = args;
29174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29175 if (!SWIG_IsOK(res1)) {
29176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29177 }
29178 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29179 {
29180 PyThreadState* __tstate = wxPyBeginAllowThreads();
29181 {
29182 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29183 result = (wxPoint *) &_result_ref;
29184 }
29185 wxPyEndAllowThreads(__tstate);
29186 if (PyErr_Occurred()) SWIG_fail;
29187 }
29188 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29189 return resultobj;
29190 fail:
29191 return NULL;
29192 }
29193
29194
29195 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29196 PyObject *resultobj = 0;
29197 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29198 wxPoint *arg2 = 0 ;
29199 void *argp1 = 0 ;
29200 int res1 = 0 ;
29201 wxPoint temp2 ;
29202 PyObject * obj0 = 0 ;
29203 PyObject * obj1 = 0 ;
29204 char * kwnames[] = {
29205 (char *) "self",(char *) "pos", NULL
29206 };
29207
29208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29210 if (!SWIG_IsOK(res1)) {
29211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29212 }
29213 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29214 {
29215 arg2 = &temp2;
29216 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29217 }
29218 {
29219 PyThreadState* __tstate = wxPyBeginAllowThreads();
29220 (arg1)->SetPosition((wxPoint const &)*arg2);
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 resultobj = SWIG_Py_Void();
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29232 PyObject *obj;
29233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29234 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29235 return SWIG_Py_Void();
29236 }
29237
29238 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29239 return SWIG_Python_InitShadowInstance(args);
29240 }
29241
29242 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29243 PyObject *resultobj = 0;
29244 wxIdleEvent *result = 0 ;
29245
29246 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29247 {
29248 PyThreadState* __tstate = wxPyBeginAllowThreads();
29249 result = (wxIdleEvent *)new wxIdleEvent();
29250 wxPyEndAllowThreads(__tstate);
29251 if (PyErr_Occurred()) SWIG_fail;
29252 }
29253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29254 return resultobj;
29255 fail:
29256 return NULL;
29257 }
29258
29259
29260 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29261 PyObject *resultobj = 0;
29262 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29263 bool arg2 = (bool) true ;
29264 void *argp1 = 0 ;
29265 int res1 = 0 ;
29266 bool val2 ;
29267 int ecode2 = 0 ;
29268 PyObject * obj0 = 0 ;
29269 PyObject * obj1 = 0 ;
29270 char * kwnames[] = {
29271 (char *) "self",(char *) "needMore", NULL
29272 };
29273
29274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29276 if (!SWIG_IsOK(res1)) {
29277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29278 }
29279 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29280 if (obj1) {
29281 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29282 if (!SWIG_IsOK(ecode2)) {
29283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29284 }
29285 arg2 = static_cast< bool >(val2);
29286 }
29287 {
29288 PyThreadState* __tstate = wxPyBeginAllowThreads();
29289 (arg1)->RequestMore(arg2);
29290 wxPyEndAllowThreads(__tstate);
29291 if (PyErr_Occurred()) SWIG_fail;
29292 }
29293 resultobj = SWIG_Py_Void();
29294 return resultobj;
29295 fail:
29296 return NULL;
29297 }
29298
29299
29300 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29301 PyObject *resultobj = 0;
29302 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29303 bool result;
29304 void *argp1 = 0 ;
29305 int res1 = 0 ;
29306 PyObject *swig_obj[1] ;
29307
29308 if (!args) SWIG_fail;
29309 swig_obj[0] = args;
29310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29311 if (!SWIG_IsOK(res1)) {
29312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29313 }
29314 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29315 {
29316 PyThreadState* __tstate = wxPyBeginAllowThreads();
29317 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29318 wxPyEndAllowThreads(__tstate);
29319 if (PyErr_Occurred()) SWIG_fail;
29320 }
29321 {
29322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29323 }
29324 return resultobj;
29325 fail:
29326 return NULL;
29327 }
29328
29329
29330 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29331 PyObject *resultobj = 0;
29332 wxIdleMode arg1 ;
29333 int val1 ;
29334 int ecode1 = 0 ;
29335 PyObject * obj0 = 0 ;
29336 char * kwnames[] = {
29337 (char *) "mode", NULL
29338 };
29339
29340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29341 ecode1 = SWIG_AsVal_int(obj0, &val1);
29342 if (!SWIG_IsOK(ecode1)) {
29343 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29344 }
29345 arg1 = static_cast< wxIdleMode >(val1);
29346 {
29347 PyThreadState* __tstate = wxPyBeginAllowThreads();
29348 wxIdleEvent::SetMode(arg1);
29349 wxPyEndAllowThreads(__tstate);
29350 if (PyErr_Occurred()) SWIG_fail;
29351 }
29352 resultobj = SWIG_Py_Void();
29353 return resultobj;
29354 fail:
29355 return NULL;
29356 }
29357
29358
29359 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29360 PyObject *resultobj = 0;
29361 wxIdleMode result;
29362
29363 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29364 {
29365 PyThreadState* __tstate = wxPyBeginAllowThreads();
29366 result = (wxIdleMode)wxIdleEvent::GetMode();
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 resultobj = SWIG_From_int(static_cast< int >(result));
29371 return resultobj;
29372 fail:
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29378 PyObject *resultobj = 0;
29379 wxWindow *arg1 = (wxWindow *) 0 ;
29380 bool result;
29381 void *argp1 = 0 ;
29382 int res1 = 0 ;
29383 PyObject * obj0 = 0 ;
29384 char * kwnames[] = {
29385 (char *) "win", NULL
29386 };
29387
29388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29390 if (!SWIG_IsOK(res1)) {
29391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29392 }
29393 arg1 = reinterpret_cast< wxWindow * >(argp1);
29394 {
29395 PyThreadState* __tstate = wxPyBeginAllowThreads();
29396 result = (bool)wxIdleEvent::CanSend(arg1);
29397 wxPyEndAllowThreads(__tstate);
29398 if (PyErr_Occurred()) SWIG_fail;
29399 }
29400 {
29401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29402 }
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29410 PyObject *obj;
29411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29412 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29413 return SWIG_Py_Void();
29414 }
29415
29416 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 return SWIG_Python_InitShadowInstance(args);
29418 }
29419
29420 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = 0;
29422 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29423 int arg2 = (int) 0 ;
29424 wxClipboardTextEvent *result = 0 ;
29425 int val1 ;
29426 int ecode1 = 0 ;
29427 int val2 ;
29428 int ecode2 = 0 ;
29429 PyObject * obj0 = 0 ;
29430 PyObject * obj1 = 0 ;
29431 char * kwnames[] = {
29432 (char *) "type",(char *) "winid", NULL
29433 };
29434
29435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29436 if (obj0) {
29437 ecode1 = SWIG_AsVal_int(obj0, &val1);
29438 if (!SWIG_IsOK(ecode1)) {
29439 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29440 }
29441 arg1 = static_cast< wxEventType >(val1);
29442 }
29443 if (obj1) {
29444 ecode2 = SWIG_AsVal_int(obj1, &val2);
29445 if (!SWIG_IsOK(ecode2)) {
29446 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29447 }
29448 arg2 = static_cast< int >(val2);
29449 }
29450 {
29451 PyThreadState* __tstate = wxPyBeginAllowThreads();
29452 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29453 wxPyEndAllowThreads(__tstate);
29454 if (PyErr_Occurred()) SWIG_fail;
29455 }
29456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29457 return resultobj;
29458 fail:
29459 return NULL;
29460 }
29461
29462
29463 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29464 PyObject *obj;
29465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29466 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29467 return SWIG_Py_Void();
29468 }
29469
29470 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29471 return SWIG_Python_InitShadowInstance(args);
29472 }
29473
29474 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29475 PyObject *resultobj = 0;
29476 int arg1 = (int) 0 ;
29477 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29478 wxPyEvent *result = 0 ;
29479 int val1 ;
29480 int ecode1 = 0 ;
29481 int val2 ;
29482 int ecode2 = 0 ;
29483 PyObject * obj0 = 0 ;
29484 PyObject * obj1 = 0 ;
29485 char * kwnames[] = {
29486 (char *) "winid",(char *) "eventType", NULL
29487 };
29488
29489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29490 if (obj0) {
29491 ecode1 = SWIG_AsVal_int(obj0, &val1);
29492 if (!SWIG_IsOK(ecode1)) {
29493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29494 }
29495 arg1 = static_cast< int >(val1);
29496 }
29497 if (obj1) {
29498 ecode2 = SWIG_AsVal_int(obj1, &val2);
29499 if (!SWIG_IsOK(ecode2)) {
29500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29501 }
29502 arg2 = static_cast< wxEventType >(val2);
29503 }
29504 {
29505 PyThreadState* __tstate = wxPyBeginAllowThreads();
29506 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29507 wxPyEndAllowThreads(__tstate);
29508 if (PyErr_Occurred()) SWIG_fail;
29509 }
29510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29511 return resultobj;
29512 fail:
29513 return NULL;
29514 }
29515
29516
29517 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29518 PyObject *resultobj = 0;
29519 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29520 void *argp1 = 0 ;
29521 int res1 = 0 ;
29522 PyObject *swig_obj[1] ;
29523
29524 if (!args) SWIG_fail;
29525 swig_obj[0] = args;
29526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29527 if (!SWIG_IsOK(res1)) {
29528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29529 }
29530 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29531 {
29532 PyThreadState* __tstate = wxPyBeginAllowThreads();
29533 delete arg1;
29534
29535 wxPyEndAllowThreads(__tstate);
29536 if (PyErr_Occurred()) SWIG_fail;
29537 }
29538 resultobj = SWIG_Py_Void();
29539 return resultobj;
29540 fail:
29541 return NULL;
29542 }
29543
29544
29545 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29546 PyObject *resultobj = 0;
29547 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29548 PyObject *arg2 = (PyObject *) 0 ;
29549 void *argp1 = 0 ;
29550 int res1 = 0 ;
29551 PyObject * obj0 = 0 ;
29552 PyObject * obj1 = 0 ;
29553 char * kwnames[] = {
29554 (char *) "self",(char *) "self", NULL
29555 };
29556
29557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29559 if (!SWIG_IsOK(res1)) {
29560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29561 }
29562 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29563 arg2 = obj1;
29564 {
29565 PyThreadState* __tstate = wxPyBeginAllowThreads();
29566 (arg1)->SetSelf(arg2);
29567 wxPyEndAllowThreads(__tstate);
29568 if (PyErr_Occurred()) SWIG_fail;
29569 }
29570 resultobj = SWIG_Py_Void();
29571 return resultobj;
29572 fail:
29573 return NULL;
29574 }
29575
29576
29577 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29578 PyObject *resultobj = 0;
29579 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29580 PyObject *result = 0 ;
29581 void *argp1 = 0 ;
29582 int res1 = 0 ;
29583 PyObject *swig_obj[1] ;
29584
29585 if (!args) SWIG_fail;
29586 swig_obj[0] = args;
29587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29588 if (!SWIG_IsOK(res1)) {
29589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29590 }
29591 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 result = (PyObject *)(arg1)->GetSelf();
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 resultobj = result;
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29606 PyObject *obj;
29607 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29608 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29609 return SWIG_Py_Void();
29610 }
29611
29612 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29613 return SWIG_Python_InitShadowInstance(args);
29614 }
29615
29616 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29617 PyObject *resultobj = 0;
29618 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29619 int arg2 = (int) 0 ;
29620 wxPyCommandEvent *result = 0 ;
29621 int val1 ;
29622 int ecode1 = 0 ;
29623 int val2 ;
29624 int ecode2 = 0 ;
29625 PyObject * obj0 = 0 ;
29626 PyObject * obj1 = 0 ;
29627 char * kwnames[] = {
29628 (char *) "eventType",(char *) "id", NULL
29629 };
29630
29631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29632 if (obj0) {
29633 ecode1 = SWIG_AsVal_int(obj0, &val1);
29634 if (!SWIG_IsOK(ecode1)) {
29635 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29636 }
29637 arg1 = static_cast< wxEventType >(val1);
29638 }
29639 if (obj1) {
29640 ecode2 = SWIG_AsVal_int(obj1, &val2);
29641 if (!SWIG_IsOK(ecode2)) {
29642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29643 }
29644 arg2 = static_cast< int >(val2);
29645 }
29646 {
29647 PyThreadState* __tstate = wxPyBeginAllowThreads();
29648 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29653 return resultobj;
29654 fail:
29655 return NULL;
29656 }
29657
29658
29659 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29660 PyObject *resultobj = 0;
29661 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29662 void *argp1 = 0 ;
29663 int res1 = 0 ;
29664 PyObject *swig_obj[1] ;
29665
29666 if (!args) SWIG_fail;
29667 swig_obj[0] = args;
29668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29669 if (!SWIG_IsOK(res1)) {
29670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29671 }
29672 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29673 {
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 delete arg1;
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 resultobj = SWIG_Py_Void();
29681 return resultobj;
29682 fail:
29683 return NULL;
29684 }
29685
29686
29687 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29688 PyObject *resultobj = 0;
29689 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29690 PyObject *arg2 = (PyObject *) 0 ;
29691 void *argp1 = 0 ;
29692 int res1 = 0 ;
29693 PyObject * obj0 = 0 ;
29694 PyObject * obj1 = 0 ;
29695 char * kwnames[] = {
29696 (char *) "self",(char *) "self", NULL
29697 };
29698
29699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29701 if (!SWIG_IsOK(res1)) {
29702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29703 }
29704 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29705 arg2 = obj1;
29706 {
29707 PyThreadState* __tstate = wxPyBeginAllowThreads();
29708 (arg1)->SetSelf(arg2);
29709 wxPyEndAllowThreads(__tstate);
29710 if (PyErr_Occurred()) SWIG_fail;
29711 }
29712 resultobj = SWIG_Py_Void();
29713 return resultobj;
29714 fail:
29715 return NULL;
29716 }
29717
29718
29719 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29720 PyObject *resultobj = 0;
29721 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29722 PyObject *result = 0 ;
29723 void *argp1 = 0 ;
29724 int res1 = 0 ;
29725 PyObject *swig_obj[1] ;
29726
29727 if (!args) SWIG_fail;
29728 swig_obj[0] = args;
29729 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29730 if (!SWIG_IsOK(res1)) {
29731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29732 }
29733 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 result = (PyObject *)(arg1)->GetSelf();
29737 wxPyEndAllowThreads(__tstate);
29738 if (PyErr_Occurred()) SWIG_fail;
29739 }
29740 resultobj = result;
29741 return resultobj;
29742 fail:
29743 return NULL;
29744 }
29745
29746
29747 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29748 PyObject *obj;
29749 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29750 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29751 return SWIG_Py_Void();
29752 }
29753
29754 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29755 return SWIG_Python_InitShadowInstance(args);
29756 }
29757
29758 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj = 0;
29760 wxWindow *arg1 = (wxWindow *) 0 ;
29761 wxDateTime *arg2 = 0 ;
29762 wxEventType arg3 ;
29763 wxDateEvent *result = 0 ;
29764 void *argp1 = 0 ;
29765 int res1 = 0 ;
29766 void *argp2 = 0 ;
29767 int res2 = 0 ;
29768 int val3 ;
29769 int ecode3 = 0 ;
29770 PyObject * obj0 = 0 ;
29771 PyObject * obj1 = 0 ;
29772 PyObject * obj2 = 0 ;
29773 char * kwnames[] = {
29774 (char *) "win",(char *) "dt",(char *) "type", NULL
29775 };
29776
29777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29779 if (!SWIG_IsOK(res1)) {
29780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29781 }
29782 arg1 = reinterpret_cast< wxWindow * >(argp1);
29783 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29784 if (!SWIG_IsOK(res2)) {
29785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29786 }
29787 if (!argp2) {
29788 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29789 }
29790 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29791 ecode3 = SWIG_AsVal_int(obj2, &val3);
29792 if (!SWIG_IsOK(ecode3)) {
29793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29794 }
29795 arg3 = static_cast< wxEventType >(val3);
29796 {
29797 PyThreadState* __tstate = wxPyBeginAllowThreads();
29798 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29810 PyObject *resultobj = 0;
29811 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29812 wxDateTime *result = 0 ;
29813 void *argp1 = 0 ;
29814 int res1 = 0 ;
29815 PyObject *swig_obj[1] ;
29816
29817 if (!args) SWIG_fail;
29818 swig_obj[0] = args;
29819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29822 }
29823 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 {
29827 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29828 result = (wxDateTime *) &_result_ref;
29829 }
29830 wxPyEndAllowThreads(__tstate);
29831 if (PyErr_Occurred()) SWIG_fail;
29832 }
29833 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29834 return resultobj;
29835 fail:
29836 return NULL;
29837 }
29838
29839
29840 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29841 PyObject *resultobj = 0;
29842 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29843 wxDateTime *arg2 = 0 ;
29844 void *argp1 = 0 ;
29845 int res1 = 0 ;
29846 void *argp2 = 0 ;
29847 int res2 = 0 ;
29848 PyObject * obj0 = 0 ;
29849 PyObject * obj1 = 0 ;
29850 char * kwnames[] = {
29851 (char *) "self",(char *) "date", NULL
29852 };
29853
29854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29856 if (!SWIG_IsOK(res1)) {
29857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29858 }
29859 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29860 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29861 if (!SWIG_IsOK(res2)) {
29862 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29863 }
29864 if (!argp2) {
29865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29866 }
29867 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29868 {
29869 PyThreadState* __tstate = wxPyBeginAllowThreads();
29870 (arg1)->SetDate((wxDateTime const &)*arg2);
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_Py_Void();
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29882 PyObject *obj;
29883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29884 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29885 return SWIG_Py_Void();
29886 }
29887
29888 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29889 return SWIG_Python_InitShadowInstance(args);
29890 }
29891
29892 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 PyObject *resultobj = 0;
29894 wxPyApp *result = 0 ;
29895
29896 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 result = (wxPyApp *)new_wxPyApp();
29900 wxPyEndAllowThreads(__tstate);
29901 if (PyErr_Occurred()) SWIG_fail;
29902 }
29903 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
29904 return resultobj;
29905 fail:
29906 return NULL;
29907 }
29908
29909
29910 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29911 PyObject *resultobj = 0;
29912 wxPyApp *arg1 = (wxPyApp *) 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_wxPyApp, SWIG_POINTER_DISOWN | 0 );
29920 if (!SWIG_IsOK(res1)) {
29921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
29922 }
29923 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29924 {
29925 PyThreadState* __tstate = wxPyBeginAllowThreads();
29926 delete arg1;
29927
29928 wxPyEndAllowThreads(__tstate);
29929 if (PyErr_Occurred()) SWIG_fail;
29930 }
29931 resultobj = SWIG_Py_Void();
29932 return resultobj;
29933 fail:
29934 return NULL;
29935 }
29936
29937
29938 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29939 PyObject *resultobj = 0;
29940 wxPyApp *arg1 = (wxPyApp *) 0 ;
29941 PyObject *arg2 = (PyObject *) 0 ;
29942 PyObject *arg3 = (PyObject *) 0 ;
29943 bool arg4 ;
29944 void *argp1 = 0 ;
29945 int res1 = 0 ;
29946 bool val4 ;
29947 int ecode4 = 0 ;
29948 PyObject * obj0 = 0 ;
29949 PyObject * obj1 = 0 ;
29950 PyObject * obj2 = 0 ;
29951 PyObject * obj3 = 0 ;
29952 char * kwnames[] = {
29953 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
29954 };
29955
29956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29958 if (!SWIG_IsOK(res1)) {
29959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
29960 }
29961 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29962 arg2 = obj1;
29963 arg3 = obj2;
29964 ecode4 = SWIG_AsVal_bool(obj3, &val4);
29965 if (!SWIG_IsOK(ecode4)) {
29966 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
29967 }
29968 arg4 = static_cast< bool >(val4);
29969 {
29970 PyThreadState* __tstate = wxPyBeginAllowThreads();
29971 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
29972 wxPyEndAllowThreads(__tstate);
29973 if (PyErr_Occurred()) SWIG_fail;
29974 }
29975 resultobj = SWIG_Py_Void();
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29983 PyObject *resultobj = 0;
29984 wxPyApp *arg1 = (wxPyApp *) 0 ;
29985 wxString result;
29986 void *argp1 = 0 ;
29987 int res1 = 0 ;
29988 PyObject *swig_obj[1] ;
29989
29990 if (!args) SWIG_fail;
29991 swig_obj[0] = args;
29992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
29993 if (!SWIG_IsOK(res1)) {
29994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
29995 }
29996 arg1 = reinterpret_cast< wxPyApp * >(argp1);
29997 {
29998 PyThreadState* __tstate = wxPyBeginAllowThreads();
29999 result = ((wxPyApp const *)arg1)->GetAppName();
30000 wxPyEndAllowThreads(__tstate);
30001 if (PyErr_Occurred()) SWIG_fail;
30002 }
30003 {
30004 #if wxUSE_UNICODE
30005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30006 #else
30007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30008 #endif
30009 }
30010 return resultobj;
30011 fail:
30012 return NULL;
30013 }
30014
30015
30016 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30017 PyObject *resultobj = 0;
30018 wxPyApp *arg1 = (wxPyApp *) 0 ;
30019 wxString *arg2 = 0 ;
30020 void *argp1 = 0 ;
30021 int res1 = 0 ;
30022 bool temp2 = false ;
30023 PyObject * obj0 = 0 ;
30024 PyObject * obj1 = 0 ;
30025 char * kwnames[] = {
30026 (char *) "self",(char *) "name", NULL
30027 };
30028
30029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30031 if (!SWIG_IsOK(res1)) {
30032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30033 }
30034 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30035 {
30036 arg2 = wxString_in_helper(obj1);
30037 if (arg2 == NULL) SWIG_fail;
30038 temp2 = true;
30039 }
30040 {
30041 PyThreadState* __tstate = wxPyBeginAllowThreads();
30042 (arg1)->SetAppName((wxString const &)*arg2);
30043 wxPyEndAllowThreads(__tstate);
30044 if (PyErr_Occurred()) SWIG_fail;
30045 }
30046 resultobj = SWIG_Py_Void();
30047 {
30048 if (temp2)
30049 delete arg2;
30050 }
30051 return resultobj;
30052 fail:
30053 {
30054 if (temp2)
30055 delete arg2;
30056 }
30057 return NULL;
30058 }
30059
30060
30061 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30062 PyObject *resultobj = 0;
30063 wxPyApp *arg1 = (wxPyApp *) 0 ;
30064 wxString result;
30065 void *argp1 = 0 ;
30066 int res1 = 0 ;
30067 PyObject *swig_obj[1] ;
30068
30069 if (!args) SWIG_fail;
30070 swig_obj[0] = args;
30071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30072 if (!SWIG_IsOK(res1)) {
30073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30074 }
30075 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30076 {
30077 PyThreadState* __tstate = wxPyBeginAllowThreads();
30078 result = ((wxPyApp const *)arg1)->GetClassName();
30079 wxPyEndAllowThreads(__tstate);
30080 if (PyErr_Occurred()) SWIG_fail;
30081 }
30082 {
30083 #if wxUSE_UNICODE
30084 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30085 #else
30086 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30087 #endif
30088 }
30089 return resultobj;
30090 fail:
30091 return NULL;
30092 }
30093
30094
30095 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30096 PyObject *resultobj = 0;
30097 wxPyApp *arg1 = (wxPyApp *) 0 ;
30098 wxString *arg2 = 0 ;
30099 void *argp1 = 0 ;
30100 int res1 = 0 ;
30101 bool temp2 = false ;
30102 PyObject * obj0 = 0 ;
30103 PyObject * obj1 = 0 ;
30104 char * kwnames[] = {
30105 (char *) "self",(char *) "name", NULL
30106 };
30107
30108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30110 if (!SWIG_IsOK(res1)) {
30111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30112 }
30113 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30114 {
30115 arg2 = wxString_in_helper(obj1);
30116 if (arg2 == NULL) SWIG_fail;
30117 temp2 = true;
30118 }
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 (arg1)->SetClassName((wxString const &)*arg2);
30122 wxPyEndAllowThreads(__tstate);
30123 if (PyErr_Occurred()) SWIG_fail;
30124 }
30125 resultobj = SWIG_Py_Void();
30126 {
30127 if (temp2)
30128 delete arg2;
30129 }
30130 return resultobj;
30131 fail:
30132 {
30133 if (temp2)
30134 delete arg2;
30135 }
30136 return NULL;
30137 }
30138
30139
30140 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30141 PyObject *resultobj = 0;
30142 wxPyApp *arg1 = (wxPyApp *) 0 ;
30143 wxString *result = 0 ;
30144 void *argp1 = 0 ;
30145 int res1 = 0 ;
30146 PyObject *swig_obj[1] ;
30147
30148 if (!args) SWIG_fail;
30149 swig_obj[0] = args;
30150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30151 if (!SWIG_IsOK(res1)) {
30152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30153 }
30154 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 {
30158 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30159 result = (wxString *) &_result_ref;
30160 }
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 {
30165 #if wxUSE_UNICODE
30166 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30167 #else
30168 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30169 #endif
30170 }
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj = 0;
30179 wxPyApp *arg1 = (wxPyApp *) 0 ;
30180 wxString *arg2 = 0 ;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 bool temp2 = false ;
30184 PyObject * obj0 = 0 ;
30185 PyObject * obj1 = 0 ;
30186 char * kwnames[] = {
30187 (char *) "self",(char *) "name", NULL
30188 };
30189
30190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30192 if (!SWIG_IsOK(res1)) {
30193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30194 }
30195 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30196 {
30197 arg2 = wxString_in_helper(obj1);
30198 if (arg2 == NULL) SWIG_fail;
30199 temp2 = true;
30200 }
30201 {
30202 PyThreadState* __tstate = wxPyBeginAllowThreads();
30203 (arg1)->SetVendorName((wxString const &)*arg2);
30204 wxPyEndAllowThreads(__tstate);
30205 if (PyErr_Occurred()) SWIG_fail;
30206 }
30207 resultobj = SWIG_Py_Void();
30208 {
30209 if (temp2)
30210 delete arg2;
30211 }
30212 return resultobj;
30213 fail:
30214 {
30215 if (temp2)
30216 delete arg2;
30217 }
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223 PyObject *resultobj = 0;
30224 wxPyApp *arg1 = (wxPyApp *) 0 ;
30225 wxAppTraits *result = 0 ;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 PyObject *swig_obj[1] ;
30229
30230 if (!args) SWIG_fail;
30231 swig_obj[0] = args;
30232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30233 if (!SWIG_IsOK(res1)) {
30234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30235 }
30236 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 result = (wxAppTraits *)(arg1)->GetTraits();
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30244 return resultobj;
30245 fail:
30246 return NULL;
30247 }
30248
30249
30250 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30251 PyObject *resultobj = 0;
30252 wxPyApp *arg1 = (wxPyApp *) 0 ;
30253 void *argp1 = 0 ;
30254 int res1 = 0 ;
30255 PyObject *swig_obj[1] ;
30256
30257 if (!args) SWIG_fail;
30258 swig_obj[0] = args;
30259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30260 if (!SWIG_IsOK(res1)) {
30261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30262 }
30263 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30264 {
30265 PyThreadState* __tstate = wxPyBeginAllowThreads();
30266 (arg1)->ProcessPendingEvents();
30267 wxPyEndAllowThreads(__tstate);
30268 if (PyErr_Occurred()) SWIG_fail;
30269 }
30270 resultobj = SWIG_Py_Void();
30271 return resultobj;
30272 fail:
30273 return NULL;
30274 }
30275
30276
30277 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30278 PyObject *resultobj = 0;
30279 wxPyApp *arg1 = (wxPyApp *) 0 ;
30280 bool arg2 = (bool) false ;
30281 bool result;
30282 void *argp1 = 0 ;
30283 int res1 = 0 ;
30284 bool val2 ;
30285 int ecode2 = 0 ;
30286 PyObject * obj0 = 0 ;
30287 PyObject * obj1 = 0 ;
30288 char * kwnames[] = {
30289 (char *) "self",(char *) "onlyIfNeeded", NULL
30290 };
30291
30292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30293 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30294 if (!SWIG_IsOK(res1)) {
30295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30296 }
30297 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30298 if (obj1) {
30299 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30300 if (!SWIG_IsOK(ecode2)) {
30301 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30302 }
30303 arg2 = static_cast< bool >(val2);
30304 }
30305 {
30306 PyThreadState* __tstate = wxPyBeginAllowThreads();
30307 result = (bool)(arg1)->Yield(arg2);
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 {
30312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30313 }
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30321 PyObject *resultobj = 0;
30322 wxPyApp *arg1 = (wxPyApp *) 0 ;
30323 void *argp1 = 0 ;
30324 int res1 = 0 ;
30325 PyObject *swig_obj[1] ;
30326
30327 if (!args) SWIG_fail;
30328 swig_obj[0] = args;
30329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30330 if (!SWIG_IsOK(res1)) {
30331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30332 }
30333 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 (arg1)->WakeUpIdle();
30337 wxPyEndAllowThreads(__tstate);
30338 if (PyErr_Occurred()) SWIG_fail;
30339 }
30340 resultobj = SWIG_Py_Void();
30341 return resultobj;
30342 fail:
30343 return NULL;
30344 }
30345
30346
30347 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30348 PyObject *resultobj = 0;
30349 bool result;
30350
30351 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30352 {
30353 PyThreadState* __tstate = wxPyBeginAllowThreads();
30354 result = (bool)wxPyApp::IsMainLoopRunning();
30355 wxPyEndAllowThreads(__tstate);
30356 if (PyErr_Occurred()) SWIG_fail;
30357 }
30358 {
30359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30360 }
30361 return resultobj;
30362 fail:
30363 return NULL;
30364 }
30365
30366
30367 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30368 PyObject *resultobj = 0;
30369 wxPyApp *arg1 = (wxPyApp *) 0 ;
30370 int result;
30371 void *argp1 = 0 ;
30372 int res1 = 0 ;
30373 PyObject *swig_obj[1] ;
30374
30375 if (!args) SWIG_fail;
30376 swig_obj[0] = args;
30377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30378 if (!SWIG_IsOK(res1)) {
30379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30380 }
30381 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30382 {
30383 PyThreadState* __tstate = wxPyBeginAllowThreads();
30384 result = (int)(arg1)->MainLoop();
30385 wxPyEndAllowThreads(__tstate);
30386 if (PyErr_Occurred()) SWIG_fail;
30387 }
30388 resultobj = SWIG_From_int(static_cast< int >(result));
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30396 PyObject *resultobj = 0;
30397 wxPyApp *arg1 = (wxPyApp *) 0 ;
30398 void *argp1 = 0 ;
30399 int res1 = 0 ;
30400 PyObject *swig_obj[1] ;
30401
30402 if (!args) SWIG_fail;
30403 swig_obj[0] = args;
30404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30405 if (!SWIG_IsOK(res1)) {
30406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30407 }
30408 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30409 {
30410 PyThreadState* __tstate = wxPyBeginAllowThreads();
30411 (arg1)->Exit();
30412 wxPyEndAllowThreads(__tstate);
30413 if (PyErr_Occurred()) SWIG_fail;
30414 }
30415 resultobj = SWIG_Py_Void();
30416 return resultobj;
30417 fail:
30418 return NULL;
30419 }
30420
30421
30422 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30423 PyObject *resultobj = 0;
30424 wxPyApp *arg1 = (wxPyApp *) 0 ;
30425 wxLayoutDirection result;
30426 void *argp1 = 0 ;
30427 int res1 = 0 ;
30428 PyObject *swig_obj[1] ;
30429
30430 if (!args) SWIG_fail;
30431 swig_obj[0] = args;
30432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30433 if (!SWIG_IsOK(res1)) {
30434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30435 }
30436 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30437 {
30438 PyThreadState* __tstate = wxPyBeginAllowThreads();
30439 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30440 wxPyEndAllowThreads(__tstate);
30441 if (PyErr_Occurred()) SWIG_fail;
30442 }
30443 resultobj = SWIG_From_int(static_cast< int >(result));
30444 return resultobj;
30445 fail:
30446 return NULL;
30447 }
30448
30449
30450 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30451 PyObject *resultobj = 0;
30452 wxPyApp *arg1 = (wxPyApp *) 0 ;
30453 void *argp1 = 0 ;
30454 int res1 = 0 ;
30455 PyObject *swig_obj[1] ;
30456
30457 if (!args) SWIG_fail;
30458 swig_obj[0] = args;
30459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30460 if (!SWIG_IsOK(res1)) {
30461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30462 }
30463 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30464 {
30465 PyThreadState* __tstate = wxPyBeginAllowThreads();
30466 (arg1)->ExitMainLoop();
30467 wxPyEndAllowThreads(__tstate);
30468 if (PyErr_Occurred()) SWIG_fail;
30469 }
30470 resultobj = SWIG_Py_Void();
30471 return resultobj;
30472 fail:
30473 return NULL;
30474 }
30475
30476
30477 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30478 PyObject *resultobj = 0;
30479 wxPyApp *arg1 = (wxPyApp *) 0 ;
30480 bool result;
30481 void *argp1 = 0 ;
30482 int res1 = 0 ;
30483 PyObject *swig_obj[1] ;
30484
30485 if (!args) SWIG_fail;
30486 swig_obj[0] = args;
30487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30488 if (!SWIG_IsOK(res1)) {
30489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30490 }
30491 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30492 {
30493 PyThreadState* __tstate = wxPyBeginAllowThreads();
30494 result = (bool)(arg1)->Pending();
30495 wxPyEndAllowThreads(__tstate);
30496 if (PyErr_Occurred()) SWIG_fail;
30497 }
30498 {
30499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30500 }
30501 return resultobj;
30502 fail:
30503 return NULL;
30504 }
30505
30506
30507 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30508 PyObject *resultobj = 0;
30509 wxPyApp *arg1 = (wxPyApp *) 0 ;
30510 bool result;
30511 void *argp1 = 0 ;
30512 int res1 = 0 ;
30513 PyObject *swig_obj[1] ;
30514
30515 if (!args) SWIG_fail;
30516 swig_obj[0] = args;
30517 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30518 if (!SWIG_IsOK(res1)) {
30519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30520 }
30521 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30522 {
30523 PyThreadState* __tstate = wxPyBeginAllowThreads();
30524 result = (bool)(arg1)->Dispatch();
30525 wxPyEndAllowThreads(__tstate);
30526 if (PyErr_Occurred()) SWIG_fail;
30527 }
30528 {
30529 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30530 }
30531 return resultobj;
30532 fail:
30533 return NULL;
30534 }
30535
30536
30537 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30538 PyObject *resultobj = 0;
30539 wxPyApp *arg1 = (wxPyApp *) 0 ;
30540 bool result;
30541 void *argp1 = 0 ;
30542 int res1 = 0 ;
30543 PyObject *swig_obj[1] ;
30544
30545 if (!args) SWIG_fail;
30546 swig_obj[0] = args;
30547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30548 if (!SWIG_IsOK(res1)) {
30549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30550 }
30551 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30552 {
30553 PyThreadState* __tstate = wxPyBeginAllowThreads();
30554 result = (bool)(arg1)->ProcessIdle();
30555 wxPyEndAllowThreads(__tstate);
30556 if (PyErr_Occurred()) SWIG_fail;
30557 }
30558 {
30559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30560 }
30561 return resultobj;
30562 fail:
30563 return NULL;
30564 }
30565
30566
30567 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30568 PyObject *resultobj = 0;
30569 wxPyApp *arg1 = (wxPyApp *) 0 ;
30570 wxWindow *arg2 = (wxWindow *) 0 ;
30571 wxIdleEvent *arg3 = 0 ;
30572 bool result;
30573 void *argp1 = 0 ;
30574 int res1 = 0 ;
30575 void *argp2 = 0 ;
30576 int res2 = 0 ;
30577 void *argp3 = 0 ;
30578 int res3 = 0 ;
30579 PyObject * obj0 = 0 ;
30580 PyObject * obj1 = 0 ;
30581 PyObject * obj2 = 0 ;
30582 char * kwnames[] = {
30583 (char *) "self",(char *) "win",(char *) "event", NULL
30584 };
30585
30586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30588 if (!SWIG_IsOK(res1)) {
30589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30590 }
30591 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30592 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30593 if (!SWIG_IsOK(res2)) {
30594 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30595 }
30596 arg2 = reinterpret_cast< wxWindow * >(argp2);
30597 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30598 if (!SWIG_IsOK(res3)) {
30599 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30600 }
30601 if (!argp3) {
30602 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30603 }
30604 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30605 {
30606 PyThreadState* __tstate = wxPyBeginAllowThreads();
30607 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30608 wxPyEndAllowThreads(__tstate);
30609 if (PyErr_Occurred()) SWIG_fail;
30610 }
30611 {
30612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30613 }
30614 return resultobj;
30615 fail:
30616 return NULL;
30617 }
30618
30619
30620 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30621 PyObject *resultobj = 0;
30622 wxPyApp *arg1 = (wxPyApp *) 0 ;
30623 bool result;
30624 void *argp1 = 0 ;
30625 int res1 = 0 ;
30626 PyObject *swig_obj[1] ;
30627
30628 if (!args) SWIG_fail;
30629 swig_obj[0] = args;
30630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30631 if (!SWIG_IsOK(res1)) {
30632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30633 }
30634 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30635 {
30636 PyThreadState* __tstate = wxPyBeginAllowThreads();
30637 result = (bool)((wxPyApp const *)arg1)->IsActive();
30638 wxPyEndAllowThreads(__tstate);
30639 if (PyErr_Occurred()) SWIG_fail;
30640 }
30641 {
30642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30643 }
30644 return resultobj;
30645 fail:
30646 return NULL;
30647 }
30648
30649
30650 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30651 PyObject *resultobj = 0;
30652 wxPyApp *arg1 = (wxPyApp *) 0 ;
30653 wxWindow *arg2 = (wxWindow *) 0 ;
30654 void *argp1 = 0 ;
30655 int res1 = 0 ;
30656 void *argp2 = 0 ;
30657 int res2 = 0 ;
30658 PyObject * obj0 = 0 ;
30659 PyObject * obj1 = 0 ;
30660 char * kwnames[] = {
30661 (char *) "self",(char *) "win", NULL
30662 };
30663
30664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30666 if (!SWIG_IsOK(res1)) {
30667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30668 }
30669 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30670 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30671 if (!SWIG_IsOK(res2)) {
30672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30673 }
30674 arg2 = reinterpret_cast< wxWindow * >(argp2);
30675 {
30676 PyThreadState* __tstate = wxPyBeginAllowThreads();
30677 (arg1)->SetTopWindow(arg2);
30678 wxPyEndAllowThreads(__tstate);
30679 if (PyErr_Occurred()) SWIG_fail;
30680 }
30681 resultobj = SWIG_Py_Void();
30682 return resultobj;
30683 fail:
30684 return NULL;
30685 }
30686
30687
30688 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30689 PyObject *resultobj = 0;
30690 wxPyApp *arg1 = (wxPyApp *) 0 ;
30691 wxWindow *result = 0 ;
30692 void *argp1 = 0 ;
30693 int res1 = 0 ;
30694 PyObject *swig_obj[1] ;
30695
30696 if (!args) SWIG_fail;
30697 swig_obj[0] = args;
30698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30699 if (!SWIG_IsOK(res1)) {
30700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30701 }
30702 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30703 {
30704 PyThreadState* __tstate = wxPyBeginAllowThreads();
30705 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30706 wxPyEndAllowThreads(__tstate);
30707 if (PyErr_Occurred()) SWIG_fail;
30708 }
30709 {
30710 resultobj = wxPyMake_wxObject(result, (bool)0);
30711 }
30712 return resultobj;
30713 fail:
30714 return NULL;
30715 }
30716
30717
30718 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30719 PyObject *resultobj = 0;
30720 wxPyApp *arg1 = (wxPyApp *) 0 ;
30721 bool arg2 ;
30722 void *argp1 = 0 ;
30723 int res1 = 0 ;
30724 bool val2 ;
30725 int ecode2 = 0 ;
30726 PyObject * obj0 = 0 ;
30727 PyObject * obj1 = 0 ;
30728 char * kwnames[] = {
30729 (char *) "self",(char *) "flag", NULL
30730 };
30731
30732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30734 if (!SWIG_IsOK(res1)) {
30735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30736 }
30737 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30738 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30739 if (!SWIG_IsOK(ecode2)) {
30740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30741 }
30742 arg2 = static_cast< bool >(val2);
30743 {
30744 PyThreadState* __tstate = wxPyBeginAllowThreads();
30745 (arg1)->SetExitOnFrameDelete(arg2);
30746 wxPyEndAllowThreads(__tstate);
30747 if (PyErr_Occurred()) SWIG_fail;
30748 }
30749 resultobj = SWIG_Py_Void();
30750 return resultobj;
30751 fail:
30752 return NULL;
30753 }
30754
30755
30756 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30757 PyObject *resultobj = 0;
30758 wxPyApp *arg1 = (wxPyApp *) 0 ;
30759 bool result;
30760 void *argp1 = 0 ;
30761 int res1 = 0 ;
30762 PyObject *swig_obj[1] ;
30763
30764 if (!args) SWIG_fail;
30765 swig_obj[0] = args;
30766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30767 if (!SWIG_IsOK(res1)) {
30768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30769 }
30770 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30771 {
30772 PyThreadState* __tstate = wxPyBeginAllowThreads();
30773 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30774 wxPyEndAllowThreads(__tstate);
30775 if (PyErr_Occurred()) SWIG_fail;
30776 }
30777 {
30778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30779 }
30780 return resultobj;
30781 fail:
30782 return NULL;
30783 }
30784
30785
30786 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30787 PyObject *resultobj = 0;
30788 wxPyApp *arg1 = (wxPyApp *) 0 ;
30789 bool arg2 ;
30790 void *argp1 = 0 ;
30791 int res1 = 0 ;
30792 bool val2 ;
30793 int ecode2 = 0 ;
30794 PyObject * obj0 = 0 ;
30795 PyObject * obj1 = 0 ;
30796 char * kwnames[] = {
30797 (char *) "self",(char *) "flag", NULL
30798 };
30799
30800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
30801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30802 if (!SWIG_IsOK(res1)) {
30803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30804 }
30805 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30807 if (!SWIG_IsOK(ecode2)) {
30808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30809 }
30810 arg2 = static_cast< bool >(val2);
30811 {
30812 PyThreadState* __tstate = wxPyBeginAllowThreads();
30813 (arg1)->SetUseBestVisual(arg2);
30814 wxPyEndAllowThreads(__tstate);
30815 if (PyErr_Occurred()) SWIG_fail;
30816 }
30817 resultobj = SWIG_Py_Void();
30818 return resultobj;
30819 fail:
30820 return NULL;
30821 }
30822
30823
30824 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30825 PyObject *resultobj = 0;
30826 wxPyApp *arg1 = (wxPyApp *) 0 ;
30827 bool result;
30828 void *argp1 = 0 ;
30829 int res1 = 0 ;
30830 PyObject *swig_obj[1] ;
30831
30832 if (!args) SWIG_fail;
30833 swig_obj[0] = args;
30834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30835 if (!SWIG_IsOK(res1)) {
30836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30837 }
30838 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30839 {
30840 PyThreadState* __tstate = wxPyBeginAllowThreads();
30841 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30842 wxPyEndAllowThreads(__tstate);
30843 if (PyErr_Occurred()) SWIG_fail;
30844 }
30845 {
30846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30847 }
30848 return resultobj;
30849 fail:
30850 return NULL;
30851 }
30852
30853
30854 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30855 PyObject *resultobj = 0;
30856 wxPyApp *arg1 = (wxPyApp *) 0 ;
30857 int arg2 ;
30858 void *argp1 = 0 ;
30859 int res1 = 0 ;
30860 int val2 ;
30861 int ecode2 = 0 ;
30862 PyObject * obj0 = 0 ;
30863 PyObject * obj1 = 0 ;
30864 char * kwnames[] = {
30865 (char *) "self",(char *) "mode", NULL
30866 };
30867
30868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
30869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30870 if (!SWIG_IsOK(res1)) {
30871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30872 }
30873 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30874 ecode2 = SWIG_AsVal_int(obj1, &val2);
30875 if (!SWIG_IsOK(ecode2)) {
30876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
30877 }
30878 arg2 = static_cast< int >(val2);
30879 {
30880 PyThreadState* __tstate = wxPyBeginAllowThreads();
30881 (arg1)->SetPrintMode(arg2);
30882 wxPyEndAllowThreads(__tstate);
30883 if (PyErr_Occurred()) SWIG_fail;
30884 }
30885 resultobj = SWIG_Py_Void();
30886 return resultobj;
30887 fail:
30888 return NULL;
30889 }
30890
30891
30892 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30893 PyObject *resultobj = 0;
30894 wxPyApp *arg1 = (wxPyApp *) 0 ;
30895 int result;
30896 void *argp1 = 0 ;
30897 int res1 = 0 ;
30898 PyObject *swig_obj[1] ;
30899
30900 if (!args) SWIG_fail;
30901 swig_obj[0] = args;
30902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30903 if (!SWIG_IsOK(res1)) {
30904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30905 }
30906 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30907 {
30908 PyThreadState* __tstate = wxPyBeginAllowThreads();
30909 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
30910 wxPyEndAllowThreads(__tstate);
30911 if (PyErr_Occurred()) SWIG_fail;
30912 }
30913 resultobj = SWIG_From_int(static_cast< int >(result));
30914 return resultobj;
30915 fail:
30916 return NULL;
30917 }
30918
30919
30920 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30921 PyObject *resultobj = 0;
30922 wxPyApp *arg1 = (wxPyApp *) 0 ;
30923 int arg2 ;
30924 void *argp1 = 0 ;
30925 int res1 = 0 ;
30926 int val2 ;
30927 int ecode2 = 0 ;
30928 PyObject * obj0 = 0 ;
30929 PyObject * obj1 = 0 ;
30930 char * kwnames[] = {
30931 (char *) "self",(char *) "mode", NULL
30932 };
30933
30934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
30935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30936 if (!SWIG_IsOK(res1)) {
30937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30938 }
30939 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30940 ecode2 = SWIG_AsVal_int(obj1, &val2);
30941 if (!SWIG_IsOK(ecode2)) {
30942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
30943 }
30944 arg2 = static_cast< int >(val2);
30945 {
30946 PyThreadState* __tstate = wxPyBeginAllowThreads();
30947 (arg1)->SetAssertMode(arg2);
30948 wxPyEndAllowThreads(__tstate);
30949 if (PyErr_Occurred()) SWIG_fail;
30950 }
30951 resultobj = SWIG_Py_Void();
30952 return resultobj;
30953 fail:
30954 return NULL;
30955 }
30956
30957
30958 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30959 PyObject *resultobj = 0;
30960 wxPyApp *arg1 = (wxPyApp *) 0 ;
30961 int result;
30962 void *argp1 = 0 ;
30963 int res1 = 0 ;
30964 PyObject *swig_obj[1] ;
30965
30966 if (!args) SWIG_fail;
30967 swig_obj[0] = args;
30968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30969 if (!SWIG_IsOK(res1)) {
30970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
30971 }
30972 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30973 {
30974 PyThreadState* __tstate = wxPyBeginAllowThreads();
30975 result = (int)(arg1)->GetAssertMode();
30976 wxPyEndAllowThreads(__tstate);
30977 if (PyErr_Occurred()) SWIG_fail;
30978 }
30979 resultobj = SWIG_From_int(static_cast< int >(result));
30980 return resultobj;
30981 fail:
30982 return NULL;
30983 }
30984
30985
30986 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30987 PyObject *resultobj = 0;
30988 bool result;
30989
30990 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
30991 {
30992 PyThreadState* __tstate = wxPyBeginAllowThreads();
30993 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
30994 wxPyEndAllowThreads(__tstate);
30995 if (PyErr_Occurred()) SWIG_fail;
30996 }
30997 {
30998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30999 }
31000 return resultobj;
31001 fail:
31002 return NULL;
31003 }
31004
31005
31006 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31007 PyObject *resultobj = 0;
31008 long result;
31009
31010 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31011 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 result = (long)wxPyApp::GetMacAboutMenuItemId();
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 resultobj = SWIG_From_long(static_cast< long >(result));
31018 return resultobj;
31019 fail:
31020 return NULL;
31021 }
31022
31023
31024 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31025 PyObject *resultobj = 0;
31026 long result;
31027
31028 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31029 {
31030 PyThreadState* __tstate = wxPyBeginAllowThreads();
31031 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31032 wxPyEndAllowThreads(__tstate);
31033 if (PyErr_Occurred()) SWIG_fail;
31034 }
31035 resultobj = SWIG_From_long(static_cast< long >(result));
31036 return resultobj;
31037 fail:
31038 return NULL;
31039 }
31040
31041
31042 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31043 PyObject *resultobj = 0;
31044 long result;
31045
31046 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31047 {
31048 PyThreadState* __tstate = wxPyBeginAllowThreads();
31049 result = (long)wxPyApp::GetMacExitMenuItemId();
31050 wxPyEndAllowThreads(__tstate);
31051 if (PyErr_Occurred()) SWIG_fail;
31052 }
31053 resultobj = SWIG_From_long(static_cast< long >(result));
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31061 PyObject *resultobj = 0;
31062 wxString result;
31063
31064 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31065 {
31066 PyThreadState* __tstate = wxPyBeginAllowThreads();
31067 result = wxPyApp::GetMacHelpMenuTitleName();
31068 wxPyEndAllowThreads(__tstate);
31069 if (PyErr_Occurred()) SWIG_fail;
31070 }
31071 {
31072 #if wxUSE_UNICODE
31073 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31074 #else
31075 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31076 #endif
31077 }
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj = 0;
31086 bool arg1 ;
31087 bool val1 ;
31088 int ecode1 = 0 ;
31089 PyObject * obj0 = 0 ;
31090 char * kwnames[] = {
31091 (char *) "val", NULL
31092 };
31093
31094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31095 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31096 if (!SWIG_IsOK(ecode1)) {
31097 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31098 }
31099 arg1 = static_cast< bool >(val1);
31100 {
31101 PyThreadState* __tstate = wxPyBeginAllowThreads();
31102 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31103 wxPyEndAllowThreads(__tstate);
31104 if (PyErr_Occurred()) SWIG_fail;
31105 }
31106 resultobj = SWIG_Py_Void();
31107 return resultobj;
31108 fail:
31109 return NULL;
31110 }
31111
31112
31113 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31114 PyObject *resultobj = 0;
31115 long arg1 ;
31116 long val1 ;
31117 int ecode1 = 0 ;
31118 PyObject * obj0 = 0 ;
31119 char * kwnames[] = {
31120 (char *) "val", NULL
31121 };
31122
31123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31124 ecode1 = SWIG_AsVal_long(obj0, &val1);
31125 if (!SWIG_IsOK(ecode1)) {
31126 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31127 }
31128 arg1 = static_cast< long >(val1);
31129 {
31130 PyThreadState* __tstate = wxPyBeginAllowThreads();
31131 wxPyApp::SetMacAboutMenuItemId(arg1);
31132 wxPyEndAllowThreads(__tstate);
31133 if (PyErr_Occurred()) SWIG_fail;
31134 }
31135 resultobj = SWIG_Py_Void();
31136 return resultobj;
31137 fail:
31138 return NULL;
31139 }
31140
31141
31142 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31143 PyObject *resultobj = 0;
31144 long arg1 ;
31145 long val1 ;
31146 int ecode1 = 0 ;
31147 PyObject * obj0 = 0 ;
31148 char * kwnames[] = {
31149 (char *) "val", NULL
31150 };
31151
31152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31153 ecode1 = SWIG_AsVal_long(obj0, &val1);
31154 if (!SWIG_IsOK(ecode1)) {
31155 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31156 }
31157 arg1 = static_cast< long >(val1);
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 resultobj = SWIG_Py_Void();
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31172 PyObject *resultobj = 0;
31173 long arg1 ;
31174 long val1 ;
31175 int ecode1 = 0 ;
31176 PyObject * obj0 = 0 ;
31177 char * kwnames[] = {
31178 (char *) "val", NULL
31179 };
31180
31181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31182 ecode1 = SWIG_AsVal_long(obj0, &val1);
31183 if (!SWIG_IsOK(ecode1)) {
31184 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31185 }
31186 arg1 = static_cast< long >(val1);
31187 {
31188 PyThreadState* __tstate = wxPyBeginAllowThreads();
31189 wxPyApp::SetMacExitMenuItemId(arg1);
31190 wxPyEndAllowThreads(__tstate);
31191 if (PyErr_Occurred()) SWIG_fail;
31192 }
31193 resultobj = SWIG_Py_Void();
31194 return resultobj;
31195 fail:
31196 return NULL;
31197 }
31198
31199
31200 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31201 PyObject *resultobj = 0;
31202 wxString *arg1 = 0 ;
31203 bool temp1 = false ;
31204 PyObject * obj0 = 0 ;
31205 char * kwnames[] = {
31206 (char *) "val", NULL
31207 };
31208
31209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31210 {
31211 arg1 = wxString_in_helper(obj0);
31212 if (arg1 == NULL) SWIG_fail;
31213 temp1 = true;
31214 }
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31218 wxPyEndAllowThreads(__tstate);
31219 if (PyErr_Occurred()) SWIG_fail;
31220 }
31221 resultobj = SWIG_Py_Void();
31222 {
31223 if (temp1)
31224 delete arg1;
31225 }
31226 return resultobj;
31227 fail:
31228 {
31229 if (temp1)
31230 delete arg1;
31231 }
31232 return NULL;
31233 }
31234
31235
31236 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31237 PyObject *resultobj = 0;
31238 wxPyApp *arg1 = (wxPyApp *) 0 ;
31239 void *argp1 = 0 ;
31240 int res1 = 0 ;
31241 PyObject *swig_obj[1] ;
31242
31243 if (!args) SWIG_fail;
31244 swig_obj[0] = args;
31245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31246 if (!SWIG_IsOK(res1)) {
31247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31248 }
31249 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31250 {
31251 PyThreadState* __tstate = wxPyBeginAllowThreads();
31252 (arg1)->_BootstrapApp();
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 resultobj = SWIG_Py_Void();
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31264 PyObject *resultobj = 0;
31265 int result;
31266
31267 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31268 {
31269 PyThreadState* __tstate = wxPyBeginAllowThreads();
31270 result = (int)wxPyApp::GetComCtl32Version();
31271 wxPyEndAllowThreads(__tstate);
31272 if (PyErr_Occurred()) SWIG_fail;
31273 }
31274 resultobj = SWIG_From_int(static_cast< int >(result));
31275 return resultobj;
31276 fail:
31277 return NULL;
31278 }
31279
31280
31281 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31282 PyObject *resultobj = 0;
31283 bool result;
31284
31285 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31286 {
31287 PyThreadState* __tstate = wxPyBeginAllowThreads();
31288 result = (bool)wxPyApp_IsDisplayAvailable();
31289 wxPyEndAllowThreads(__tstate);
31290 if (PyErr_Occurred()) SWIG_fail;
31291 }
31292 {
31293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31294 }
31295 return resultobj;
31296 fail:
31297 return NULL;
31298 }
31299
31300
31301 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31302 PyObject *obj;
31303 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31304 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31305 return SWIG_Py_Void();
31306 }
31307
31308 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31309 return SWIG_Python_InitShadowInstance(args);
31310 }
31311
31312 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31313 PyObject *resultobj = 0;
31314
31315 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31316 {
31317 PyThreadState* __tstate = wxPyBeginAllowThreads();
31318 wxExit();
31319 wxPyEndAllowThreads(__tstate);
31320 if (PyErr_Occurred()) SWIG_fail;
31321 }
31322 resultobj = SWIG_Py_Void();
31323 return resultobj;
31324 fail:
31325 return NULL;
31326 }
31327
31328
31329 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31330 PyObject *resultobj = 0;
31331 bool result;
31332
31333 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31334 {
31335 PyThreadState* __tstate = wxPyBeginAllowThreads();
31336 result = (bool)wxYield();
31337 wxPyEndAllowThreads(__tstate);
31338 if (PyErr_Occurred()) SWIG_fail;
31339 }
31340 {
31341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31342 }
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31350 PyObject *resultobj = 0;
31351 bool result;
31352
31353 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 result = (bool)wxYieldIfNeeded();
31357 wxPyEndAllowThreads(__tstate);
31358 if (PyErr_Occurred()) SWIG_fail;
31359 }
31360 {
31361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31362 }
31363 return resultobj;
31364 fail:
31365 return NULL;
31366 }
31367
31368
31369 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31370 PyObject *resultobj = 0;
31371 wxWindow *arg1 = (wxWindow *) NULL ;
31372 bool arg2 = (bool) false ;
31373 bool result;
31374 void *argp1 = 0 ;
31375 int res1 = 0 ;
31376 bool val2 ;
31377 int ecode2 = 0 ;
31378 PyObject * obj0 = 0 ;
31379 PyObject * obj1 = 0 ;
31380 char * kwnames[] = {
31381 (char *) "win",(char *) "onlyIfNeeded", NULL
31382 };
31383
31384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31385 if (obj0) {
31386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31387 if (!SWIG_IsOK(res1)) {
31388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31389 }
31390 arg1 = reinterpret_cast< wxWindow * >(argp1);
31391 }
31392 if (obj1) {
31393 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31394 if (!SWIG_IsOK(ecode2)) {
31395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31396 }
31397 arg2 = static_cast< bool >(val2);
31398 }
31399 {
31400 PyThreadState* __tstate = wxPyBeginAllowThreads();
31401 result = (bool)wxSafeYield(arg1,arg2);
31402 wxPyEndAllowThreads(__tstate);
31403 if (PyErr_Occurred()) SWIG_fail;
31404 }
31405 {
31406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31407 }
31408 return resultobj;
31409 fail:
31410 return NULL;
31411 }
31412
31413
31414 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31415 PyObject *resultobj = 0;
31416
31417 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31418 {
31419 PyThreadState* __tstate = wxPyBeginAllowThreads();
31420 wxWakeUpIdle();
31421 wxPyEndAllowThreads(__tstate);
31422 if (PyErr_Occurred()) SWIG_fail;
31423 }
31424 resultobj = SWIG_Py_Void();
31425 return resultobj;
31426 fail:
31427 return NULL;
31428 }
31429
31430
31431 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31432 PyObject *resultobj = 0;
31433 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31434 wxEvent *arg2 = 0 ;
31435 void *argp1 = 0 ;
31436 int res1 = 0 ;
31437 void *argp2 = 0 ;
31438 int res2 = 0 ;
31439 PyObject * obj0 = 0 ;
31440 PyObject * obj1 = 0 ;
31441 char * kwnames[] = {
31442 (char *) "dest",(char *) "event", NULL
31443 };
31444
31445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31447 if (!SWIG_IsOK(res1)) {
31448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31449 }
31450 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31451 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31452 if (!SWIG_IsOK(res2)) {
31453 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31454 }
31455 if (!argp2) {
31456 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31457 }
31458 arg2 = reinterpret_cast< wxEvent * >(argp2);
31459 {
31460 PyThreadState* __tstate = wxPyBeginAllowThreads();
31461 wxPostEvent(arg1,*arg2);
31462 wxPyEndAllowThreads(__tstate);
31463 if (PyErr_Occurred()) SWIG_fail;
31464 }
31465 resultobj = SWIG_Py_Void();
31466 return resultobj;
31467 fail:
31468 return NULL;
31469 }
31470
31471
31472 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31473 PyObject *resultobj = 0;
31474
31475 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31476 {
31477 PyThreadState* __tstate = wxPyBeginAllowThreads();
31478 wxApp_CleanUp();
31479 wxPyEndAllowThreads(__tstate);
31480 if (PyErr_Occurred()) SWIG_fail;
31481 }
31482 resultobj = SWIG_Py_Void();
31483 return resultobj;
31484 fail:
31485 return NULL;
31486 }
31487
31488
31489 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31490 PyObject *resultobj = 0;
31491 wxPyApp *result = 0 ;
31492
31493 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31494 {
31495 PyThreadState* __tstate = wxPyBeginAllowThreads();
31496 result = (wxPyApp *)wxPyGetApp();
31497 wxPyEndAllowThreads(__tstate);
31498 if (PyErr_Occurred()) SWIG_fail;
31499 }
31500 {
31501 resultobj = wxPyMake_wxObject(result, 0);
31502 }
31503 return resultobj;
31504 fail:
31505 return NULL;
31506 }
31507
31508
31509 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31510 PyObject *resultobj = 0;
31511 char *arg1 = (char *) 0 ;
31512 int res1 ;
31513 char *buf1 = 0 ;
31514 int alloc1 = 0 ;
31515 PyObject * obj0 = 0 ;
31516 char * kwnames[] = {
31517 (char *) "encoding", NULL
31518 };
31519
31520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31521 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31522 if (!SWIG_IsOK(res1)) {
31523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31524 }
31525 arg1 = buf1;
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 wxSetDefaultPyEncoding((char const *)arg1);
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 resultobj = SWIG_Py_Void();
31533 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31534 return resultobj;
31535 fail:
31536 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31537 return NULL;
31538 }
31539
31540
31541 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31542 PyObject *resultobj = 0;
31543 char *result = 0 ;
31544
31545 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31546 {
31547 PyThreadState* __tstate = wxPyBeginAllowThreads();
31548 result = (char *)wxGetDefaultPyEncoding();
31549 wxPyEndAllowThreads(__tstate);
31550 if (PyErr_Occurred()) SWIG_fail;
31551 }
31552 resultobj = SWIG_FromCharPtr(result);
31553 return resultobj;
31554 fail:
31555 return NULL;
31556 }
31557
31558
31559 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31560 PyObject *resultobj = 0;
31561 wxEventLoop *result = 0 ;
31562
31563 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31564 {
31565 PyThreadState* __tstate = wxPyBeginAllowThreads();
31566 result = (wxEventLoop *)new wxEventLoop();
31567 wxPyEndAllowThreads(__tstate);
31568 if (PyErr_Occurred()) SWIG_fail;
31569 }
31570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31571 return resultobj;
31572 fail:
31573 return NULL;
31574 }
31575
31576
31577 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31578 PyObject *resultobj = 0;
31579 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31580 void *argp1 = 0 ;
31581 int res1 = 0 ;
31582 PyObject *swig_obj[1] ;
31583
31584 if (!args) SWIG_fail;
31585 swig_obj[0] = args;
31586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31587 if (!SWIG_IsOK(res1)) {
31588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31589 }
31590 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31591 {
31592 PyThreadState* __tstate = wxPyBeginAllowThreads();
31593 delete arg1;
31594
31595 wxPyEndAllowThreads(__tstate);
31596 if (PyErr_Occurred()) SWIG_fail;
31597 }
31598 resultobj = SWIG_Py_Void();
31599 return resultobj;
31600 fail:
31601 return NULL;
31602 }
31603
31604
31605 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31606 PyObject *resultobj = 0;
31607 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31608 int result;
31609 void *argp1 = 0 ;
31610 int res1 = 0 ;
31611 PyObject *swig_obj[1] ;
31612
31613 if (!args) SWIG_fail;
31614 swig_obj[0] = args;
31615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31616 if (!SWIG_IsOK(res1)) {
31617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31618 }
31619 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31620 {
31621 PyThreadState* __tstate = wxPyBeginAllowThreads();
31622 result = (int)(arg1)->Run();
31623 wxPyEndAllowThreads(__tstate);
31624 if (PyErr_Occurred()) SWIG_fail;
31625 }
31626 resultobj = SWIG_From_int(static_cast< int >(result));
31627 return resultobj;
31628 fail:
31629 return NULL;
31630 }
31631
31632
31633 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31634 PyObject *resultobj = 0;
31635 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31636 int arg2 = (int) 0 ;
31637 void *argp1 = 0 ;
31638 int res1 = 0 ;
31639 int val2 ;
31640 int ecode2 = 0 ;
31641 PyObject * obj0 = 0 ;
31642 PyObject * obj1 = 0 ;
31643 char * kwnames[] = {
31644 (char *) "self",(char *) "rc", NULL
31645 };
31646
31647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31649 if (!SWIG_IsOK(res1)) {
31650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31651 }
31652 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31653 if (obj1) {
31654 ecode2 = SWIG_AsVal_int(obj1, &val2);
31655 if (!SWIG_IsOK(ecode2)) {
31656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31657 }
31658 arg2 = static_cast< int >(val2);
31659 }
31660 {
31661 PyThreadState* __tstate = wxPyBeginAllowThreads();
31662 (arg1)->Exit(arg2);
31663 wxPyEndAllowThreads(__tstate);
31664 if (PyErr_Occurred()) SWIG_fail;
31665 }
31666 resultobj = SWIG_Py_Void();
31667 return resultobj;
31668 fail:
31669 return NULL;
31670 }
31671
31672
31673 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31674 PyObject *resultobj = 0;
31675 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31676 bool result;
31677 void *argp1 = 0 ;
31678 int res1 = 0 ;
31679 PyObject *swig_obj[1] ;
31680
31681 if (!args) SWIG_fail;
31682 swig_obj[0] = args;
31683 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31684 if (!SWIG_IsOK(res1)) {
31685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31686 }
31687 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31688 {
31689 PyThreadState* __tstate = wxPyBeginAllowThreads();
31690 result = (bool)((wxEventLoop const *)arg1)->Pending();
31691 wxPyEndAllowThreads(__tstate);
31692 if (PyErr_Occurred()) SWIG_fail;
31693 }
31694 {
31695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31696 }
31697 return resultobj;
31698 fail:
31699 return NULL;
31700 }
31701
31702
31703 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31704 PyObject *resultobj = 0;
31705 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31706 bool result;
31707 void *argp1 = 0 ;
31708 int res1 = 0 ;
31709 PyObject *swig_obj[1] ;
31710
31711 if (!args) SWIG_fail;
31712 swig_obj[0] = args;
31713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31714 if (!SWIG_IsOK(res1)) {
31715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31716 }
31717 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31718 {
31719 PyThreadState* __tstate = wxPyBeginAllowThreads();
31720 result = (bool)(arg1)->Dispatch();
31721 wxPyEndAllowThreads(__tstate);
31722 if (PyErr_Occurred()) SWIG_fail;
31723 }
31724 {
31725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31726 }
31727 return resultobj;
31728 fail:
31729 return NULL;
31730 }
31731
31732
31733 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31734 PyObject *resultobj = 0;
31735 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31736 bool result;
31737 void *argp1 = 0 ;
31738 int res1 = 0 ;
31739 PyObject *swig_obj[1] ;
31740
31741 if (!args) SWIG_fail;
31742 swig_obj[0] = args;
31743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31744 if (!SWIG_IsOK(res1)) {
31745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31746 }
31747 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 {
31755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31756 }
31757 return resultobj;
31758 fail:
31759 return NULL;
31760 }
31761
31762
31763 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31764 PyObject *resultobj = 0;
31765 wxEventLoop *result = 0 ;
31766
31767 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31768 {
31769 PyThreadState* __tstate = wxPyBeginAllowThreads();
31770 result = (wxEventLoop *)wxEventLoop::GetActive();
31771 wxPyEndAllowThreads(__tstate);
31772 if (PyErr_Occurred()) SWIG_fail;
31773 }
31774 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31775 return resultobj;
31776 fail:
31777 return NULL;
31778 }
31779
31780
31781 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31782 PyObject *resultobj = 0;
31783 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31784 void *argp1 = 0 ;
31785 int res1 = 0 ;
31786 PyObject * obj0 = 0 ;
31787 char * kwnames[] = {
31788 (char *) "loop", NULL
31789 };
31790
31791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31793 if (!SWIG_IsOK(res1)) {
31794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31795 }
31796 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31797 {
31798 PyThreadState* __tstate = wxPyBeginAllowThreads();
31799 wxEventLoop::SetActive(arg1);
31800 wxPyEndAllowThreads(__tstate);
31801 if (PyErr_Occurred()) SWIG_fail;
31802 }
31803 resultobj = SWIG_Py_Void();
31804 return resultobj;
31805 fail:
31806 return NULL;
31807 }
31808
31809
31810 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31811 PyObject *obj;
31812 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31813 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31814 return SWIG_Py_Void();
31815 }
31816
31817 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31818 return SWIG_Python_InitShadowInstance(args);
31819 }
31820
31821 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31822 PyObject *resultobj = 0;
31823 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31824 wxEventLoopActivator *result = 0 ;
31825 void *argp1 = 0 ;
31826 int res1 = 0 ;
31827 PyObject * obj0 = 0 ;
31828 char * kwnames[] = {
31829 (char *) "evtLoop", NULL
31830 };
31831
31832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31834 if (!SWIG_IsOK(res1)) {
31835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31836 }
31837 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31838 {
31839 PyThreadState* __tstate = wxPyBeginAllowThreads();
31840 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31841 wxPyEndAllowThreads(__tstate);
31842 if (PyErr_Occurred()) SWIG_fail;
31843 }
31844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
31845 return resultobj;
31846 fail:
31847 return NULL;
31848 }
31849
31850
31851 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31852 PyObject *resultobj = 0;
31853 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
31854 void *argp1 = 0 ;
31855 int res1 = 0 ;
31856 PyObject *swig_obj[1] ;
31857
31858 if (!args) SWIG_fail;
31859 swig_obj[0] = args;
31860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
31861 if (!SWIG_IsOK(res1)) {
31862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
31863 }
31864 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
31865 {
31866 PyThreadState* __tstate = wxPyBeginAllowThreads();
31867 delete arg1;
31868
31869 wxPyEndAllowThreads(__tstate);
31870 if (PyErr_Occurred()) SWIG_fail;
31871 }
31872 resultobj = SWIG_Py_Void();
31873 return resultobj;
31874 fail:
31875 return NULL;
31876 }
31877
31878
31879 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 PyObject *obj;
31881 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31882 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
31883 return SWIG_Py_Void();
31884 }
31885
31886 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31887 return SWIG_Python_InitShadowInstance(args);
31888 }
31889
31890 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31891 PyObject *resultobj = 0;
31892 int arg1 = (int) 0 ;
31893 int arg2 = (int) 0 ;
31894 int arg3 = (int) 0 ;
31895 wxAcceleratorEntry *result = 0 ;
31896 int val1 ;
31897 int ecode1 = 0 ;
31898 int val2 ;
31899 int ecode2 = 0 ;
31900 int val3 ;
31901 int ecode3 = 0 ;
31902 PyObject * obj0 = 0 ;
31903 PyObject * obj1 = 0 ;
31904 PyObject * obj2 = 0 ;
31905 char * kwnames[] = {
31906 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
31907 };
31908
31909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31910 if (obj0) {
31911 ecode1 = SWIG_AsVal_int(obj0, &val1);
31912 if (!SWIG_IsOK(ecode1)) {
31913 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
31914 }
31915 arg1 = static_cast< int >(val1);
31916 }
31917 if (obj1) {
31918 ecode2 = SWIG_AsVal_int(obj1, &val2);
31919 if (!SWIG_IsOK(ecode2)) {
31920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
31921 }
31922 arg2 = static_cast< int >(val2);
31923 }
31924 if (obj2) {
31925 ecode3 = SWIG_AsVal_int(obj2, &val3);
31926 if (!SWIG_IsOK(ecode3)) {
31927 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
31928 }
31929 arg3 = static_cast< int >(val3);
31930 }
31931 {
31932 PyThreadState* __tstate = wxPyBeginAllowThreads();
31933 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
31934 wxPyEndAllowThreads(__tstate);
31935 if (PyErr_Occurred()) SWIG_fail;
31936 }
31937 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
31938 return resultobj;
31939 fail:
31940 return NULL;
31941 }
31942
31943
31944 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31945 PyObject *resultobj = 0;
31946 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31947 void *argp1 = 0 ;
31948 int res1 = 0 ;
31949 PyObject *swig_obj[1] ;
31950
31951 if (!args) SWIG_fail;
31952 swig_obj[0] = args;
31953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
31954 if (!SWIG_IsOK(res1)) {
31955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31956 }
31957 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
31958 {
31959 PyThreadState* __tstate = wxPyBeginAllowThreads();
31960 delete arg1;
31961
31962 wxPyEndAllowThreads(__tstate);
31963 if (PyErr_Occurred()) SWIG_fail;
31964 }
31965 resultobj = SWIG_Py_Void();
31966 return resultobj;
31967 fail:
31968 return NULL;
31969 }
31970
31971
31972 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31973 PyObject *resultobj = 0;
31974 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
31975 int arg2 ;
31976 int arg3 ;
31977 int arg4 ;
31978 void *argp1 = 0 ;
31979 int res1 = 0 ;
31980 int val2 ;
31981 int ecode2 = 0 ;
31982 int val3 ;
31983 int ecode3 = 0 ;
31984 int val4 ;
31985 int ecode4 = 0 ;
31986 PyObject * obj0 = 0 ;
31987 PyObject * obj1 = 0 ;
31988 PyObject * obj2 = 0 ;
31989 PyObject * obj3 = 0 ;
31990 char * kwnames[] = {
31991 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
31992 };
31993
31994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
31996 if (!SWIG_IsOK(res1)) {
31997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
31998 }
31999 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32000 ecode2 = SWIG_AsVal_int(obj1, &val2);
32001 if (!SWIG_IsOK(ecode2)) {
32002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32003 }
32004 arg2 = static_cast< int >(val2);
32005 ecode3 = SWIG_AsVal_int(obj2, &val3);
32006 if (!SWIG_IsOK(ecode3)) {
32007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32008 }
32009 arg3 = static_cast< int >(val3);
32010 ecode4 = SWIG_AsVal_int(obj3, &val4);
32011 if (!SWIG_IsOK(ecode4)) {
32012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32013 }
32014 arg4 = static_cast< int >(val4);
32015 {
32016 PyThreadState* __tstate = wxPyBeginAllowThreads();
32017 (arg1)->Set(arg2,arg3,arg4);
32018 wxPyEndAllowThreads(__tstate);
32019 if (PyErr_Occurred()) SWIG_fail;
32020 }
32021 resultobj = SWIG_Py_Void();
32022 return resultobj;
32023 fail:
32024 return NULL;
32025 }
32026
32027
32028 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32029 PyObject *resultobj = 0;
32030 wxString *arg1 = 0 ;
32031 wxAcceleratorEntry *result = 0 ;
32032 bool temp1 = false ;
32033 PyObject * obj0 = 0 ;
32034 char * kwnames[] = {
32035 (char *) "str", NULL
32036 };
32037
32038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32039 {
32040 arg1 = wxString_in_helper(obj0);
32041 if (arg1 == NULL) SWIG_fail;
32042 temp1 = true;
32043 }
32044 {
32045 PyThreadState* __tstate = wxPyBeginAllowThreads();
32046 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32047 wxPyEndAllowThreads(__tstate);
32048 if (PyErr_Occurred()) SWIG_fail;
32049 }
32050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32051 {
32052 if (temp1)
32053 delete arg1;
32054 }
32055 return resultobj;
32056 fail:
32057 {
32058 if (temp1)
32059 delete arg1;
32060 }
32061 return NULL;
32062 }
32063
32064
32065 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32066 PyObject *resultobj = 0;
32067 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32068 int result;
32069 void *argp1 = 0 ;
32070 int res1 = 0 ;
32071 PyObject *swig_obj[1] ;
32072
32073 if (!args) SWIG_fail;
32074 swig_obj[0] = args;
32075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32076 if (!SWIG_IsOK(res1)) {
32077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32078 }
32079 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32080 {
32081 PyThreadState* __tstate = wxPyBeginAllowThreads();
32082 result = (int)(arg1)->GetFlags();
32083 wxPyEndAllowThreads(__tstate);
32084 if (PyErr_Occurred()) SWIG_fail;
32085 }
32086 resultobj = SWIG_From_int(static_cast< int >(result));
32087 return resultobj;
32088 fail:
32089 return NULL;
32090 }
32091
32092
32093 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32094 PyObject *resultobj = 0;
32095 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32096 int result;
32097 void *argp1 = 0 ;
32098 int res1 = 0 ;
32099 PyObject *swig_obj[1] ;
32100
32101 if (!args) SWIG_fail;
32102 swig_obj[0] = args;
32103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32104 if (!SWIG_IsOK(res1)) {
32105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32106 }
32107 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32108 {
32109 PyThreadState* __tstate = wxPyBeginAllowThreads();
32110 result = (int)(arg1)->GetKeyCode();
32111 wxPyEndAllowThreads(__tstate);
32112 if (PyErr_Occurred()) SWIG_fail;
32113 }
32114 resultobj = SWIG_From_int(static_cast< int >(result));
32115 return resultobj;
32116 fail:
32117 return NULL;
32118 }
32119
32120
32121 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32122 PyObject *resultobj = 0;
32123 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32124 int result;
32125 void *argp1 = 0 ;
32126 int res1 = 0 ;
32127 PyObject *swig_obj[1] ;
32128
32129 if (!args) SWIG_fail;
32130 swig_obj[0] = args;
32131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32132 if (!SWIG_IsOK(res1)) {
32133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32134 }
32135 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32136 {
32137 PyThreadState* __tstate = wxPyBeginAllowThreads();
32138 result = (int)(arg1)->GetCommand();
32139 wxPyEndAllowThreads(__tstate);
32140 if (PyErr_Occurred()) SWIG_fail;
32141 }
32142 resultobj = SWIG_From_int(static_cast< int >(result));
32143 return resultobj;
32144 fail:
32145 return NULL;
32146 }
32147
32148
32149 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32150 PyObject *resultobj = 0;
32151 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32152 bool result;
32153 void *argp1 = 0 ;
32154 int res1 = 0 ;
32155 PyObject *swig_obj[1] ;
32156
32157 if (!args) SWIG_fail;
32158 swig_obj[0] = args;
32159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32160 if (!SWIG_IsOK(res1)) {
32161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32162 }
32163 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32164 {
32165 PyThreadState* __tstate = wxPyBeginAllowThreads();
32166 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32167 wxPyEndAllowThreads(__tstate);
32168 if (PyErr_Occurred()) SWIG_fail;
32169 }
32170 {
32171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32172 }
32173 return resultobj;
32174 fail:
32175 return NULL;
32176 }
32177
32178
32179 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32180 PyObject *resultobj = 0;
32181 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32182 wxString result;
32183 void *argp1 = 0 ;
32184 int res1 = 0 ;
32185 PyObject *swig_obj[1] ;
32186
32187 if (!args) SWIG_fail;
32188 swig_obj[0] = args;
32189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32190 if (!SWIG_IsOK(res1)) {
32191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32192 }
32193 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32194 {
32195 PyThreadState* __tstate = wxPyBeginAllowThreads();
32196 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32197 wxPyEndAllowThreads(__tstate);
32198 if (PyErr_Occurred()) SWIG_fail;
32199 }
32200 {
32201 #if wxUSE_UNICODE
32202 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32203 #else
32204 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32205 #endif
32206 }
32207 return resultobj;
32208 fail:
32209 return NULL;
32210 }
32211
32212
32213 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32214 PyObject *resultobj = 0;
32215 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32216 wxString *arg2 = 0 ;
32217 bool result;
32218 void *argp1 = 0 ;
32219 int res1 = 0 ;
32220 bool temp2 = false ;
32221 PyObject * obj0 = 0 ;
32222 PyObject * obj1 = 0 ;
32223 char * kwnames[] = {
32224 (char *) "self",(char *) "str", NULL
32225 };
32226
32227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32229 if (!SWIG_IsOK(res1)) {
32230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32231 }
32232 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32233 {
32234 arg2 = wxString_in_helper(obj1);
32235 if (arg2 == NULL) SWIG_fail;
32236 temp2 = true;
32237 }
32238 {
32239 PyThreadState* __tstate = wxPyBeginAllowThreads();
32240 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32241 wxPyEndAllowThreads(__tstate);
32242 if (PyErr_Occurred()) SWIG_fail;
32243 }
32244 {
32245 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32246 }
32247 {
32248 if (temp2)
32249 delete arg2;
32250 }
32251 return resultobj;
32252 fail:
32253 {
32254 if (temp2)
32255 delete arg2;
32256 }
32257 return NULL;
32258 }
32259
32260
32261 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32262 PyObject *obj;
32263 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32264 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32265 return SWIG_Py_Void();
32266 }
32267
32268 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32269 return SWIG_Python_InitShadowInstance(args);
32270 }
32271
32272 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32273 PyObject *resultobj = 0;
32274 int arg1 ;
32275 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32276 wxAcceleratorTable *result = 0 ;
32277 PyObject * obj0 = 0 ;
32278 char * kwnames[] = {
32279 (char *) "n", NULL
32280 };
32281
32282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32283 {
32284 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32285 if (arg2) arg1 = PyList_Size(obj0);
32286 else arg1 = 0;
32287 }
32288 {
32289 PyThreadState* __tstate = wxPyBeginAllowThreads();
32290 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32291 wxPyEndAllowThreads(__tstate);
32292 if (PyErr_Occurred()) SWIG_fail;
32293 }
32294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32295 return resultobj;
32296 fail:
32297 return NULL;
32298 }
32299
32300
32301 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32302 PyObject *resultobj = 0;
32303 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32304 void *argp1 = 0 ;
32305 int res1 = 0 ;
32306 PyObject *swig_obj[1] ;
32307
32308 if (!args) SWIG_fail;
32309 swig_obj[0] = args;
32310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32311 if (!SWIG_IsOK(res1)) {
32312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32313 }
32314 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32315 {
32316 PyThreadState* __tstate = wxPyBeginAllowThreads();
32317 delete arg1;
32318
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 resultobj = SWIG_Py_Void();
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *resultobj = 0;
32331 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32332 bool result;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 PyObject *swig_obj[1] ;
32336
32337 if (!args) SWIG_fail;
32338 swig_obj[0] = args;
32339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32340 if (!SWIG_IsOK(res1)) {
32341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32342 }
32343 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 {
32351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32352 }
32353 return resultobj;
32354 fail:
32355 return NULL;
32356 }
32357
32358
32359 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32360 PyObject *obj;
32361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32362 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32363 return SWIG_Py_Void();
32364 }
32365
32366 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32367 return SWIG_Python_InitShadowInstance(args);
32368 }
32369
32370 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32371 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32372 return 1;
32373 }
32374
32375
32376 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32377 PyObject *pyobj = 0;
32378
32379 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32380 return pyobj;
32381 }
32382
32383
32384 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32385 PyObject *resultobj = 0;
32386 wxString *arg1 = 0 ;
32387 wxAcceleratorEntry *result = 0 ;
32388 bool temp1 = false ;
32389 PyObject * obj0 = 0 ;
32390 char * kwnames[] = {
32391 (char *) "label", NULL
32392 };
32393
32394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32395 {
32396 arg1 = wxString_in_helper(obj0);
32397 if (arg1 == NULL) SWIG_fail;
32398 temp1 = true;
32399 }
32400 {
32401 PyThreadState* __tstate = wxPyBeginAllowThreads();
32402 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32403 wxPyEndAllowThreads(__tstate);
32404 if (PyErr_Occurred()) SWIG_fail;
32405 }
32406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32407 {
32408 if (temp1)
32409 delete arg1;
32410 }
32411 return resultobj;
32412 fail:
32413 {
32414 if (temp1)
32415 delete arg1;
32416 }
32417 return NULL;
32418 }
32419
32420
32421 SWIGINTERN int PanelNameStr_set(PyObject *) {
32422 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32423 return 1;
32424 }
32425
32426
32427 SWIGINTERN PyObject *PanelNameStr_get(void) {
32428 PyObject *pyobj = 0;
32429
32430 {
32431 #if wxUSE_UNICODE
32432 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32433 #else
32434 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32435 #endif
32436 }
32437 return pyobj;
32438 }
32439
32440
32441 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32442 PyObject *resultobj = 0;
32443 wxVisualAttributes *result = 0 ;
32444
32445 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (wxVisualAttributes *)new_wxVisualAttributes();
32449 wxPyEndAllowThreads(__tstate);
32450 if (PyErr_Occurred()) SWIG_fail;
32451 }
32452 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32453 return resultobj;
32454 fail:
32455 return NULL;
32456 }
32457
32458
32459 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32460 PyObject *resultobj = 0;
32461 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32462 void *argp1 = 0 ;
32463 int res1 = 0 ;
32464 PyObject *swig_obj[1] ;
32465
32466 if (!args) SWIG_fail;
32467 swig_obj[0] = args;
32468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32469 if (!SWIG_IsOK(res1)) {
32470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32471 }
32472 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32473 {
32474 PyThreadState* __tstate = wxPyBeginAllowThreads();
32475 delete_wxVisualAttributes(arg1);
32476
32477 wxPyEndAllowThreads(__tstate);
32478 if (PyErr_Occurred()) SWIG_fail;
32479 }
32480 resultobj = SWIG_Py_Void();
32481 return resultobj;
32482 fail:
32483 return NULL;
32484 }
32485
32486
32487 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32488 PyObject *resultobj = 0;
32489 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32490 wxFont *arg2 = (wxFont *) 0 ;
32491 void *argp1 = 0 ;
32492 int res1 = 0 ;
32493 void *argp2 = 0 ;
32494 int res2 = 0 ;
32495 PyObject *swig_obj[2] ;
32496
32497 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32499 if (!SWIG_IsOK(res1)) {
32500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32501 }
32502 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32503 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32504 if (!SWIG_IsOK(res2)) {
32505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32506 }
32507 arg2 = reinterpret_cast< wxFont * >(argp2);
32508 if (arg1) (arg1)->font = *arg2;
32509
32510 resultobj = SWIG_Py_Void();
32511 return resultobj;
32512 fail:
32513 return NULL;
32514 }
32515
32516
32517 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32518 PyObject *resultobj = 0;
32519 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32520 wxFont *result = 0 ;
32521 void *argp1 = 0 ;
32522 int res1 = 0 ;
32523 PyObject *swig_obj[1] ;
32524
32525 if (!args) SWIG_fail;
32526 swig_obj[0] = args;
32527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32528 if (!SWIG_IsOK(res1)) {
32529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32530 }
32531 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32532 result = (wxFont *)& ((arg1)->font);
32533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32534 return resultobj;
32535 fail:
32536 return NULL;
32537 }
32538
32539
32540 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32541 PyObject *resultobj = 0;
32542 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32543 wxColour *arg2 = (wxColour *) 0 ;
32544 void *argp1 = 0 ;
32545 int res1 = 0 ;
32546 void *argp2 = 0 ;
32547 int res2 = 0 ;
32548 PyObject *swig_obj[2] ;
32549
32550 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32552 if (!SWIG_IsOK(res1)) {
32553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32554 }
32555 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32556 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32557 if (!SWIG_IsOK(res2)) {
32558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32559 }
32560 arg2 = reinterpret_cast< wxColour * >(argp2);
32561 if (arg1) (arg1)->colFg = *arg2;
32562
32563 resultobj = SWIG_Py_Void();
32564 return resultobj;
32565 fail:
32566 return NULL;
32567 }
32568
32569
32570 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32571 PyObject *resultobj = 0;
32572 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32573 wxColour *result = 0 ;
32574 void *argp1 = 0 ;
32575 int res1 = 0 ;
32576 PyObject *swig_obj[1] ;
32577
32578 if (!args) SWIG_fail;
32579 swig_obj[0] = args;
32580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32581 if (!SWIG_IsOK(res1)) {
32582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32583 }
32584 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32585 result = (wxColour *)& ((arg1)->colFg);
32586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32587 return resultobj;
32588 fail:
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32594 PyObject *resultobj = 0;
32595 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32596 wxColour *arg2 = (wxColour *) 0 ;
32597 void *argp1 = 0 ;
32598 int res1 = 0 ;
32599 void *argp2 = 0 ;
32600 int res2 = 0 ;
32601 PyObject *swig_obj[2] ;
32602
32603 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32605 if (!SWIG_IsOK(res1)) {
32606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32607 }
32608 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32609 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32610 if (!SWIG_IsOK(res2)) {
32611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32612 }
32613 arg2 = reinterpret_cast< wxColour * >(argp2);
32614 if (arg1) (arg1)->colBg = *arg2;
32615
32616 resultobj = SWIG_Py_Void();
32617 return resultobj;
32618 fail:
32619 return NULL;
32620 }
32621
32622
32623 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32624 PyObject *resultobj = 0;
32625 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32626 wxColour *result = 0 ;
32627 void *argp1 = 0 ;
32628 int res1 = 0 ;
32629 PyObject *swig_obj[1] ;
32630
32631 if (!args) SWIG_fail;
32632 swig_obj[0] = args;
32633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32634 if (!SWIG_IsOK(res1)) {
32635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32636 }
32637 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32638 result = (wxColour *)& ((arg1)->colBg);
32639 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32640 return resultobj;
32641 fail:
32642 return NULL;
32643 }
32644
32645
32646 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32647 PyObject *obj;
32648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32649 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32650 return SWIG_Py_Void();
32651 }
32652
32653 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32654 return SWIG_Python_InitShadowInstance(args);
32655 }
32656
32657 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32658 PyObject *resultobj = 0;
32659 wxWindow *arg1 = (wxWindow *) 0 ;
32660 int arg2 = (int) (int)-1 ;
32661 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32662 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32663 wxSize const &arg4_defvalue = wxDefaultSize ;
32664 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32665 long arg5 = (long) 0 ;
32666 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32667 wxString *arg6 = (wxString *) &arg6_defvalue ;
32668 wxWindow *result = 0 ;
32669 void *argp1 = 0 ;
32670 int res1 = 0 ;
32671 int val2 ;
32672 int ecode2 = 0 ;
32673 wxPoint temp3 ;
32674 wxSize temp4 ;
32675 long val5 ;
32676 int ecode5 = 0 ;
32677 bool temp6 = false ;
32678 PyObject * obj0 = 0 ;
32679 PyObject * obj1 = 0 ;
32680 PyObject * obj2 = 0 ;
32681 PyObject * obj3 = 0 ;
32682 PyObject * obj4 = 0 ;
32683 PyObject * obj5 = 0 ;
32684 char * kwnames[] = {
32685 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32686 };
32687
32688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32690 if (!SWIG_IsOK(res1)) {
32691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32692 }
32693 arg1 = reinterpret_cast< wxWindow * >(argp1);
32694 if (obj1) {
32695 ecode2 = SWIG_AsVal_int(obj1, &val2);
32696 if (!SWIG_IsOK(ecode2)) {
32697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32698 }
32699 arg2 = static_cast< int >(val2);
32700 }
32701 if (obj2) {
32702 {
32703 arg3 = &temp3;
32704 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32705 }
32706 }
32707 if (obj3) {
32708 {
32709 arg4 = &temp4;
32710 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32711 }
32712 }
32713 if (obj4) {
32714 ecode5 = SWIG_AsVal_long(obj4, &val5);
32715 if (!SWIG_IsOK(ecode5)) {
32716 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32717 }
32718 arg5 = static_cast< long >(val5);
32719 }
32720 if (obj5) {
32721 {
32722 arg6 = wxString_in_helper(obj5);
32723 if (arg6 == NULL) SWIG_fail;
32724 temp6 = true;
32725 }
32726 }
32727 {
32728 if (!wxPyCheckForApp()) SWIG_fail;
32729 PyThreadState* __tstate = wxPyBeginAllowThreads();
32730 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32731 wxPyEndAllowThreads(__tstate);
32732 if (PyErr_Occurred()) SWIG_fail;
32733 }
32734 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32735 {
32736 if (temp6)
32737 delete arg6;
32738 }
32739 return resultobj;
32740 fail:
32741 {
32742 if (temp6)
32743 delete arg6;
32744 }
32745 return NULL;
32746 }
32747
32748
32749 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32750 PyObject *resultobj = 0;
32751 wxWindow *result = 0 ;
32752
32753 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32754 {
32755 if (!wxPyCheckForApp()) SWIG_fail;
32756 PyThreadState* __tstate = wxPyBeginAllowThreads();
32757 result = (wxWindow *)new wxWindow();
32758 wxPyEndAllowThreads(__tstate);
32759 if (PyErr_Occurred()) SWIG_fail;
32760 }
32761 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32762 return resultobj;
32763 fail:
32764 return NULL;
32765 }
32766
32767
32768 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32769 PyObject *resultobj = 0;
32770 wxWindow *arg1 = (wxWindow *) 0 ;
32771 wxWindow *arg2 = (wxWindow *) 0 ;
32772 int arg3 = (int) (int)-1 ;
32773 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32774 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32775 wxSize const &arg5_defvalue = wxDefaultSize ;
32776 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32777 long arg6 = (long) 0 ;
32778 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32779 wxString *arg7 = (wxString *) &arg7_defvalue ;
32780 bool result;
32781 void *argp1 = 0 ;
32782 int res1 = 0 ;
32783 void *argp2 = 0 ;
32784 int res2 = 0 ;
32785 int val3 ;
32786 int ecode3 = 0 ;
32787 wxPoint temp4 ;
32788 wxSize temp5 ;
32789 long val6 ;
32790 int ecode6 = 0 ;
32791 bool temp7 = false ;
32792 PyObject * obj0 = 0 ;
32793 PyObject * obj1 = 0 ;
32794 PyObject * obj2 = 0 ;
32795 PyObject * obj3 = 0 ;
32796 PyObject * obj4 = 0 ;
32797 PyObject * obj5 = 0 ;
32798 PyObject * obj6 = 0 ;
32799 char * kwnames[] = {
32800 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32801 };
32802
32803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32810 if (!SWIG_IsOK(res2)) {
32811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32812 }
32813 arg2 = reinterpret_cast< wxWindow * >(argp2);
32814 if (obj2) {
32815 ecode3 = SWIG_AsVal_int(obj2, &val3);
32816 if (!SWIG_IsOK(ecode3)) {
32817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32818 }
32819 arg3 = static_cast< int >(val3);
32820 }
32821 if (obj3) {
32822 {
32823 arg4 = &temp4;
32824 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32825 }
32826 }
32827 if (obj4) {
32828 {
32829 arg5 = &temp5;
32830 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32831 }
32832 }
32833 if (obj5) {
32834 ecode6 = SWIG_AsVal_long(obj5, &val6);
32835 if (!SWIG_IsOK(ecode6)) {
32836 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32837 }
32838 arg6 = static_cast< long >(val6);
32839 }
32840 if (obj6) {
32841 {
32842 arg7 = wxString_in_helper(obj6);
32843 if (arg7 == NULL) SWIG_fail;
32844 temp7 = true;
32845 }
32846 }
32847 {
32848 PyThreadState* __tstate = wxPyBeginAllowThreads();
32849 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
32850 wxPyEndAllowThreads(__tstate);
32851 if (PyErr_Occurred()) SWIG_fail;
32852 }
32853 {
32854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32855 }
32856 {
32857 if (temp7)
32858 delete arg7;
32859 }
32860 return resultobj;
32861 fail:
32862 {
32863 if (temp7)
32864 delete arg7;
32865 }
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32871 PyObject *resultobj = 0;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 bool arg2 = (bool) false ;
32874 bool result;
32875 void *argp1 = 0 ;
32876 int res1 = 0 ;
32877 bool val2 ;
32878 int ecode2 = 0 ;
32879 PyObject * obj0 = 0 ;
32880 PyObject * obj1 = 0 ;
32881 char * kwnames[] = {
32882 (char *) "self",(char *) "force", NULL
32883 };
32884
32885 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
32886 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32887 if (!SWIG_IsOK(res1)) {
32888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
32889 }
32890 arg1 = reinterpret_cast< wxWindow * >(argp1);
32891 if (obj1) {
32892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32893 if (!SWIG_IsOK(ecode2)) {
32894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
32895 }
32896 arg2 = static_cast< bool >(val2);
32897 }
32898 {
32899 PyThreadState* __tstate = wxPyBeginAllowThreads();
32900 result = (bool)(arg1)->Close(arg2);
32901 wxPyEndAllowThreads(__tstate);
32902 if (PyErr_Occurred()) SWIG_fail;
32903 }
32904 {
32905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32906 }
32907 return resultobj;
32908 fail:
32909 return NULL;
32910 }
32911
32912
32913 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32914 PyObject *resultobj = 0;
32915 wxWindow *arg1 = (wxWindow *) 0 ;
32916 bool result;
32917 void *argp1 = 0 ;
32918 int res1 = 0 ;
32919 PyObject *swig_obj[1] ;
32920
32921 if (!args) SWIG_fail;
32922 swig_obj[0] = args;
32923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32924 if (!SWIG_IsOK(res1)) {
32925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
32926 }
32927 arg1 = reinterpret_cast< wxWindow * >(argp1);
32928 {
32929 PyThreadState* __tstate = wxPyBeginAllowThreads();
32930 result = (bool)(arg1)->Destroy();
32931 wxPyEndAllowThreads(__tstate);
32932 if (PyErr_Occurred()) SWIG_fail;
32933 }
32934 {
32935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32936 }
32937 return resultobj;
32938 fail:
32939 return NULL;
32940 }
32941
32942
32943 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32944 PyObject *resultobj = 0;
32945 wxWindow *arg1 = (wxWindow *) 0 ;
32946 bool result;
32947 void *argp1 = 0 ;
32948 int res1 = 0 ;
32949 PyObject *swig_obj[1] ;
32950
32951 if (!args) SWIG_fail;
32952 swig_obj[0] = args;
32953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32954 if (!SWIG_IsOK(res1)) {
32955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32956 }
32957 arg1 = reinterpret_cast< wxWindow * >(argp1);
32958 {
32959 PyThreadState* __tstate = wxPyBeginAllowThreads();
32960 result = (bool)(arg1)->DestroyChildren();
32961 wxPyEndAllowThreads(__tstate);
32962 if (PyErr_Occurred()) SWIG_fail;
32963 }
32964 {
32965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32966 }
32967 return resultobj;
32968 fail:
32969 return NULL;
32970 }
32971
32972
32973 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32974 PyObject *resultobj = 0;
32975 wxWindow *arg1 = (wxWindow *) 0 ;
32976 bool result;
32977 void *argp1 = 0 ;
32978 int res1 = 0 ;
32979 PyObject *swig_obj[1] ;
32980
32981 if (!args) SWIG_fail;
32982 swig_obj[0] = args;
32983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32984 if (!SWIG_IsOK(res1)) {
32985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
32986 }
32987 arg1 = reinterpret_cast< wxWindow * >(argp1);
32988 {
32989 PyThreadState* __tstate = wxPyBeginAllowThreads();
32990 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
32991 wxPyEndAllowThreads(__tstate);
32992 if (PyErr_Occurred()) SWIG_fail;
32993 }
32994 {
32995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32996 }
32997 return resultobj;
32998 fail:
32999 return NULL;
33000 }
33001
33002
33003 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33004 PyObject *resultobj = 0;
33005 wxWindow *arg1 = (wxWindow *) 0 ;
33006 wxString *arg2 = 0 ;
33007 void *argp1 = 0 ;
33008 int res1 = 0 ;
33009 bool temp2 = false ;
33010 PyObject * obj0 = 0 ;
33011 PyObject * obj1 = 0 ;
33012 char * kwnames[] = {
33013 (char *) "self",(char *) "label", NULL
33014 };
33015
33016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33018 if (!SWIG_IsOK(res1)) {
33019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33020 }
33021 arg1 = reinterpret_cast< wxWindow * >(argp1);
33022 {
33023 arg2 = wxString_in_helper(obj1);
33024 if (arg2 == NULL) SWIG_fail;
33025 temp2 = true;
33026 }
33027 {
33028 PyThreadState* __tstate = wxPyBeginAllowThreads();
33029 (arg1)->SetLabel((wxString const &)*arg2);
33030 wxPyEndAllowThreads(__tstate);
33031 if (PyErr_Occurred()) SWIG_fail;
33032 }
33033 resultobj = SWIG_Py_Void();
33034 {
33035 if (temp2)
33036 delete arg2;
33037 }
33038 return resultobj;
33039 fail:
33040 {
33041 if (temp2)
33042 delete arg2;
33043 }
33044 return NULL;
33045 }
33046
33047
33048 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33049 PyObject *resultobj = 0;
33050 wxWindow *arg1 = (wxWindow *) 0 ;
33051 wxString result;
33052 void *argp1 = 0 ;
33053 int res1 = 0 ;
33054 PyObject *swig_obj[1] ;
33055
33056 if (!args) SWIG_fail;
33057 swig_obj[0] = args;
33058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33059 if (!SWIG_IsOK(res1)) {
33060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33061 }
33062 arg1 = reinterpret_cast< wxWindow * >(argp1);
33063 {
33064 PyThreadState* __tstate = wxPyBeginAllowThreads();
33065 result = ((wxWindow const *)arg1)->GetLabel();
33066 wxPyEndAllowThreads(__tstate);
33067 if (PyErr_Occurred()) SWIG_fail;
33068 }
33069 {
33070 #if wxUSE_UNICODE
33071 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33072 #else
33073 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33074 #endif
33075 }
33076 return resultobj;
33077 fail:
33078 return NULL;
33079 }
33080
33081
33082 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33083 PyObject *resultobj = 0;
33084 wxWindow *arg1 = (wxWindow *) 0 ;
33085 wxString *arg2 = 0 ;
33086 void *argp1 = 0 ;
33087 int res1 = 0 ;
33088 bool temp2 = false ;
33089 PyObject * obj0 = 0 ;
33090 PyObject * obj1 = 0 ;
33091 char * kwnames[] = {
33092 (char *) "self",(char *) "name", NULL
33093 };
33094
33095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33097 if (!SWIG_IsOK(res1)) {
33098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33099 }
33100 arg1 = reinterpret_cast< wxWindow * >(argp1);
33101 {
33102 arg2 = wxString_in_helper(obj1);
33103 if (arg2 == NULL) SWIG_fail;
33104 temp2 = true;
33105 }
33106 {
33107 PyThreadState* __tstate = wxPyBeginAllowThreads();
33108 (arg1)->SetName((wxString const &)*arg2);
33109 wxPyEndAllowThreads(__tstate);
33110 if (PyErr_Occurred()) SWIG_fail;
33111 }
33112 resultobj = SWIG_Py_Void();
33113 {
33114 if (temp2)
33115 delete arg2;
33116 }
33117 return resultobj;
33118 fail:
33119 {
33120 if (temp2)
33121 delete arg2;
33122 }
33123 return NULL;
33124 }
33125
33126
33127 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33128 PyObject *resultobj = 0;
33129 wxWindow *arg1 = (wxWindow *) 0 ;
33130 wxString result;
33131 void *argp1 = 0 ;
33132 int res1 = 0 ;
33133 PyObject *swig_obj[1] ;
33134
33135 if (!args) SWIG_fail;
33136 swig_obj[0] = args;
33137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33138 if (!SWIG_IsOK(res1)) {
33139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33140 }
33141 arg1 = reinterpret_cast< wxWindow * >(argp1);
33142 {
33143 PyThreadState* __tstate = wxPyBeginAllowThreads();
33144 result = ((wxWindow const *)arg1)->GetName();
33145 wxPyEndAllowThreads(__tstate);
33146 if (PyErr_Occurred()) SWIG_fail;
33147 }
33148 {
33149 #if wxUSE_UNICODE
33150 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33151 #else
33152 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33153 #endif
33154 }
33155 return resultobj;
33156 fail:
33157 return NULL;
33158 }
33159
33160
33161 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33162 PyObject *resultobj = 0;
33163 wxWindow *arg1 = (wxWindow *) 0 ;
33164 wxWindowVariant arg2 ;
33165 void *argp1 = 0 ;
33166 int res1 = 0 ;
33167 int val2 ;
33168 int ecode2 = 0 ;
33169 PyObject * obj0 = 0 ;
33170 PyObject * obj1 = 0 ;
33171 char * kwnames[] = {
33172 (char *) "self",(char *) "variant", NULL
33173 };
33174
33175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33177 if (!SWIG_IsOK(res1)) {
33178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33179 }
33180 arg1 = reinterpret_cast< wxWindow * >(argp1);
33181 ecode2 = SWIG_AsVal_int(obj1, &val2);
33182 if (!SWIG_IsOK(ecode2)) {
33183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33184 }
33185 arg2 = static_cast< wxWindowVariant >(val2);
33186 {
33187 PyThreadState* __tstate = wxPyBeginAllowThreads();
33188 (arg1)->SetWindowVariant(arg2);
33189 wxPyEndAllowThreads(__tstate);
33190 if (PyErr_Occurred()) SWIG_fail;
33191 }
33192 resultobj = SWIG_Py_Void();
33193 return resultobj;
33194 fail:
33195 return NULL;
33196 }
33197
33198
33199 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33200 PyObject *resultobj = 0;
33201 wxWindow *arg1 = (wxWindow *) 0 ;
33202 wxWindowVariant result;
33203 void *argp1 = 0 ;
33204 int res1 = 0 ;
33205 PyObject *swig_obj[1] ;
33206
33207 if (!args) SWIG_fail;
33208 swig_obj[0] = args;
33209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33210 if (!SWIG_IsOK(res1)) {
33211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33212 }
33213 arg1 = reinterpret_cast< wxWindow * >(argp1);
33214 {
33215 PyThreadState* __tstate = wxPyBeginAllowThreads();
33216 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33217 wxPyEndAllowThreads(__tstate);
33218 if (PyErr_Occurred()) SWIG_fail;
33219 }
33220 resultobj = SWIG_From_int(static_cast< int >(result));
33221 return resultobj;
33222 fail:
33223 return NULL;
33224 }
33225
33226
33227 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33228 PyObject *resultobj = 0;
33229 wxWindow *arg1 = (wxWindow *) 0 ;
33230 int arg2 ;
33231 void *argp1 = 0 ;
33232 int res1 = 0 ;
33233 int val2 ;
33234 int ecode2 = 0 ;
33235 PyObject * obj0 = 0 ;
33236 PyObject * obj1 = 0 ;
33237 char * kwnames[] = {
33238 (char *) "self",(char *) "winid", NULL
33239 };
33240
33241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33243 if (!SWIG_IsOK(res1)) {
33244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33245 }
33246 arg1 = reinterpret_cast< wxWindow * >(argp1);
33247 ecode2 = SWIG_AsVal_int(obj1, &val2);
33248 if (!SWIG_IsOK(ecode2)) {
33249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33250 }
33251 arg2 = static_cast< int >(val2);
33252 {
33253 PyThreadState* __tstate = wxPyBeginAllowThreads();
33254 (arg1)->SetId(arg2);
33255 wxPyEndAllowThreads(__tstate);
33256 if (PyErr_Occurred()) SWIG_fail;
33257 }
33258 resultobj = SWIG_Py_Void();
33259 return resultobj;
33260 fail:
33261 return NULL;
33262 }
33263
33264
33265 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33266 PyObject *resultobj = 0;
33267 wxWindow *arg1 = (wxWindow *) 0 ;
33268 int result;
33269 void *argp1 = 0 ;
33270 int res1 = 0 ;
33271 PyObject *swig_obj[1] ;
33272
33273 if (!args) SWIG_fail;
33274 swig_obj[0] = args;
33275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33276 if (!SWIG_IsOK(res1)) {
33277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33278 }
33279 arg1 = reinterpret_cast< wxWindow * >(argp1);
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 result = (int)((wxWindow const *)arg1)->GetId();
33283 wxPyEndAllowThreads(__tstate);
33284 if (PyErr_Occurred()) SWIG_fail;
33285 }
33286 resultobj = SWIG_From_int(static_cast< int >(result));
33287 return resultobj;
33288 fail:
33289 return NULL;
33290 }
33291
33292
33293 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33294 PyObject *resultobj = 0;
33295 int result;
33296
33297 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33298 {
33299 PyThreadState* __tstate = wxPyBeginAllowThreads();
33300 result = (int)wxWindow::NewControlId();
33301 wxPyEndAllowThreads(__tstate);
33302 if (PyErr_Occurred()) SWIG_fail;
33303 }
33304 resultobj = SWIG_From_int(static_cast< int >(result));
33305 return resultobj;
33306 fail:
33307 return NULL;
33308 }
33309
33310
33311 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33312 PyObject *resultobj = 0;
33313 int arg1 ;
33314 int result;
33315 int val1 ;
33316 int ecode1 = 0 ;
33317 PyObject * obj0 = 0 ;
33318 char * kwnames[] = {
33319 (char *) "winid", NULL
33320 };
33321
33322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33323 ecode1 = SWIG_AsVal_int(obj0, &val1);
33324 if (!SWIG_IsOK(ecode1)) {
33325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33326 }
33327 arg1 = static_cast< int >(val1);
33328 {
33329 PyThreadState* __tstate = wxPyBeginAllowThreads();
33330 result = (int)wxWindow::NextControlId(arg1);
33331 wxPyEndAllowThreads(__tstate);
33332 if (PyErr_Occurred()) SWIG_fail;
33333 }
33334 resultobj = SWIG_From_int(static_cast< int >(result));
33335 return resultobj;
33336 fail:
33337 return NULL;
33338 }
33339
33340
33341 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33342 PyObject *resultobj = 0;
33343 int arg1 ;
33344 int result;
33345 int val1 ;
33346 int ecode1 = 0 ;
33347 PyObject * obj0 = 0 ;
33348 char * kwnames[] = {
33349 (char *) "winid", NULL
33350 };
33351
33352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33353 ecode1 = SWIG_AsVal_int(obj0, &val1);
33354 if (!SWIG_IsOK(ecode1)) {
33355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33356 }
33357 arg1 = static_cast< int >(val1);
33358 {
33359 PyThreadState* __tstate = wxPyBeginAllowThreads();
33360 result = (int)wxWindow::PrevControlId(arg1);
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 resultobj = SWIG_From_int(static_cast< int >(result));
33365 return resultobj;
33366 fail:
33367 return NULL;
33368 }
33369
33370
33371 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33372 PyObject *resultobj = 0;
33373 wxWindow *arg1 = (wxWindow *) 0 ;
33374 wxLayoutDirection result;
33375 void *argp1 = 0 ;
33376 int res1 = 0 ;
33377 PyObject *swig_obj[1] ;
33378
33379 if (!args) SWIG_fail;
33380 swig_obj[0] = args;
33381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33382 if (!SWIG_IsOK(res1)) {
33383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33384 }
33385 arg1 = reinterpret_cast< wxWindow * >(argp1);
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 resultobj = SWIG_From_int(static_cast< int >(result));
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33400 PyObject *resultobj = 0;
33401 wxWindow *arg1 = (wxWindow *) 0 ;
33402 wxLayoutDirection arg2 ;
33403 void *argp1 = 0 ;
33404 int res1 = 0 ;
33405 int val2 ;
33406 int ecode2 = 0 ;
33407 PyObject * obj0 = 0 ;
33408 PyObject * obj1 = 0 ;
33409 char * kwnames[] = {
33410 (char *) "self",(char *) "dir", NULL
33411 };
33412
33413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33415 if (!SWIG_IsOK(res1)) {
33416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33417 }
33418 arg1 = reinterpret_cast< wxWindow * >(argp1);
33419 ecode2 = SWIG_AsVal_int(obj1, &val2);
33420 if (!SWIG_IsOK(ecode2)) {
33421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33422 }
33423 arg2 = static_cast< wxLayoutDirection >(val2);
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 (arg1)->SetLayoutDirection(arg2);
33427 wxPyEndAllowThreads(__tstate);
33428 if (PyErr_Occurred()) SWIG_fail;
33429 }
33430 resultobj = SWIG_Py_Void();
33431 return resultobj;
33432 fail:
33433 return NULL;
33434 }
33435
33436
33437 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33438 PyObject *resultobj = 0;
33439 wxWindow *arg1 = (wxWindow *) 0 ;
33440 int arg2 ;
33441 int arg3 ;
33442 int arg4 ;
33443 int result;
33444 void *argp1 = 0 ;
33445 int res1 = 0 ;
33446 int val2 ;
33447 int ecode2 = 0 ;
33448 int val3 ;
33449 int ecode3 = 0 ;
33450 int val4 ;
33451 int ecode4 = 0 ;
33452 PyObject * obj0 = 0 ;
33453 PyObject * obj1 = 0 ;
33454 PyObject * obj2 = 0 ;
33455 PyObject * obj3 = 0 ;
33456 char * kwnames[] = {
33457 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33458 };
33459
33460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33462 if (!SWIG_IsOK(res1)) {
33463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33464 }
33465 arg1 = reinterpret_cast< wxWindow * >(argp1);
33466 ecode2 = SWIG_AsVal_int(obj1, &val2);
33467 if (!SWIG_IsOK(ecode2)) {
33468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33469 }
33470 arg2 = static_cast< int >(val2);
33471 ecode3 = SWIG_AsVal_int(obj2, &val3);
33472 if (!SWIG_IsOK(ecode3)) {
33473 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33474 }
33475 arg3 = static_cast< int >(val3);
33476 ecode4 = SWIG_AsVal_int(obj3, &val4);
33477 if (!SWIG_IsOK(ecode4)) {
33478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33479 }
33480 arg4 = static_cast< int >(val4);
33481 {
33482 PyThreadState* __tstate = wxPyBeginAllowThreads();
33483 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33484 wxPyEndAllowThreads(__tstate);
33485 if (PyErr_Occurred()) SWIG_fail;
33486 }
33487 resultobj = SWIG_From_int(static_cast< int >(result));
33488 return resultobj;
33489 fail:
33490 return NULL;
33491 }
33492
33493
33494 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33495 PyObject *resultobj = 0;
33496 wxWindow *arg1 = (wxWindow *) 0 ;
33497 wxSize *arg2 = 0 ;
33498 void *argp1 = 0 ;
33499 int res1 = 0 ;
33500 wxSize temp2 ;
33501 PyObject * obj0 = 0 ;
33502 PyObject * obj1 = 0 ;
33503 char * kwnames[] = {
33504 (char *) "self",(char *) "size", NULL
33505 };
33506
33507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33509 if (!SWIG_IsOK(res1)) {
33510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33511 }
33512 arg1 = reinterpret_cast< wxWindow * >(argp1);
33513 {
33514 arg2 = &temp2;
33515 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33516 }
33517 {
33518 PyThreadState* __tstate = wxPyBeginAllowThreads();
33519 (arg1)->SetSize((wxSize const &)*arg2);
33520 wxPyEndAllowThreads(__tstate);
33521 if (PyErr_Occurred()) SWIG_fail;
33522 }
33523 resultobj = SWIG_Py_Void();
33524 return resultobj;
33525 fail:
33526 return NULL;
33527 }
33528
33529
33530 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33531 PyObject *resultobj = 0;
33532 wxWindow *arg1 = (wxWindow *) 0 ;
33533 int arg2 ;
33534 int arg3 ;
33535 int arg4 ;
33536 int arg5 ;
33537 int arg6 = (int) wxSIZE_AUTO ;
33538 void *argp1 = 0 ;
33539 int res1 = 0 ;
33540 int val2 ;
33541 int ecode2 = 0 ;
33542 int val3 ;
33543 int ecode3 = 0 ;
33544 int val4 ;
33545 int ecode4 = 0 ;
33546 int val5 ;
33547 int ecode5 = 0 ;
33548 int val6 ;
33549 int ecode6 = 0 ;
33550 PyObject * obj0 = 0 ;
33551 PyObject * obj1 = 0 ;
33552 PyObject * obj2 = 0 ;
33553 PyObject * obj3 = 0 ;
33554 PyObject * obj4 = 0 ;
33555 PyObject * obj5 = 0 ;
33556 char * kwnames[] = {
33557 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33558 };
33559
33560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
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_SetDimensions" "', 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_SetDimensions" "', 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_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33579 }
33580 arg4 = static_cast< int >(val4);
33581 ecode5 = SWIG_AsVal_int(obj4, &val5);
33582 if (!SWIG_IsOK(ecode5)) {
33583 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33584 }
33585 arg5 = static_cast< int >(val5);
33586 if (obj5) {
33587 ecode6 = SWIG_AsVal_int(obj5, &val6);
33588 if (!SWIG_IsOK(ecode6)) {
33589 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33590 }
33591 arg6 = static_cast< int >(val6);
33592 }
33593 {
33594 PyThreadState* __tstate = wxPyBeginAllowThreads();
33595 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33596 wxPyEndAllowThreads(__tstate);
33597 if (PyErr_Occurred()) SWIG_fail;
33598 }
33599 resultobj = SWIG_Py_Void();
33600 return resultobj;
33601 fail:
33602 return NULL;
33603 }
33604
33605
33606 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33607 PyObject *resultobj = 0;
33608 wxWindow *arg1 = (wxWindow *) 0 ;
33609 wxRect *arg2 = 0 ;
33610 int arg3 = (int) wxSIZE_AUTO ;
33611 void *argp1 = 0 ;
33612 int res1 = 0 ;
33613 wxRect temp2 ;
33614 int val3 ;
33615 int ecode3 = 0 ;
33616 PyObject * obj0 = 0 ;
33617 PyObject * obj1 = 0 ;
33618 PyObject * obj2 = 0 ;
33619 char * kwnames[] = {
33620 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33621 };
33622
33623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33625 if (!SWIG_IsOK(res1)) {
33626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33627 }
33628 arg1 = reinterpret_cast< wxWindow * >(argp1);
33629 {
33630 arg2 = &temp2;
33631 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33632 }
33633 if (obj2) {
33634 ecode3 = SWIG_AsVal_int(obj2, &val3);
33635 if (!SWIG_IsOK(ecode3)) {
33636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33637 }
33638 arg3 = static_cast< int >(val3);
33639 }
33640 {
33641 PyThreadState* __tstate = wxPyBeginAllowThreads();
33642 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33643 wxPyEndAllowThreads(__tstate);
33644 if (PyErr_Occurred()) SWIG_fail;
33645 }
33646 resultobj = SWIG_Py_Void();
33647 return resultobj;
33648 fail:
33649 return NULL;
33650 }
33651
33652
33653 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33654 PyObject *resultobj = 0;
33655 wxWindow *arg1 = (wxWindow *) 0 ;
33656 int arg2 ;
33657 int arg3 ;
33658 void *argp1 = 0 ;
33659 int res1 = 0 ;
33660 int val2 ;
33661 int ecode2 = 0 ;
33662 int val3 ;
33663 int ecode3 = 0 ;
33664 PyObject * obj0 = 0 ;
33665 PyObject * obj1 = 0 ;
33666 PyObject * obj2 = 0 ;
33667 char * kwnames[] = {
33668 (char *) "self",(char *) "width",(char *) "height", NULL
33669 };
33670
33671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33673 if (!SWIG_IsOK(res1)) {
33674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33675 }
33676 arg1 = reinterpret_cast< wxWindow * >(argp1);
33677 ecode2 = SWIG_AsVal_int(obj1, &val2);
33678 if (!SWIG_IsOK(ecode2)) {
33679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33680 }
33681 arg2 = static_cast< int >(val2);
33682 ecode3 = SWIG_AsVal_int(obj2, &val3);
33683 if (!SWIG_IsOK(ecode3)) {
33684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33685 }
33686 arg3 = static_cast< int >(val3);
33687 {
33688 PyThreadState* __tstate = wxPyBeginAllowThreads();
33689 (arg1)->SetSize(arg2,arg3);
33690 wxPyEndAllowThreads(__tstate);
33691 if (PyErr_Occurred()) SWIG_fail;
33692 }
33693 resultobj = SWIG_Py_Void();
33694 return resultobj;
33695 fail:
33696 return NULL;
33697 }
33698
33699
33700 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33701 PyObject *resultobj = 0;
33702 wxWindow *arg1 = (wxWindow *) 0 ;
33703 wxPoint *arg2 = 0 ;
33704 int arg3 = (int) wxSIZE_USE_EXISTING ;
33705 void *argp1 = 0 ;
33706 int res1 = 0 ;
33707 wxPoint temp2 ;
33708 int val3 ;
33709 int ecode3 = 0 ;
33710 PyObject * obj0 = 0 ;
33711 PyObject * obj1 = 0 ;
33712 PyObject * obj2 = 0 ;
33713 char * kwnames[] = {
33714 (char *) "self",(char *) "pt",(char *) "flags", NULL
33715 };
33716
33717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33719 if (!SWIG_IsOK(res1)) {
33720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33721 }
33722 arg1 = reinterpret_cast< wxWindow * >(argp1);
33723 {
33724 arg2 = &temp2;
33725 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33726 }
33727 if (obj2) {
33728 ecode3 = SWIG_AsVal_int(obj2, &val3);
33729 if (!SWIG_IsOK(ecode3)) {
33730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33731 }
33732 arg3 = static_cast< int >(val3);
33733 }
33734 {
33735 PyThreadState* __tstate = wxPyBeginAllowThreads();
33736 (arg1)->Move((wxPoint const &)*arg2,arg3);
33737 wxPyEndAllowThreads(__tstate);
33738 if (PyErr_Occurred()) SWIG_fail;
33739 }
33740 resultobj = SWIG_Py_Void();
33741 return resultobj;
33742 fail:
33743 return NULL;
33744 }
33745
33746
33747 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33748 PyObject *resultobj = 0;
33749 wxWindow *arg1 = (wxWindow *) 0 ;
33750 int arg2 ;
33751 int arg3 ;
33752 int arg4 = (int) wxSIZE_USE_EXISTING ;
33753 void *argp1 = 0 ;
33754 int res1 = 0 ;
33755 int val2 ;
33756 int ecode2 = 0 ;
33757 int val3 ;
33758 int ecode3 = 0 ;
33759 int val4 ;
33760 int ecode4 = 0 ;
33761 PyObject * obj0 = 0 ;
33762 PyObject * obj1 = 0 ;
33763 PyObject * obj2 = 0 ;
33764 PyObject * obj3 = 0 ;
33765 char * kwnames[] = {
33766 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33767 };
33768
33769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33771 if (!SWIG_IsOK(res1)) {
33772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33773 }
33774 arg1 = reinterpret_cast< wxWindow * >(argp1);
33775 ecode2 = SWIG_AsVal_int(obj1, &val2);
33776 if (!SWIG_IsOK(ecode2)) {
33777 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33778 }
33779 arg2 = static_cast< int >(val2);
33780 ecode3 = SWIG_AsVal_int(obj2, &val3);
33781 if (!SWIG_IsOK(ecode3)) {
33782 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33783 }
33784 arg3 = static_cast< int >(val3);
33785 if (obj3) {
33786 ecode4 = SWIG_AsVal_int(obj3, &val4);
33787 if (!SWIG_IsOK(ecode4)) {
33788 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33789 }
33790 arg4 = static_cast< int >(val4);
33791 }
33792 {
33793 PyThreadState* __tstate = wxPyBeginAllowThreads();
33794 (arg1)->Move(arg2,arg3,arg4);
33795 wxPyEndAllowThreads(__tstate);
33796 if (PyErr_Occurred()) SWIG_fail;
33797 }
33798 resultobj = SWIG_Py_Void();
33799 return resultobj;
33800 fail:
33801 return NULL;
33802 }
33803
33804
33805 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33806 PyObject *resultobj = 0;
33807 wxWindow *arg1 = (wxWindow *) 0 ;
33808 wxSize const &arg2_defvalue = wxDefaultSize ;
33809 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33810 void *argp1 = 0 ;
33811 int res1 = 0 ;
33812 wxSize temp2 ;
33813 PyObject * obj0 = 0 ;
33814 PyObject * obj1 = 0 ;
33815 char * kwnames[] = {
33816 (char *) "self",(char *) "size", NULL
33817 };
33818
33819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33821 if (!SWIG_IsOK(res1)) {
33822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33823 }
33824 arg1 = reinterpret_cast< wxWindow * >(argp1);
33825 if (obj1) {
33826 {
33827 arg2 = &temp2;
33828 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33829 }
33830 }
33831 {
33832 PyThreadState* __tstate = wxPyBeginAllowThreads();
33833 (arg1)->SetInitialSize((wxSize const &)*arg2);
33834 wxPyEndAllowThreads(__tstate);
33835 if (PyErr_Occurred()) SWIG_fail;
33836 }
33837 resultobj = SWIG_Py_Void();
33838 return resultobj;
33839 fail:
33840 return NULL;
33841 }
33842
33843
33844 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33845 PyObject *resultobj = 0;
33846 wxWindow *arg1 = (wxWindow *) 0 ;
33847 void *argp1 = 0 ;
33848 int res1 = 0 ;
33849 PyObject *swig_obj[1] ;
33850
33851 if (!args) SWIG_fail;
33852 swig_obj[0] = args;
33853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33854 if (!SWIG_IsOK(res1)) {
33855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
33856 }
33857 arg1 = reinterpret_cast< wxWindow * >(argp1);
33858 {
33859 PyThreadState* __tstate = wxPyBeginAllowThreads();
33860 (arg1)->Raise();
33861 wxPyEndAllowThreads(__tstate);
33862 if (PyErr_Occurred()) SWIG_fail;
33863 }
33864 resultobj = SWIG_Py_Void();
33865 return resultobj;
33866 fail:
33867 return NULL;
33868 }
33869
33870
33871 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33872 PyObject *resultobj = 0;
33873 wxWindow *arg1 = (wxWindow *) 0 ;
33874 void *argp1 = 0 ;
33875 int res1 = 0 ;
33876 PyObject *swig_obj[1] ;
33877
33878 if (!args) SWIG_fail;
33879 swig_obj[0] = args;
33880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33881 if (!SWIG_IsOK(res1)) {
33882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
33883 }
33884 arg1 = reinterpret_cast< wxWindow * >(argp1);
33885 {
33886 PyThreadState* __tstate = wxPyBeginAllowThreads();
33887 (arg1)->Lower();
33888 wxPyEndAllowThreads(__tstate);
33889 if (PyErr_Occurred()) SWIG_fail;
33890 }
33891 resultobj = SWIG_Py_Void();
33892 return resultobj;
33893 fail:
33894 return NULL;
33895 }
33896
33897
33898 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33899 PyObject *resultobj = 0;
33900 wxWindow *arg1 = (wxWindow *) 0 ;
33901 wxSize *arg2 = 0 ;
33902 void *argp1 = 0 ;
33903 int res1 = 0 ;
33904 wxSize temp2 ;
33905 PyObject * obj0 = 0 ;
33906 PyObject * obj1 = 0 ;
33907 char * kwnames[] = {
33908 (char *) "self",(char *) "size", NULL
33909 };
33910
33911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
33912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33913 if (!SWIG_IsOK(res1)) {
33914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33915 }
33916 arg1 = reinterpret_cast< wxWindow * >(argp1);
33917 {
33918 arg2 = &temp2;
33919 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33920 }
33921 {
33922 PyThreadState* __tstate = wxPyBeginAllowThreads();
33923 (arg1)->SetClientSize((wxSize const &)*arg2);
33924 wxPyEndAllowThreads(__tstate);
33925 if (PyErr_Occurred()) SWIG_fail;
33926 }
33927 resultobj = SWIG_Py_Void();
33928 return resultobj;
33929 fail:
33930 return NULL;
33931 }
33932
33933
33934 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33935 PyObject *resultobj = 0;
33936 wxWindow *arg1 = (wxWindow *) 0 ;
33937 int arg2 ;
33938 int arg3 ;
33939 void *argp1 = 0 ;
33940 int res1 = 0 ;
33941 int val2 ;
33942 int ecode2 = 0 ;
33943 int val3 ;
33944 int ecode3 = 0 ;
33945 PyObject * obj0 = 0 ;
33946 PyObject * obj1 = 0 ;
33947 PyObject * obj2 = 0 ;
33948 char * kwnames[] = {
33949 (char *) "self",(char *) "width",(char *) "height", NULL
33950 };
33951
33952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33954 if (!SWIG_IsOK(res1)) {
33955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33956 }
33957 arg1 = reinterpret_cast< wxWindow * >(argp1);
33958 ecode2 = SWIG_AsVal_int(obj1, &val2);
33959 if (!SWIG_IsOK(ecode2)) {
33960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
33961 }
33962 arg2 = static_cast< int >(val2);
33963 ecode3 = SWIG_AsVal_int(obj2, &val3);
33964 if (!SWIG_IsOK(ecode3)) {
33965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
33966 }
33967 arg3 = static_cast< int >(val3);
33968 {
33969 PyThreadState* __tstate = wxPyBeginAllowThreads();
33970 (arg1)->SetClientSize(arg2,arg3);
33971 wxPyEndAllowThreads(__tstate);
33972 if (PyErr_Occurred()) SWIG_fail;
33973 }
33974 resultobj = SWIG_Py_Void();
33975 return resultobj;
33976 fail:
33977 return NULL;
33978 }
33979
33980
33981 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33982 PyObject *resultobj = 0;
33983 wxWindow *arg1 = (wxWindow *) 0 ;
33984 wxRect *arg2 = 0 ;
33985 void *argp1 = 0 ;
33986 int res1 = 0 ;
33987 wxRect temp2 ;
33988 PyObject * obj0 = 0 ;
33989 PyObject * obj1 = 0 ;
33990 char * kwnames[] = {
33991 (char *) "self",(char *) "rect", NULL
33992 };
33993
33994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
33995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33996 if (!SWIG_IsOK(res1)) {
33997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33998 }
33999 arg1 = reinterpret_cast< wxWindow * >(argp1);
34000 {
34001 arg2 = &temp2;
34002 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34003 }
34004 {
34005 PyThreadState* __tstate = wxPyBeginAllowThreads();
34006 (arg1)->SetClientSize((wxRect const &)*arg2);
34007 wxPyEndAllowThreads(__tstate);
34008 if (PyErr_Occurred()) SWIG_fail;
34009 }
34010 resultobj = SWIG_Py_Void();
34011 return resultobj;
34012 fail:
34013 return NULL;
34014 }
34015
34016
34017 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34018 PyObject *resultobj = 0;
34019 wxWindow *arg1 = (wxWindow *) 0 ;
34020 wxPoint result;
34021 void *argp1 = 0 ;
34022 int res1 = 0 ;
34023 PyObject *swig_obj[1] ;
34024
34025 if (!args) SWIG_fail;
34026 swig_obj[0] = args;
34027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34028 if (!SWIG_IsOK(res1)) {
34029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34030 }
34031 arg1 = reinterpret_cast< wxWindow * >(argp1);
34032 {
34033 PyThreadState* __tstate = wxPyBeginAllowThreads();
34034 result = ((wxWindow const *)arg1)->GetPosition();
34035 wxPyEndAllowThreads(__tstate);
34036 if (PyErr_Occurred()) SWIG_fail;
34037 }
34038 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34039 return resultobj;
34040 fail:
34041 return NULL;
34042 }
34043
34044
34045 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34046 PyObject *resultobj = 0;
34047 wxWindow *arg1 = (wxWindow *) 0 ;
34048 int *arg2 = (int *) 0 ;
34049 int *arg3 = (int *) 0 ;
34050 void *argp1 = 0 ;
34051 int res1 = 0 ;
34052 int temp2 ;
34053 int res2 = SWIG_TMPOBJ ;
34054 int temp3 ;
34055 int res3 = SWIG_TMPOBJ ;
34056 PyObject *swig_obj[1] ;
34057
34058 arg2 = &temp2;
34059 arg3 = &temp3;
34060 if (!args) SWIG_fail;
34061 swig_obj[0] = args;
34062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34063 if (!SWIG_IsOK(res1)) {
34064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34065 }
34066 arg1 = reinterpret_cast< wxWindow * >(argp1);
34067 {
34068 PyThreadState* __tstate = wxPyBeginAllowThreads();
34069 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34070 wxPyEndAllowThreads(__tstate);
34071 if (PyErr_Occurred()) SWIG_fail;
34072 }
34073 resultobj = SWIG_Py_Void();
34074 if (SWIG_IsTmpObj(res2)) {
34075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34076 } else {
34077 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34079 }
34080 if (SWIG_IsTmpObj(res3)) {
34081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34082 } else {
34083 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34085 }
34086 return resultobj;
34087 fail:
34088 return NULL;
34089 }
34090
34091
34092 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34093 PyObject *resultobj = 0;
34094 wxWindow *arg1 = (wxWindow *) 0 ;
34095 wxPoint result;
34096 void *argp1 = 0 ;
34097 int res1 = 0 ;
34098 PyObject *swig_obj[1] ;
34099
34100 if (!args) SWIG_fail;
34101 swig_obj[0] = args;
34102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34103 if (!SWIG_IsOK(res1)) {
34104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34105 }
34106 arg1 = reinterpret_cast< wxWindow * >(argp1);
34107 {
34108 PyThreadState* __tstate = wxPyBeginAllowThreads();
34109 result = ((wxWindow const *)arg1)->GetScreenPosition();
34110 wxPyEndAllowThreads(__tstate);
34111 if (PyErr_Occurred()) SWIG_fail;
34112 }
34113 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34114 return resultobj;
34115 fail:
34116 return NULL;
34117 }
34118
34119
34120 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34121 PyObject *resultobj = 0;
34122 wxWindow *arg1 = (wxWindow *) 0 ;
34123 int *arg2 = (int *) 0 ;
34124 int *arg3 = (int *) 0 ;
34125 void *argp1 = 0 ;
34126 int res1 = 0 ;
34127 int temp2 ;
34128 int res2 = SWIG_TMPOBJ ;
34129 int temp3 ;
34130 int res3 = SWIG_TMPOBJ ;
34131 PyObject *swig_obj[1] ;
34132
34133 arg2 = &temp2;
34134 arg3 = &temp3;
34135 if (!args) SWIG_fail;
34136 swig_obj[0] = args;
34137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34138 if (!SWIG_IsOK(res1)) {
34139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34140 }
34141 arg1 = reinterpret_cast< wxWindow * >(argp1);
34142 {
34143 PyThreadState* __tstate = wxPyBeginAllowThreads();
34144 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34145 wxPyEndAllowThreads(__tstate);
34146 if (PyErr_Occurred()) SWIG_fail;
34147 }
34148 resultobj = SWIG_Py_Void();
34149 if (SWIG_IsTmpObj(res2)) {
34150 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34151 } else {
34152 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34153 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34154 }
34155 if (SWIG_IsTmpObj(res3)) {
34156 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34157 } else {
34158 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34159 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34160 }
34161 return resultobj;
34162 fail:
34163 return NULL;
34164 }
34165
34166
34167 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34168 PyObject *resultobj = 0;
34169 wxWindow *arg1 = (wxWindow *) 0 ;
34170 wxRect result;
34171 void *argp1 = 0 ;
34172 int res1 = 0 ;
34173 PyObject *swig_obj[1] ;
34174
34175 if (!args) SWIG_fail;
34176 swig_obj[0] = args;
34177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34178 if (!SWIG_IsOK(res1)) {
34179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34180 }
34181 arg1 = reinterpret_cast< wxWindow * >(argp1);
34182 {
34183 PyThreadState* __tstate = wxPyBeginAllowThreads();
34184 result = ((wxWindow const *)arg1)->GetScreenRect();
34185 wxPyEndAllowThreads(__tstate);
34186 if (PyErr_Occurred()) SWIG_fail;
34187 }
34188 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34189 return resultobj;
34190 fail:
34191 return NULL;
34192 }
34193
34194
34195 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34196 PyObject *resultobj = 0;
34197 wxWindow *arg1 = (wxWindow *) 0 ;
34198 wxSize result;
34199 void *argp1 = 0 ;
34200 int res1 = 0 ;
34201 PyObject *swig_obj[1] ;
34202
34203 if (!args) SWIG_fail;
34204 swig_obj[0] = args;
34205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34206 if (!SWIG_IsOK(res1)) {
34207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34208 }
34209 arg1 = reinterpret_cast< wxWindow * >(argp1);
34210 {
34211 PyThreadState* __tstate = wxPyBeginAllowThreads();
34212 result = ((wxWindow const *)arg1)->GetSize();
34213 wxPyEndAllowThreads(__tstate);
34214 if (PyErr_Occurred()) SWIG_fail;
34215 }
34216 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34217 return resultobj;
34218 fail:
34219 return NULL;
34220 }
34221
34222
34223 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34224 PyObject *resultobj = 0;
34225 wxWindow *arg1 = (wxWindow *) 0 ;
34226 int *arg2 = (int *) 0 ;
34227 int *arg3 = (int *) 0 ;
34228 void *argp1 = 0 ;
34229 int res1 = 0 ;
34230 int temp2 ;
34231 int res2 = SWIG_TMPOBJ ;
34232 int temp3 ;
34233 int res3 = SWIG_TMPOBJ ;
34234 PyObject *swig_obj[1] ;
34235
34236 arg2 = &temp2;
34237 arg3 = &temp3;
34238 if (!args) SWIG_fail;
34239 swig_obj[0] = args;
34240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34241 if (!SWIG_IsOK(res1)) {
34242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34243 }
34244 arg1 = reinterpret_cast< wxWindow * >(argp1);
34245 {
34246 PyThreadState* __tstate = wxPyBeginAllowThreads();
34247 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34248 wxPyEndAllowThreads(__tstate);
34249 if (PyErr_Occurred()) SWIG_fail;
34250 }
34251 resultobj = SWIG_Py_Void();
34252 if (SWIG_IsTmpObj(res2)) {
34253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34254 } else {
34255 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34257 }
34258 if (SWIG_IsTmpObj(res3)) {
34259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34260 } else {
34261 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34263 }
34264 return resultobj;
34265 fail:
34266 return NULL;
34267 }
34268
34269
34270 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34271 PyObject *resultobj = 0;
34272 wxWindow *arg1 = (wxWindow *) 0 ;
34273 wxRect result;
34274 void *argp1 = 0 ;
34275 int res1 = 0 ;
34276 PyObject *swig_obj[1] ;
34277
34278 if (!args) SWIG_fail;
34279 swig_obj[0] = args;
34280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34281 if (!SWIG_IsOK(res1)) {
34282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34283 }
34284 arg1 = reinterpret_cast< wxWindow * >(argp1);
34285 {
34286 PyThreadState* __tstate = wxPyBeginAllowThreads();
34287 result = ((wxWindow const *)arg1)->GetRect();
34288 wxPyEndAllowThreads(__tstate);
34289 if (PyErr_Occurred()) SWIG_fail;
34290 }
34291 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34292 return resultobj;
34293 fail:
34294 return NULL;
34295 }
34296
34297
34298 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34299 PyObject *resultobj = 0;
34300 wxWindow *arg1 = (wxWindow *) 0 ;
34301 wxSize result;
34302 void *argp1 = 0 ;
34303 int res1 = 0 ;
34304 PyObject *swig_obj[1] ;
34305
34306 if (!args) SWIG_fail;
34307 swig_obj[0] = args;
34308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34309 if (!SWIG_IsOK(res1)) {
34310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34311 }
34312 arg1 = reinterpret_cast< wxWindow * >(argp1);
34313 {
34314 PyThreadState* __tstate = wxPyBeginAllowThreads();
34315 result = ((wxWindow const *)arg1)->GetClientSize();
34316 wxPyEndAllowThreads(__tstate);
34317 if (PyErr_Occurred()) SWIG_fail;
34318 }
34319 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34320 return resultobj;
34321 fail:
34322 return NULL;
34323 }
34324
34325
34326 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34327 PyObject *resultobj = 0;
34328 wxWindow *arg1 = (wxWindow *) 0 ;
34329 int *arg2 = (int *) 0 ;
34330 int *arg3 = (int *) 0 ;
34331 void *argp1 = 0 ;
34332 int res1 = 0 ;
34333 int temp2 ;
34334 int res2 = SWIG_TMPOBJ ;
34335 int temp3 ;
34336 int res3 = SWIG_TMPOBJ ;
34337 PyObject *swig_obj[1] ;
34338
34339 arg2 = &temp2;
34340 arg3 = &temp3;
34341 if (!args) SWIG_fail;
34342 swig_obj[0] = args;
34343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34344 if (!SWIG_IsOK(res1)) {
34345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34346 }
34347 arg1 = reinterpret_cast< wxWindow * >(argp1);
34348 {
34349 PyThreadState* __tstate = wxPyBeginAllowThreads();
34350 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34351 wxPyEndAllowThreads(__tstate);
34352 if (PyErr_Occurred()) SWIG_fail;
34353 }
34354 resultobj = SWIG_Py_Void();
34355 if (SWIG_IsTmpObj(res2)) {
34356 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34357 } else {
34358 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34359 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34360 }
34361 if (SWIG_IsTmpObj(res3)) {
34362 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34363 } else {
34364 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34365 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34366 }
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34374 PyObject *resultobj = 0;
34375 wxWindow *arg1 = (wxWindow *) 0 ;
34376 wxPoint result;
34377 void *argp1 = 0 ;
34378 int res1 = 0 ;
34379 PyObject *swig_obj[1] ;
34380
34381 if (!args) SWIG_fail;
34382 swig_obj[0] = args;
34383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34384 if (!SWIG_IsOK(res1)) {
34385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34386 }
34387 arg1 = reinterpret_cast< wxWindow * >(argp1);
34388 {
34389 PyThreadState* __tstate = wxPyBeginAllowThreads();
34390 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34391 wxPyEndAllowThreads(__tstate);
34392 if (PyErr_Occurred()) SWIG_fail;
34393 }
34394 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34395 return resultobj;
34396 fail:
34397 return NULL;
34398 }
34399
34400
34401 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34402 PyObject *resultobj = 0;
34403 wxWindow *arg1 = (wxWindow *) 0 ;
34404 wxRect result;
34405 void *argp1 = 0 ;
34406 int res1 = 0 ;
34407 PyObject *swig_obj[1] ;
34408
34409 if (!args) SWIG_fail;
34410 swig_obj[0] = args;
34411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34412 if (!SWIG_IsOK(res1)) {
34413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34414 }
34415 arg1 = reinterpret_cast< wxWindow * >(argp1);
34416 {
34417 PyThreadState* __tstate = wxPyBeginAllowThreads();
34418 result = ((wxWindow const *)arg1)->GetClientRect();
34419 wxPyEndAllowThreads(__tstate);
34420 if (PyErr_Occurred()) SWIG_fail;
34421 }
34422 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34423 return resultobj;
34424 fail:
34425 return NULL;
34426 }
34427
34428
34429 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34430 PyObject *resultobj = 0;
34431 wxWindow *arg1 = (wxWindow *) 0 ;
34432 wxSize result;
34433 void *argp1 = 0 ;
34434 int res1 = 0 ;
34435 PyObject *swig_obj[1] ;
34436
34437 if (!args) SWIG_fail;
34438 swig_obj[0] = args;
34439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34440 if (!SWIG_IsOK(res1)) {
34441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34442 }
34443 arg1 = reinterpret_cast< wxWindow * >(argp1);
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 result = ((wxWindow const *)arg1)->GetBestSize();
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 PyObject *resultobj = 0;
34459 wxWindow *arg1 = (wxWindow *) 0 ;
34460 int *arg2 = (int *) 0 ;
34461 int *arg3 = (int *) 0 ;
34462 void *argp1 = 0 ;
34463 int res1 = 0 ;
34464 int temp2 ;
34465 int res2 = SWIG_TMPOBJ ;
34466 int temp3 ;
34467 int res3 = SWIG_TMPOBJ ;
34468 PyObject *swig_obj[1] ;
34469
34470 arg2 = &temp2;
34471 arg3 = &temp3;
34472 if (!args) SWIG_fail;
34473 swig_obj[0] = args;
34474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34475 if (!SWIG_IsOK(res1)) {
34476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34477 }
34478 arg1 = reinterpret_cast< wxWindow * >(argp1);
34479 {
34480 PyThreadState* __tstate = wxPyBeginAllowThreads();
34481 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34482 wxPyEndAllowThreads(__tstate);
34483 if (PyErr_Occurred()) SWIG_fail;
34484 }
34485 resultobj = SWIG_Py_Void();
34486 if (SWIG_IsTmpObj(res2)) {
34487 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34488 } else {
34489 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34490 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34491 }
34492 if (SWIG_IsTmpObj(res3)) {
34493 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34494 } else {
34495 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34496 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34497 }
34498 return resultobj;
34499 fail:
34500 return NULL;
34501 }
34502
34503
34504 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34505 PyObject *resultobj = 0;
34506 wxWindow *arg1 = (wxWindow *) 0 ;
34507 void *argp1 = 0 ;
34508 int res1 = 0 ;
34509 PyObject *swig_obj[1] ;
34510
34511 if (!args) SWIG_fail;
34512 swig_obj[0] = args;
34513 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34514 if (!SWIG_IsOK(res1)) {
34515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34516 }
34517 arg1 = reinterpret_cast< wxWindow * >(argp1);
34518 {
34519 PyThreadState* __tstate = wxPyBeginAllowThreads();
34520 (arg1)->InvalidateBestSize();
34521 wxPyEndAllowThreads(__tstate);
34522 if (PyErr_Occurred()) SWIG_fail;
34523 }
34524 resultobj = SWIG_Py_Void();
34525 return resultobj;
34526 fail:
34527 return NULL;
34528 }
34529
34530
34531 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34532 PyObject *resultobj = 0;
34533 wxWindow *arg1 = (wxWindow *) 0 ;
34534 wxSize *arg2 = 0 ;
34535 void *argp1 = 0 ;
34536 int res1 = 0 ;
34537 wxSize temp2 ;
34538 PyObject * obj0 = 0 ;
34539 PyObject * obj1 = 0 ;
34540 char * kwnames[] = {
34541 (char *) "self",(char *) "size", NULL
34542 };
34543
34544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34546 if (!SWIG_IsOK(res1)) {
34547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34548 }
34549 arg1 = reinterpret_cast< wxWindow * >(argp1);
34550 {
34551 arg2 = &temp2;
34552 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34553 }
34554 {
34555 PyThreadState* __tstate = wxPyBeginAllowThreads();
34556 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34557 wxPyEndAllowThreads(__tstate);
34558 if (PyErr_Occurred()) SWIG_fail;
34559 }
34560 resultobj = SWIG_Py_Void();
34561 return resultobj;
34562 fail:
34563 return NULL;
34564 }
34565
34566
34567 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34568 PyObject *resultobj = 0;
34569 wxWindow *arg1 = (wxWindow *) 0 ;
34570 wxSize result;
34571 void *argp1 = 0 ;
34572 int res1 = 0 ;
34573 PyObject *swig_obj[1] ;
34574
34575 if (!args) SWIG_fail;
34576 swig_obj[0] = args;
34577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34578 if (!SWIG_IsOK(res1)) {
34579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34580 }
34581 arg1 = reinterpret_cast< wxWindow * >(argp1);
34582 {
34583 PyThreadState* __tstate = wxPyBeginAllowThreads();
34584 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34585 wxPyEndAllowThreads(__tstate);
34586 if (PyErr_Occurred()) SWIG_fail;
34587 }
34588 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34589 return resultobj;
34590 fail:
34591 return NULL;
34592 }
34593
34594
34595 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34596 PyObject *resultobj = 0;
34597 wxWindow *arg1 = (wxWindow *) 0 ;
34598 int arg2 = (int) wxBOTH ;
34599 void *argp1 = 0 ;
34600 int res1 = 0 ;
34601 int val2 ;
34602 int ecode2 = 0 ;
34603 PyObject * obj0 = 0 ;
34604 PyObject * obj1 = 0 ;
34605 char * kwnames[] = {
34606 (char *) "self",(char *) "direction", NULL
34607 };
34608
34609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34611 if (!SWIG_IsOK(res1)) {
34612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34613 }
34614 arg1 = reinterpret_cast< wxWindow * >(argp1);
34615 if (obj1) {
34616 ecode2 = SWIG_AsVal_int(obj1, &val2);
34617 if (!SWIG_IsOK(ecode2)) {
34618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34619 }
34620 arg2 = static_cast< int >(val2);
34621 }
34622 {
34623 PyThreadState* __tstate = wxPyBeginAllowThreads();
34624 (arg1)->Center(arg2);
34625 wxPyEndAllowThreads(__tstate);
34626 if (PyErr_Occurred()) SWIG_fail;
34627 }
34628 resultobj = SWIG_Py_Void();
34629 return resultobj;
34630 fail:
34631 return NULL;
34632 }
34633
34634
34635 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34636 PyObject *resultobj = 0;
34637 wxWindow *arg1 = (wxWindow *) 0 ;
34638 int arg2 = (int) wxBOTH ;
34639 void *argp1 = 0 ;
34640 int res1 = 0 ;
34641 int val2 ;
34642 int ecode2 = 0 ;
34643 PyObject * obj0 = 0 ;
34644 PyObject * obj1 = 0 ;
34645 char * kwnames[] = {
34646 (char *) "self",(char *) "dir", NULL
34647 };
34648
34649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34651 if (!SWIG_IsOK(res1)) {
34652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34653 }
34654 arg1 = reinterpret_cast< wxWindow * >(argp1);
34655 if (obj1) {
34656 ecode2 = SWIG_AsVal_int(obj1, &val2);
34657 if (!SWIG_IsOK(ecode2)) {
34658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34659 }
34660 arg2 = static_cast< int >(val2);
34661 }
34662 {
34663 PyThreadState* __tstate = wxPyBeginAllowThreads();
34664 (arg1)->CenterOnParent(arg2);
34665 wxPyEndAllowThreads(__tstate);
34666 if (PyErr_Occurred()) SWIG_fail;
34667 }
34668 resultobj = SWIG_Py_Void();
34669 return resultobj;
34670 fail:
34671 return NULL;
34672 }
34673
34674
34675 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34676 PyObject *resultobj = 0;
34677 wxWindow *arg1 = (wxWindow *) 0 ;
34678 void *argp1 = 0 ;
34679 int res1 = 0 ;
34680 PyObject *swig_obj[1] ;
34681
34682 if (!args) SWIG_fail;
34683 swig_obj[0] = args;
34684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34685 if (!SWIG_IsOK(res1)) {
34686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34687 }
34688 arg1 = reinterpret_cast< wxWindow * >(argp1);
34689 {
34690 PyThreadState* __tstate = wxPyBeginAllowThreads();
34691 (arg1)->Fit();
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 resultobj = SWIG_Py_Void();
34696 return resultobj;
34697 fail:
34698 return NULL;
34699 }
34700
34701
34702 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34703 PyObject *resultobj = 0;
34704 wxWindow *arg1 = (wxWindow *) 0 ;
34705 void *argp1 = 0 ;
34706 int res1 = 0 ;
34707 PyObject *swig_obj[1] ;
34708
34709 if (!args) SWIG_fail;
34710 swig_obj[0] = args;
34711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34712 if (!SWIG_IsOK(res1)) {
34713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34714 }
34715 arg1 = reinterpret_cast< wxWindow * >(argp1);
34716 {
34717 PyThreadState* __tstate = wxPyBeginAllowThreads();
34718 (arg1)->FitInside();
34719 wxPyEndAllowThreads(__tstate);
34720 if (PyErr_Occurred()) SWIG_fail;
34721 }
34722 resultobj = SWIG_Py_Void();
34723 return resultobj;
34724 fail:
34725 return NULL;
34726 }
34727
34728
34729 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34730 PyObject *resultobj = 0;
34731 wxWindow *arg1 = (wxWindow *) 0 ;
34732 int arg2 ;
34733 int arg3 ;
34734 int arg4 = (int) -1 ;
34735 int arg5 = (int) -1 ;
34736 int arg6 = (int) -1 ;
34737 int arg7 = (int) -1 ;
34738 void *argp1 = 0 ;
34739 int res1 = 0 ;
34740 int val2 ;
34741 int ecode2 = 0 ;
34742 int val3 ;
34743 int ecode3 = 0 ;
34744 int val4 ;
34745 int ecode4 = 0 ;
34746 int val5 ;
34747 int ecode5 = 0 ;
34748 int val6 ;
34749 int ecode6 = 0 ;
34750 int val7 ;
34751 int ecode7 = 0 ;
34752 PyObject * obj0 = 0 ;
34753 PyObject * obj1 = 0 ;
34754 PyObject * obj2 = 0 ;
34755 PyObject * obj3 = 0 ;
34756 PyObject * obj4 = 0 ;
34757 PyObject * obj5 = 0 ;
34758 PyObject * obj6 = 0 ;
34759 char * kwnames[] = {
34760 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34761 };
34762
34763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34767 }
34768 arg1 = reinterpret_cast< wxWindow * >(argp1);
34769 ecode2 = SWIG_AsVal_int(obj1, &val2);
34770 if (!SWIG_IsOK(ecode2)) {
34771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34772 }
34773 arg2 = static_cast< int >(val2);
34774 ecode3 = SWIG_AsVal_int(obj2, &val3);
34775 if (!SWIG_IsOK(ecode3)) {
34776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34777 }
34778 arg3 = static_cast< int >(val3);
34779 if (obj3) {
34780 ecode4 = SWIG_AsVal_int(obj3, &val4);
34781 if (!SWIG_IsOK(ecode4)) {
34782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34783 }
34784 arg4 = static_cast< int >(val4);
34785 }
34786 if (obj4) {
34787 ecode5 = SWIG_AsVal_int(obj4, &val5);
34788 if (!SWIG_IsOK(ecode5)) {
34789 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34790 }
34791 arg5 = static_cast< int >(val5);
34792 }
34793 if (obj5) {
34794 ecode6 = SWIG_AsVal_int(obj5, &val6);
34795 if (!SWIG_IsOK(ecode6)) {
34796 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34797 }
34798 arg6 = static_cast< int >(val6);
34799 }
34800 if (obj6) {
34801 ecode7 = SWIG_AsVal_int(obj6, &val7);
34802 if (!SWIG_IsOK(ecode7)) {
34803 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34804 }
34805 arg7 = static_cast< int >(val7);
34806 }
34807 {
34808 PyThreadState* __tstate = wxPyBeginAllowThreads();
34809 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34810 wxPyEndAllowThreads(__tstate);
34811 if (PyErr_Occurred()) SWIG_fail;
34812 }
34813 resultobj = SWIG_Py_Void();
34814 return resultobj;
34815 fail:
34816 return NULL;
34817 }
34818
34819
34820 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34821 PyObject *resultobj = 0;
34822 wxWindow *arg1 = (wxWindow *) 0 ;
34823 wxSize *arg2 = 0 ;
34824 wxSize const &arg3_defvalue = wxDefaultSize ;
34825 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34826 wxSize const &arg4_defvalue = wxDefaultSize ;
34827 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34828 void *argp1 = 0 ;
34829 int res1 = 0 ;
34830 wxSize temp2 ;
34831 wxSize temp3 ;
34832 wxSize temp4 ;
34833 PyObject * obj0 = 0 ;
34834 PyObject * obj1 = 0 ;
34835 PyObject * obj2 = 0 ;
34836 PyObject * obj3 = 0 ;
34837 char * kwnames[] = {
34838 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34839 };
34840
34841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34843 if (!SWIG_IsOK(res1)) {
34844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34845 }
34846 arg1 = reinterpret_cast< wxWindow * >(argp1);
34847 {
34848 arg2 = &temp2;
34849 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34850 }
34851 if (obj2) {
34852 {
34853 arg3 = &temp3;
34854 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34855 }
34856 }
34857 if (obj3) {
34858 {
34859 arg4 = &temp4;
34860 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
34861 }
34862 }
34863 {
34864 PyThreadState* __tstate = wxPyBeginAllowThreads();
34865 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
34866 wxPyEndAllowThreads(__tstate);
34867 if (PyErr_Occurred()) SWIG_fail;
34868 }
34869 resultobj = SWIG_Py_Void();
34870 return resultobj;
34871 fail:
34872 return NULL;
34873 }
34874
34875
34876 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34877 PyObject *resultobj = 0;
34878 wxWindow *arg1 = (wxWindow *) 0 ;
34879 int arg2 ;
34880 int arg3 ;
34881 int arg4 = (int) -1 ;
34882 int arg5 = (int) -1 ;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 int val2 ;
34886 int ecode2 = 0 ;
34887 int val3 ;
34888 int ecode3 = 0 ;
34889 int val4 ;
34890 int ecode4 = 0 ;
34891 int val5 ;
34892 int ecode5 = 0 ;
34893 PyObject * obj0 = 0 ;
34894 PyObject * obj1 = 0 ;
34895 PyObject * obj2 = 0 ;
34896 PyObject * obj3 = 0 ;
34897 PyObject * obj4 = 0 ;
34898 char * kwnames[] = {
34899 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
34900 };
34901
34902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34904 if (!SWIG_IsOK(res1)) {
34905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34906 }
34907 arg1 = reinterpret_cast< wxWindow * >(argp1);
34908 ecode2 = SWIG_AsVal_int(obj1, &val2);
34909 if (!SWIG_IsOK(ecode2)) {
34910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
34911 }
34912 arg2 = static_cast< int >(val2);
34913 ecode3 = SWIG_AsVal_int(obj2, &val3);
34914 if (!SWIG_IsOK(ecode3)) {
34915 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
34916 }
34917 arg3 = static_cast< int >(val3);
34918 if (obj3) {
34919 ecode4 = SWIG_AsVal_int(obj3, &val4);
34920 if (!SWIG_IsOK(ecode4)) {
34921 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
34922 }
34923 arg4 = static_cast< int >(val4);
34924 }
34925 if (obj4) {
34926 ecode5 = SWIG_AsVal_int(obj4, &val5);
34927 if (!SWIG_IsOK(ecode5)) {
34928 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
34929 }
34930 arg5 = static_cast< int >(val5);
34931 }
34932 {
34933 PyThreadState* __tstate = wxPyBeginAllowThreads();
34934 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
34935 wxPyEndAllowThreads(__tstate);
34936 if (PyErr_Occurred()) SWIG_fail;
34937 }
34938 resultobj = SWIG_Py_Void();
34939 return resultobj;
34940 fail:
34941 return NULL;
34942 }
34943
34944
34945 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34946 PyObject *resultobj = 0;
34947 wxWindow *arg1 = (wxWindow *) 0 ;
34948 wxSize *arg2 = 0 ;
34949 wxSize const &arg3_defvalue = wxDefaultSize ;
34950 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34951 void *argp1 = 0 ;
34952 int res1 = 0 ;
34953 wxSize temp2 ;
34954 wxSize temp3 ;
34955 PyObject * obj0 = 0 ;
34956 PyObject * obj1 = 0 ;
34957 PyObject * obj2 = 0 ;
34958 char * kwnames[] = {
34959 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
34960 };
34961
34962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34964 if (!SWIG_IsOK(res1)) {
34965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
34966 }
34967 arg1 = reinterpret_cast< wxWindow * >(argp1);
34968 {
34969 arg2 = &temp2;
34970 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34971 }
34972 if (obj2) {
34973 {
34974 arg3 = &temp3;
34975 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
34976 }
34977 }
34978 {
34979 PyThreadState* __tstate = wxPyBeginAllowThreads();
34980 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
34981 wxPyEndAllowThreads(__tstate);
34982 if (PyErr_Occurred()) SWIG_fail;
34983 }
34984 resultobj = SWIG_Py_Void();
34985 return resultobj;
34986 fail:
34987 return NULL;
34988 }
34989
34990
34991 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34992 PyObject *resultobj = 0;
34993 wxWindow *arg1 = (wxWindow *) 0 ;
34994 wxSize result;
34995 void *argp1 = 0 ;
34996 int res1 = 0 ;
34997 PyObject *swig_obj[1] ;
34998
34999 if (!args) SWIG_fail;
35000 swig_obj[0] = args;
35001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35002 if (!SWIG_IsOK(res1)) {
35003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35004 }
35005 arg1 = reinterpret_cast< wxWindow * >(argp1);
35006 {
35007 PyThreadState* __tstate = wxPyBeginAllowThreads();
35008 result = ((wxWindow const *)arg1)->GetMaxSize();
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35013 return resultobj;
35014 fail:
35015 return NULL;
35016 }
35017
35018
35019 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35020 PyObject *resultobj = 0;
35021 wxWindow *arg1 = (wxWindow *) 0 ;
35022 wxSize result;
35023 void *argp1 = 0 ;
35024 int res1 = 0 ;
35025 PyObject *swig_obj[1] ;
35026
35027 if (!args) SWIG_fail;
35028 swig_obj[0] = args;
35029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35030 if (!SWIG_IsOK(res1)) {
35031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35032 }
35033 arg1 = reinterpret_cast< wxWindow * >(argp1);
35034 {
35035 PyThreadState* __tstate = wxPyBeginAllowThreads();
35036 result = ((wxWindow const *)arg1)->GetMinSize();
35037 wxPyEndAllowThreads(__tstate);
35038 if (PyErr_Occurred()) SWIG_fail;
35039 }
35040 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35041 return resultobj;
35042 fail:
35043 return NULL;
35044 }
35045
35046
35047 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35048 PyObject *resultobj = 0;
35049 wxWindow *arg1 = (wxWindow *) 0 ;
35050 wxSize *arg2 = 0 ;
35051 void *argp1 = 0 ;
35052 int res1 = 0 ;
35053 wxSize temp2 ;
35054 PyObject * obj0 = 0 ;
35055 PyObject * obj1 = 0 ;
35056 char * kwnames[] = {
35057 (char *) "self",(char *) "minSize", NULL
35058 };
35059
35060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35061 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35062 if (!SWIG_IsOK(res1)) {
35063 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35064 }
35065 arg1 = reinterpret_cast< wxWindow * >(argp1);
35066 {
35067 arg2 = &temp2;
35068 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35069 }
35070 {
35071 PyThreadState* __tstate = wxPyBeginAllowThreads();
35072 (arg1)->SetMinSize((wxSize const &)*arg2);
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 resultobj = SWIG_Py_Void();
35077 return resultobj;
35078 fail:
35079 return NULL;
35080 }
35081
35082
35083 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35084 PyObject *resultobj = 0;
35085 wxWindow *arg1 = (wxWindow *) 0 ;
35086 wxSize *arg2 = 0 ;
35087 void *argp1 = 0 ;
35088 int res1 = 0 ;
35089 wxSize temp2 ;
35090 PyObject * obj0 = 0 ;
35091 PyObject * obj1 = 0 ;
35092 char * kwnames[] = {
35093 (char *) "self",(char *) "maxSize", NULL
35094 };
35095
35096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35098 if (!SWIG_IsOK(res1)) {
35099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35100 }
35101 arg1 = reinterpret_cast< wxWindow * >(argp1);
35102 {
35103 arg2 = &temp2;
35104 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35105 }
35106 {
35107 PyThreadState* __tstate = wxPyBeginAllowThreads();
35108 (arg1)->SetMaxSize((wxSize const &)*arg2);
35109 wxPyEndAllowThreads(__tstate);
35110 if (PyErr_Occurred()) SWIG_fail;
35111 }
35112 resultobj = SWIG_Py_Void();
35113 return resultobj;
35114 fail:
35115 return NULL;
35116 }
35117
35118
35119 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35120 PyObject *resultobj = 0;
35121 wxWindow *arg1 = (wxWindow *) 0 ;
35122 int 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_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35132 }
35133 arg1 = reinterpret_cast< wxWindow * >(argp1);
35134 {
35135 PyThreadState* __tstate = wxPyBeginAllowThreads();
35136 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35137 wxPyEndAllowThreads(__tstate);
35138 if (PyErr_Occurred()) SWIG_fail;
35139 }
35140 resultobj = SWIG_From_int(static_cast< int >(result));
35141 return resultobj;
35142 fail:
35143 return NULL;
35144 }
35145
35146
35147 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35148 PyObject *resultobj = 0;
35149 wxWindow *arg1 = (wxWindow *) 0 ;
35150 int result;
35151 void *argp1 = 0 ;
35152 int res1 = 0 ;
35153 PyObject *swig_obj[1] ;
35154
35155 if (!args) SWIG_fail;
35156 swig_obj[0] = args;
35157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35158 if (!SWIG_IsOK(res1)) {
35159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35160 }
35161 arg1 = reinterpret_cast< wxWindow * >(argp1);
35162 {
35163 PyThreadState* __tstate = wxPyBeginAllowThreads();
35164 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35165 wxPyEndAllowThreads(__tstate);
35166 if (PyErr_Occurred()) SWIG_fail;
35167 }
35168 resultobj = SWIG_From_int(static_cast< int >(result));
35169 return resultobj;
35170 fail:
35171 return NULL;
35172 }
35173
35174
35175 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35176 PyObject *resultobj = 0;
35177 wxWindow *arg1 = (wxWindow *) 0 ;
35178 int result;
35179 void *argp1 = 0 ;
35180 int res1 = 0 ;
35181 PyObject *swig_obj[1] ;
35182
35183 if (!args) SWIG_fail;
35184 swig_obj[0] = args;
35185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35186 if (!SWIG_IsOK(res1)) {
35187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35188 }
35189 arg1 = reinterpret_cast< wxWindow * >(argp1);
35190 {
35191 PyThreadState* __tstate = wxPyBeginAllowThreads();
35192 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35193 wxPyEndAllowThreads(__tstate);
35194 if (PyErr_Occurred()) SWIG_fail;
35195 }
35196 resultobj = SWIG_From_int(static_cast< int >(result));
35197 return resultobj;
35198 fail:
35199 return NULL;
35200 }
35201
35202
35203 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35204 PyObject *resultobj = 0;
35205 wxWindow *arg1 = (wxWindow *) 0 ;
35206 int result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 PyObject *swig_obj[1] ;
35210
35211 if (!args) SWIG_fail;
35212 swig_obj[0] = args;
35213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35214 if (!SWIG_IsOK(res1)) {
35215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35216 }
35217 arg1 = reinterpret_cast< wxWindow * >(argp1);
35218 {
35219 PyThreadState* __tstate = wxPyBeginAllowThreads();
35220 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35221 wxPyEndAllowThreads(__tstate);
35222 if (PyErr_Occurred()) SWIG_fail;
35223 }
35224 resultobj = SWIG_From_int(static_cast< int >(result));
35225 return resultobj;
35226 fail:
35227 return NULL;
35228 }
35229
35230
35231 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35232 PyObject *resultobj = 0;
35233 wxWindow *arg1 = (wxWindow *) 0 ;
35234 wxSize *arg2 = 0 ;
35235 void *argp1 = 0 ;
35236 int res1 = 0 ;
35237 wxSize temp2 ;
35238 PyObject * obj0 = 0 ;
35239 PyObject * obj1 = 0 ;
35240 char * kwnames[] = {
35241 (char *) "self",(char *) "size", NULL
35242 };
35243
35244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35246 if (!SWIG_IsOK(res1)) {
35247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35248 }
35249 arg1 = reinterpret_cast< wxWindow * >(argp1);
35250 {
35251 arg2 = &temp2;
35252 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35253 }
35254 {
35255 PyThreadState* __tstate = wxPyBeginAllowThreads();
35256 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35257 wxPyEndAllowThreads(__tstate);
35258 if (PyErr_Occurred()) SWIG_fail;
35259 }
35260 resultobj = SWIG_Py_Void();
35261 return resultobj;
35262 fail:
35263 return NULL;
35264 }
35265
35266
35267 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35268 PyObject *resultobj = 0;
35269 wxWindow *arg1 = (wxWindow *) 0 ;
35270 int arg2 ;
35271 int arg3 ;
35272 void *argp1 = 0 ;
35273 int res1 = 0 ;
35274 int val2 ;
35275 int ecode2 = 0 ;
35276 int val3 ;
35277 int ecode3 = 0 ;
35278 PyObject * obj0 = 0 ;
35279 PyObject * obj1 = 0 ;
35280 PyObject * obj2 = 0 ;
35281 char * kwnames[] = {
35282 (char *) "self",(char *) "w",(char *) "h", NULL
35283 };
35284
35285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35287 if (!SWIG_IsOK(res1)) {
35288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35289 }
35290 arg1 = reinterpret_cast< wxWindow * >(argp1);
35291 ecode2 = SWIG_AsVal_int(obj1, &val2);
35292 if (!SWIG_IsOK(ecode2)) {
35293 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35294 }
35295 arg2 = static_cast< int >(val2);
35296 ecode3 = SWIG_AsVal_int(obj2, &val3);
35297 if (!SWIG_IsOK(ecode3)) {
35298 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35299 }
35300 arg3 = static_cast< int >(val3);
35301 {
35302 PyThreadState* __tstate = wxPyBeginAllowThreads();
35303 (arg1)->SetVirtualSize(arg2,arg3);
35304 wxPyEndAllowThreads(__tstate);
35305 if (PyErr_Occurred()) SWIG_fail;
35306 }
35307 resultobj = SWIG_Py_Void();
35308 return resultobj;
35309 fail:
35310 return NULL;
35311 }
35312
35313
35314 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35315 PyObject *resultobj = 0;
35316 wxWindow *arg1 = (wxWindow *) 0 ;
35317 wxSize result;
35318 void *argp1 = 0 ;
35319 int res1 = 0 ;
35320 PyObject *swig_obj[1] ;
35321
35322 if (!args) SWIG_fail;
35323 swig_obj[0] = args;
35324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35325 if (!SWIG_IsOK(res1)) {
35326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35327 }
35328 arg1 = reinterpret_cast< wxWindow * >(argp1);
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = ((wxWindow const *)arg1)->GetVirtualSize();
35332 wxPyEndAllowThreads(__tstate);
35333 if (PyErr_Occurred()) SWIG_fail;
35334 }
35335 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35336 return resultobj;
35337 fail:
35338 return NULL;
35339 }
35340
35341
35342 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35343 PyObject *resultobj = 0;
35344 wxWindow *arg1 = (wxWindow *) 0 ;
35345 int *arg2 = (int *) 0 ;
35346 int *arg3 = (int *) 0 ;
35347 void *argp1 = 0 ;
35348 int res1 = 0 ;
35349 int temp2 ;
35350 int res2 = SWIG_TMPOBJ ;
35351 int temp3 ;
35352 int res3 = SWIG_TMPOBJ ;
35353 PyObject *swig_obj[1] ;
35354
35355 arg2 = &temp2;
35356 arg3 = &temp3;
35357 if (!args) SWIG_fail;
35358 swig_obj[0] = args;
35359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35360 if (!SWIG_IsOK(res1)) {
35361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35362 }
35363 arg1 = reinterpret_cast< wxWindow * >(argp1);
35364 {
35365 PyThreadState* __tstate = wxPyBeginAllowThreads();
35366 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35367 wxPyEndAllowThreads(__tstate);
35368 if (PyErr_Occurred()) SWIG_fail;
35369 }
35370 resultobj = SWIG_Py_Void();
35371 if (SWIG_IsTmpObj(res2)) {
35372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35373 } else {
35374 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35376 }
35377 if (SWIG_IsTmpObj(res3)) {
35378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35379 } else {
35380 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35381 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35382 }
35383 return resultobj;
35384 fail:
35385 return NULL;
35386 }
35387
35388
35389 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35390 PyObject *resultobj = 0;
35391 wxWindow *arg1 = (wxWindow *) 0 ;
35392 wxSize result;
35393 void *argp1 = 0 ;
35394 int res1 = 0 ;
35395 PyObject *swig_obj[1] ;
35396
35397 if (!args) SWIG_fail;
35398 swig_obj[0] = args;
35399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35400 if (!SWIG_IsOK(res1)) {
35401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35402 }
35403 arg1 = reinterpret_cast< wxWindow * >(argp1);
35404 {
35405 PyThreadState* __tstate = wxPyBeginAllowThreads();
35406 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35407 wxPyEndAllowThreads(__tstate);
35408 if (PyErr_Occurred()) SWIG_fail;
35409 }
35410 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35411 return resultobj;
35412 fail:
35413 return NULL;
35414 }
35415
35416
35417 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35418 PyObject *resultobj = 0;
35419 wxWindow *arg1 = (wxWindow *) 0 ;
35420 bool arg2 = (bool) true ;
35421 bool result;
35422 void *argp1 = 0 ;
35423 int res1 = 0 ;
35424 bool val2 ;
35425 int ecode2 = 0 ;
35426 PyObject * obj0 = 0 ;
35427 PyObject * obj1 = 0 ;
35428 char * kwnames[] = {
35429 (char *) "self",(char *) "show", NULL
35430 };
35431
35432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35434 if (!SWIG_IsOK(res1)) {
35435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35436 }
35437 arg1 = reinterpret_cast< wxWindow * >(argp1);
35438 if (obj1) {
35439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35440 if (!SWIG_IsOK(ecode2)) {
35441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35442 }
35443 arg2 = static_cast< bool >(val2);
35444 }
35445 {
35446 PyThreadState* __tstate = wxPyBeginAllowThreads();
35447 result = (bool)(arg1)->Show(arg2);
35448 wxPyEndAllowThreads(__tstate);
35449 if (PyErr_Occurred()) SWIG_fail;
35450 }
35451 {
35452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35453 }
35454 return resultobj;
35455 fail:
35456 return NULL;
35457 }
35458
35459
35460 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35461 PyObject *resultobj = 0;
35462 wxWindow *arg1 = (wxWindow *) 0 ;
35463 bool result;
35464 void *argp1 = 0 ;
35465 int res1 = 0 ;
35466 PyObject *swig_obj[1] ;
35467
35468 if (!args) SWIG_fail;
35469 swig_obj[0] = args;
35470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35471 if (!SWIG_IsOK(res1)) {
35472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35473 }
35474 arg1 = reinterpret_cast< wxWindow * >(argp1);
35475 {
35476 PyThreadState* __tstate = wxPyBeginAllowThreads();
35477 result = (bool)(arg1)->Hide();
35478 wxPyEndAllowThreads(__tstate);
35479 if (PyErr_Occurred()) SWIG_fail;
35480 }
35481 {
35482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35483 }
35484 return resultobj;
35485 fail:
35486 return NULL;
35487 }
35488
35489
35490 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35491 PyObject *resultobj = 0;
35492 wxWindow *arg1 = (wxWindow *) 0 ;
35493 bool arg2 = (bool) true ;
35494 bool result;
35495 void *argp1 = 0 ;
35496 int res1 = 0 ;
35497 bool val2 ;
35498 int ecode2 = 0 ;
35499 PyObject * obj0 = 0 ;
35500 PyObject * obj1 = 0 ;
35501 char * kwnames[] = {
35502 (char *) "self",(char *) "enable", NULL
35503 };
35504
35505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35507 if (!SWIG_IsOK(res1)) {
35508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35509 }
35510 arg1 = reinterpret_cast< wxWindow * >(argp1);
35511 if (obj1) {
35512 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35513 if (!SWIG_IsOK(ecode2)) {
35514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35515 }
35516 arg2 = static_cast< bool >(val2);
35517 }
35518 {
35519 PyThreadState* __tstate = wxPyBeginAllowThreads();
35520 result = (bool)(arg1)->Enable(arg2);
35521 wxPyEndAllowThreads(__tstate);
35522 if (PyErr_Occurred()) SWIG_fail;
35523 }
35524 {
35525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35526 }
35527 return resultobj;
35528 fail:
35529 return NULL;
35530 }
35531
35532
35533 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35534 PyObject *resultobj = 0;
35535 wxWindow *arg1 = (wxWindow *) 0 ;
35536 bool result;
35537 void *argp1 = 0 ;
35538 int res1 = 0 ;
35539 PyObject *swig_obj[1] ;
35540
35541 if (!args) SWIG_fail;
35542 swig_obj[0] = args;
35543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35544 if (!SWIG_IsOK(res1)) {
35545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35546 }
35547 arg1 = reinterpret_cast< wxWindow * >(argp1);
35548 {
35549 PyThreadState* __tstate = wxPyBeginAllowThreads();
35550 result = (bool)(arg1)->Disable();
35551 wxPyEndAllowThreads(__tstate);
35552 if (PyErr_Occurred()) SWIG_fail;
35553 }
35554 {
35555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35556 }
35557 return resultobj;
35558 fail:
35559 return NULL;
35560 }
35561
35562
35563 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35564 PyObject *resultobj = 0;
35565 wxWindow *arg1 = (wxWindow *) 0 ;
35566 bool result;
35567 void *argp1 = 0 ;
35568 int res1 = 0 ;
35569 PyObject *swig_obj[1] ;
35570
35571 if (!args) SWIG_fail;
35572 swig_obj[0] = args;
35573 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35574 if (!SWIG_IsOK(res1)) {
35575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35576 }
35577 arg1 = reinterpret_cast< wxWindow * >(argp1);
35578 {
35579 PyThreadState* __tstate = wxPyBeginAllowThreads();
35580 result = (bool)((wxWindow const *)arg1)->IsShown();
35581 wxPyEndAllowThreads(__tstate);
35582 if (PyErr_Occurred()) SWIG_fail;
35583 }
35584 {
35585 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35586 }
35587 return resultobj;
35588 fail:
35589 return NULL;
35590 }
35591
35592
35593 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35594 PyObject *resultobj = 0;
35595 wxWindow *arg1 = (wxWindow *) 0 ;
35596 bool result;
35597 void *argp1 = 0 ;
35598 int res1 = 0 ;
35599 PyObject *swig_obj[1] ;
35600
35601 if (!args) SWIG_fail;
35602 swig_obj[0] = args;
35603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35604 if (!SWIG_IsOK(res1)) {
35605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35606 }
35607 arg1 = reinterpret_cast< wxWindow * >(argp1);
35608 {
35609 PyThreadState* __tstate = wxPyBeginAllowThreads();
35610 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35611 wxPyEndAllowThreads(__tstate);
35612 if (PyErr_Occurred()) SWIG_fail;
35613 }
35614 {
35615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35616 }
35617 return resultobj;
35618 fail:
35619 return NULL;
35620 }
35621
35622
35623 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35624 PyObject *resultobj = 0;
35625 wxWindow *arg1 = (wxWindow *) 0 ;
35626 bool result;
35627 void *argp1 = 0 ;
35628 int res1 = 0 ;
35629 PyObject *swig_obj[1] ;
35630
35631 if (!args) SWIG_fail;
35632 swig_obj[0] = args;
35633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35634 if (!SWIG_IsOK(res1)) {
35635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35636 }
35637 arg1 = reinterpret_cast< wxWindow * >(argp1);
35638 {
35639 PyThreadState* __tstate = wxPyBeginAllowThreads();
35640 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35641 wxPyEndAllowThreads(__tstate);
35642 if (PyErr_Occurred()) SWIG_fail;
35643 }
35644 {
35645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35646 }
35647 return resultobj;
35648 fail:
35649 return NULL;
35650 }
35651
35652
35653 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35654 PyObject *resultobj = 0;
35655 wxWindow *arg1 = (wxWindow *) 0 ;
35656 long arg2 ;
35657 void *argp1 = 0 ;
35658 int res1 = 0 ;
35659 long val2 ;
35660 int ecode2 = 0 ;
35661 PyObject * obj0 = 0 ;
35662 PyObject * obj1 = 0 ;
35663 char * kwnames[] = {
35664 (char *) "self",(char *) "style", NULL
35665 };
35666
35667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35669 if (!SWIG_IsOK(res1)) {
35670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35671 }
35672 arg1 = reinterpret_cast< wxWindow * >(argp1);
35673 ecode2 = SWIG_AsVal_long(obj1, &val2);
35674 if (!SWIG_IsOK(ecode2)) {
35675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35676 }
35677 arg2 = static_cast< long >(val2);
35678 {
35679 PyThreadState* __tstate = wxPyBeginAllowThreads();
35680 (arg1)->SetWindowStyleFlag(arg2);
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 resultobj = SWIG_Py_Void();
35685 return resultobj;
35686 fail:
35687 return NULL;
35688 }
35689
35690
35691 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35692 PyObject *resultobj = 0;
35693 wxWindow *arg1 = (wxWindow *) 0 ;
35694 long result;
35695 void *argp1 = 0 ;
35696 int res1 = 0 ;
35697 PyObject *swig_obj[1] ;
35698
35699 if (!args) SWIG_fail;
35700 swig_obj[0] = args;
35701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35702 if (!SWIG_IsOK(res1)) {
35703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35704 }
35705 arg1 = reinterpret_cast< wxWindow * >(argp1);
35706 {
35707 PyThreadState* __tstate = wxPyBeginAllowThreads();
35708 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35709 wxPyEndAllowThreads(__tstate);
35710 if (PyErr_Occurred()) SWIG_fail;
35711 }
35712 resultobj = SWIG_From_long(static_cast< long >(result));
35713 return resultobj;
35714 fail:
35715 return NULL;
35716 }
35717
35718
35719 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35720 PyObject *resultobj = 0;
35721 wxWindow *arg1 = (wxWindow *) 0 ;
35722 int arg2 ;
35723 bool result;
35724 void *argp1 = 0 ;
35725 int res1 = 0 ;
35726 int val2 ;
35727 int ecode2 = 0 ;
35728 PyObject * obj0 = 0 ;
35729 PyObject * obj1 = 0 ;
35730 char * kwnames[] = {
35731 (char *) "self",(char *) "flag", NULL
35732 };
35733
35734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35736 if (!SWIG_IsOK(res1)) {
35737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35738 }
35739 arg1 = reinterpret_cast< wxWindow * >(argp1);
35740 ecode2 = SWIG_AsVal_int(obj1, &val2);
35741 if (!SWIG_IsOK(ecode2)) {
35742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35743 }
35744 arg2 = static_cast< int >(val2);
35745 {
35746 PyThreadState* __tstate = wxPyBeginAllowThreads();
35747 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35748 wxPyEndAllowThreads(__tstate);
35749 if (PyErr_Occurred()) SWIG_fail;
35750 }
35751 {
35752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35753 }
35754 return resultobj;
35755 fail:
35756 return NULL;
35757 }
35758
35759
35760 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35761 PyObject *resultobj = 0;
35762 wxWindow *arg1 = (wxWindow *) 0 ;
35763 bool result;
35764 void *argp1 = 0 ;
35765 int res1 = 0 ;
35766 PyObject *swig_obj[1] ;
35767
35768 if (!args) SWIG_fail;
35769 swig_obj[0] = args;
35770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35771 if (!SWIG_IsOK(res1)) {
35772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35773 }
35774 arg1 = reinterpret_cast< wxWindow * >(argp1);
35775 {
35776 PyThreadState* __tstate = wxPyBeginAllowThreads();
35777 result = (bool)((wxWindow const *)arg1)->IsRetained();
35778 wxPyEndAllowThreads(__tstate);
35779 if (PyErr_Occurred()) SWIG_fail;
35780 }
35781 {
35782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35783 }
35784 return resultobj;
35785 fail:
35786 return NULL;
35787 }
35788
35789
35790 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35791 PyObject *resultobj = 0;
35792 wxWindow *arg1 = (wxWindow *) 0 ;
35793 long arg2 ;
35794 void *argp1 = 0 ;
35795 int res1 = 0 ;
35796 long val2 ;
35797 int ecode2 = 0 ;
35798 PyObject * obj0 = 0 ;
35799 PyObject * obj1 = 0 ;
35800 char * kwnames[] = {
35801 (char *) "self",(char *) "exStyle", NULL
35802 };
35803
35804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35806 if (!SWIG_IsOK(res1)) {
35807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35808 }
35809 arg1 = reinterpret_cast< wxWindow * >(argp1);
35810 ecode2 = SWIG_AsVal_long(obj1, &val2);
35811 if (!SWIG_IsOK(ecode2)) {
35812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
35813 }
35814 arg2 = static_cast< long >(val2);
35815 {
35816 PyThreadState* __tstate = wxPyBeginAllowThreads();
35817 (arg1)->SetExtraStyle(arg2);
35818 wxPyEndAllowThreads(__tstate);
35819 if (PyErr_Occurred()) SWIG_fail;
35820 }
35821 resultobj = SWIG_Py_Void();
35822 return resultobj;
35823 fail:
35824 return NULL;
35825 }
35826
35827
35828 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35829 PyObject *resultobj = 0;
35830 wxWindow *arg1 = (wxWindow *) 0 ;
35831 long result;
35832 void *argp1 = 0 ;
35833 int res1 = 0 ;
35834 PyObject *swig_obj[1] ;
35835
35836 if (!args) SWIG_fail;
35837 swig_obj[0] = args;
35838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35839 if (!SWIG_IsOK(res1)) {
35840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35841 }
35842 arg1 = reinterpret_cast< wxWindow * >(argp1);
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 resultobj = SWIG_From_long(static_cast< long >(result));
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 bool arg2 = (bool) true ;
35860 void *argp1 = 0 ;
35861 int res1 = 0 ;
35862 bool val2 ;
35863 int ecode2 = 0 ;
35864 PyObject * obj0 = 0 ;
35865 PyObject * obj1 = 0 ;
35866 char * kwnames[] = {
35867 (char *) "self",(char *) "modal", NULL
35868 };
35869
35870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
35871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35872 if (!SWIG_IsOK(res1)) {
35873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
35874 }
35875 arg1 = reinterpret_cast< wxWindow * >(argp1);
35876 if (obj1) {
35877 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35878 if (!SWIG_IsOK(ecode2)) {
35879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
35880 }
35881 arg2 = static_cast< bool >(val2);
35882 }
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 (arg1)->MakeModal(arg2);
35886 wxPyEndAllowThreads(__tstate);
35887 if (PyErr_Occurred()) SWIG_fail;
35888 }
35889 resultobj = SWIG_Py_Void();
35890 return resultobj;
35891 fail:
35892 return NULL;
35893 }
35894
35895
35896 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35897 PyObject *resultobj = 0;
35898 wxWindow *arg1 = (wxWindow *) 0 ;
35899 bool arg2 ;
35900 void *argp1 = 0 ;
35901 int res1 = 0 ;
35902 bool val2 ;
35903 int ecode2 = 0 ;
35904 PyObject * obj0 = 0 ;
35905 PyObject * obj1 = 0 ;
35906 char * kwnames[] = {
35907 (char *) "self",(char *) "enableTheme", NULL
35908 };
35909
35910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
35911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35912 if (!SWIG_IsOK(res1)) {
35913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
35914 }
35915 arg1 = reinterpret_cast< wxWindow * >(argp1);
35916 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35917 if (!SWIG_IsOK(ecode2)) {
35918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
35919 }
35920 arg2 = static_cast< bool >(val2);
35921 {
35922 PyThreadState* __tstate = wxPyBeginAllowThreads();
35923 (arg1)->SetThemeEnabled(arg2);
35924 wxPyEndAllowThreads(__tstate);
35925 if (PyErr_Occurred()) SWIG_fail;
35926 }
35927 resultobj = SWIG_Py_Void();
35928 return resultobj;
35929 fail:
35930 return NULL;
35931 }
35932
35933
35934 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35935 PyObject *resultobj = 0;
35936 wxWindow *arg1 = (wxWindow *) 0 ;
35937 bool result;
35938 void *argp1 = 0 ;
35939 int res1 = 0 ;
35940 PyObject *swig_obj[1] ;
35941
35942 if (!args) SWIG_fail;
35943 swig_obj[0] = args;
35944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35945 if (!SWIG_IsOK(res1)) {
35946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35947 }
35948 arg1 = reinterpret_cast< wxWindow * >(argp1);
35949 {
35950 PyThreadState* __tstate = wxPyBeginAllowThreads();
35951 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
35952 wxPyEndAllowThreads(__tstate);
35953 if (PyErr_Occurred()) SWIG_fail;
35954 }
35955 {
35956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35957 }
35958 return resultobj;
35959 fail:
35960 return NULL;
35961 }
35962
35963
35964 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35965 PyObject *resultobj = 0;
35966 wxWindow *arg1 = (wxWindow *) 0 ;
35967 void *argp1 = 0 ;
35968 int res1 = 0 ;
35969 PyObject *swig_obj[1] ;
35970
35971 if (!args) SWIG_fail;
35972 swig_obj[0] = args;
35973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35974 if (!SWIG_IsOK(res1)) {
35975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
35976 }
35977 arg1 = reinterpret_cast< wxWindow * >(argp1);
35978 {
35979 PyThreadState* __tstate = wxPyBeginAllowThreads();
35980 (arg1)->SetFocus();
35981 wxPyEndAllowThreads(__tstate);
35982 if (PyErr_Occurred()) SWIG_fail;
35983 }
35984 resultobj = SWIG_Py_Void();
35985 return resultobj;
35986 fail:
35987 return NULL;
35988 }
35989
35990
35991 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35992 PyObject *resultobj = 0;
35993 wxWindow *arg1 = (wxWindow *) 0 ;
35994 void *argp1 = 0 ;
35995 int res1 = 0 ;
35996 PyObject *swig_obj[1] ;
35997
35998 if (!args) SWIG_fail;
35999 swig_obj[0] = args;
36000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36001 if (!SWIG_IsOK(res1)) {
36002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36003 }
36004 arg1 = reinterpret_cast< wxWindow * >(argp1);
36005 {
36006 PyThreadState* __tstate = wxPyBeginAllowThreads();
36007 (arg1)->SetFocusFromKbd();
36008 wxPyEndAllowThreads(__tstate);
36009 if (PyErr_Occurred()) SWIG_fail;
36010 }
36011 resultobj = SWIG_Py_Void();
36012 return resultobj;
36013 fail:
36014 return NULL;
36015 }
36016
36017
36018 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36019 PyObject *resultobj = 0;
36020 wxWindow *result = 0 ;
36021
36022 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36023 {
36024 if (!wxPyCheckForApp()) SWIG_fail;
36025 PyThreadState* __tstate = wxPyBeginAllowThreads();
36026 result = (wxWindow *)wxWindow::FindFocus();
36027 wxPyEndAllowThreads(__tstate);
36028 if (PyErr_Occurred()) SWIG_fail;
36029 }
36030 {
36031 resultobj = wxPyMake_wxObject(result, 0);
36032 }
36033 return resultobj;
36034 fail:
36035 return NULL;
36036 }
36037
36038
36039 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36040 PyObject *resultobj = 0;
36041 wxWindow *arg1 = (wxWindow *) 0 ;
36042 bool result;
36043 void *argp1 = 0 ;
36044 int res1 = 0 ;
36045 PyObject *swig_obj[1] ;
36046
36047 if (!args) SWIG_fail;
36048 swig_obj[0] = args;
36049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36050 if (!SWIG_IsOK(res1)) {
36051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36052 }
36053 arg1 = reinterpret_cast< wxWindow * >(argp1);
36054 {
36055 PyThreadState* __tstate = wxPyBeginAllowThreads();
36056 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36057 wxPyEndAllowThreads(__tstate);
36058 if (PyErr_Occurred()) SWIG_fail;
36059 }
36060 {
36061 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36062 }
36063 return resultobj;
36064 fail:
36065 return NULL;
36066 }
36067
36068
36069 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36070 PyObject *resultobj = 0;
36071 wxWindow *arg1 = (wxWindow *) 0 ;
36072 bool result;
36073 void *argp1 = 0 ;
36074 int res1 = 0 ;
36075 PyObject *swig_obj[1] ;
36076
36077 if (!args) SWIG_fail;
36078 swig_obj[0] = args;
36079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36080 if (!SWIG_IsOK(res1)) {
36081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36082 }
36083 arg1 = reinterpret_cast< wxWindow * >(argp1);
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 {
36091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36092 }
36093 return resultobj;
36094 fail:
36095 return NULL;
36096 }
36097
36098
36099 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36100 PyObject *resultobj = 0;
36101 wxWindow *arg1 = (wxWindow *) 0 ;
36102 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36103 bool result;
36104 void *argp1 = 0 ;
36105 int res1 = 0 ;
36106 int val2 ;
36107 int ecode2 = 0 ;
36108 PyObject * obj0 = 0 ;
36109 PyObject * obj1 = 0 ;
36110 char * kwnames[] = {
36111 (char *) "self",(char *) "flags", NULL
36112 };
36113
36114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36116 if (!SWIG_IsOK(res1)) {
36117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36118 }
36119 arg1 = reinterpret_cast< wxWindow * >(argp1);
36120 if (obj1) {
36121 ecode2 = SWIG_AsVal_int(obj1, &val2);
36122 if (!SWIG_IsOK(ecode2)) {
36123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36124 }
36125 arg2 = static_cast< int >(val2);
36126 }
36127 {
36128 PyThreadState* __tstate = wxPyBeginAllowThreads();
36129 result = (bool)(arg1)->Navigate(arg2);
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 {
36134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36135 }
36136 return resultobj;
36137 fail:
36138 return NULL;
36139 }
36140
36141
36142 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36143 PyObject *resultobj = 0;
36144 wxWindow *arg1 = (wxWindow *) 0 ;
36145 wxWindow *arg2 = (wxWindow *) 0 ;
36146 void *argp1 = 0 ;
36147 int res1 = 0 ;
36148 void *argp2 = 0 ;
36149 int res2 = 0 ;
36150 PyObject * obj0 = 0 ;
36151 PyObject * obj1 = 0 ;
36152 char * kwnames[] = {
36153 (char *) "self",(char *) "win", NULL
36154 };
36155
36156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36157 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36158 if (!SWIG_IsOK(res1)) {
36159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36160 }
36161 arg1 = reinterpret_cast< wxWindow * >(argp1);
36162 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36163 if (!SWIG_IsOK(res2)) {
36164 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36165 }
36166 arg2 = reinterpret_cast< wxWindow * >(argp2);
36167 {
36168 PyThreadState* __tstate = wxPyBeginAllowThreads();
36169 (arg1)->MoveAfterInTabOrder(arg2);
36170 wxPyEndAllowThreads(__tstate);
36171 if (PyErr_Occurred()) SWIG_fail;
36172 }
36173 resultobj = SWIG_Py_Void();
36174 return resultobj;
36175 fail:
36176 return NULL;
36177 }
36178
36179
36180 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36181 PyObject *resultobj = 0;
36182 wxWindow *arg1 = (wxWindow *) 0 ;
36183 wxWindow *arg2 = (wxWindow *) 0 ;
36184 void *argp1 = 0 ;
36185 int res1 = 0 ;
36186 void *argp2 = 0 ;
36187 int res2 = 0 ;
36188 PyObject * obj0 = 0 ;
36189 PyObject * obj1 = 0 ;
36190 char * kwnames[] = {
36191 (char *) "self",(char *) "win", NULL
36192 };
36193
36194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36196 if (!SWIG_IsOK(res1)) {
36197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36198 }
36199 arg1 = reinterpret_cast< wxWindow * >(argp1);
36200 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36201 if (!SWIG_IsOK(res2)) {
36202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36203 }
36204 arg2 = reinterpret_cast< wxWindow * >(argp2);
36205 {
36206 PyThreadState* __tstate = wxPyBeginAllowThreads();
36207 (arg1)->MoveBeforeInTabOrder(arg2);
36208 wxPyEndAllowThreads(__tstate);
36209 if (PyErr_Occurred()) SWIG_fail;
36210 }
36211 resultobj = SWIG_Py_Void();
36212 return resultobj;
36213 fail:
36214 return NULL;
36215 }
36216
36217
36218 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36219 PyObject *resultobj = 0;
36220 wxWindow *arg1 = (wxWindow *) 0 ;
36221 PyObject *result = 0 ;
36222 void *argp1 = 0 ;
36223 int res1 = 0 ;
36224 PyObject *swig_obj[1] ;
36225
36226 if (!args) SWIG_fail;
36227 swig_obj[0] = args;
36228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36229 if (!SWIG_IsOK(res1)) {
36230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36231 }
36232 arg1 = reinterpret_cast< wxWindow * >(argp1);
36233 {
36234 PyThreadState* __tstate = wxPyBeginAllowThreads();
36235 result = (PyObject *)wxWindow_GetChildren(arg1);
36236 wxPyEndAllowThreads(__tstate);
36237 if (PyErr_Occurred()) SWIG_fail;
36238 }
36239 resultobj = result;
36240 return resultobj;
36241 fail:
36242 return NULL;
36243 }
36244
36245
36246 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36247 PyObject *resultobj = 0;
36248 wxWindow *arg1 = (wxWindow *) 0 ;
36249 wxWindow *result = 0 ;
36250 void *argp1 = 0 ;
36251 int res1 = 0 ;
36252 PyObject *swig_obj[1] ;
36253
36254 if (!args) SWIG_fail;
36255 swig_obj[0] = args;
36256 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36257 if (!SWIG_IsOK(res1)) {
36258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36259 }
36260 arg1 = reinterpret_cast< wxWindow * >(argp1);
36261 {
36262 PyThreadState* __tstate = wxPyBeginAllowThreads();
36263 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36264 wxPyEndAllowThreads(__tstate);
36265 if (PyErr_Occurred()) SWIG_fail;
36266 }
36267 {
36268 resultobj = wxPyMake_wxObject(result, 0);
36269 }
36270 return resultobj;
36271 fail:
36272 return NULL;
36273 }
36274
36275
36276 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 PyObject *resultobj = 0;
36278 wxWindow *arg1 = (wxWindow *) 0 ;
36279 wxWindow *result = 0 ;
36280 void *argp1 = 0 ;
36281 int res1 = 0 ;
36282 PyObject *swig_obj[1] ;
36283
36284 if (!args) SWIG_fail;
36285 swig_obj[0] = args;
36286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36287 if (!SWIG_IsOK(res1)) {
36288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36289 }
36290 arg1 = reinterpret_cast< wxWindow * >(argp1);
36291 {
36292 PyThreadState* __tstate = wxPyBeginAllowThreads();
36293 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36294 wxPyEndAllowThreads(__tstate);
36295 if (PyErr_Occurred()) SWIG_fail;
36296 }
36297 {
36298 resultobj = wxPyMake_wxObject(result, 0);
36299 }
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36307 PyObject *resultobj = 0;
36308 wxWindow *arg1 = (wxWindow *) 0 ;
36309 bool result;
36310 void *argp1 = 0 ;
36311 int res1 = 0 ;
36312 PyObject *swig_obj[1] ;
36313
36314 if (!args) SWIG_fail;
36315 swig_obj[0] = args;
36316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36317 if (!SWIG_IsOK(res1)) {
36318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36319 }
36320 arg1 = reinterpret_cast< wxWindow * >(argp1);
36321 {
36322 PyThreadState* __tstate = wxPyBeginAllowThreads();
36323 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36324 wxPyEndAllowThreads(__tstate);
36325 if (PyErr_Occurred()) SWIG_fail;
36326 }
36327 {
36328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36329 }
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36337 PyObject *resultobj = 0;
36338 wxWindow *arg1 = (wxWindow *) 0 ;
36339 wxWindow *arg2 = (wxWindow *) 0 ;
36340 bool result;
36341 void *argp1 = 0 ;
36342 int res1 = 0 ;
36343 void *argp2 = 0 ;
36344 int res2 = 0 ;
36345 PyObject * obj0 = 0 ;
36346 PyObject * obj1 = 0 ;
36347 char * kwnames[] = {
36348 (char *) "self",(char *) "newParent", NULL
36349 };
36350
36351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36353 if (!SWIG_IsOK(res1)) {
36354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36355 }
36356 arg1 = reinterpret_cast< wxWindow * >(argp1);
36357 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36358 if (!SWIG_IsOK(res2)) {
36359 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36360 }
36361 arg2 = reinterpret_cast< wxWindow * >(argp2);
36362 {
36363 PyThreadState* __tstate = wxPyBeginAllowThreads();
36364 result = (bool)(arg1)->Reparent(arg2);
36365 wxPyEndAllowThreads(__tstate);
36366 if (PyErr_Occurred()) SWIG_fail;
36367 }
36368 {
36369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36370 }
36371 return resultobj;
36372 fail:
36373 return NULL;
36374 }
36375
36376
36377 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36378 PyObject *resultobj = 0;
36379 wxWindow *arg1 = (wxWindow *) 0 ;
36380 wxWindow *arg2 = (wxWindow *) 0 ;
36381 void *argp1 = 0 ;
36382 int res1 = 0 ;
36383 void *argp2 = 0 ;
36384 int res2 = 0 ;
36385 PyObject * obj0 = 0 ;
36386 PyObject * obj1 = 0 ;
36387 char * kwnames[] = {
36388 (char *) "self",(char *) "child", NULL
36389 };
36390
36391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36393 if (!SWIG_IsOK(res1)) {
36394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36395 }
36396 arg1 = reinterpret_cast< wxWindow * >(argp1);
36397 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36398 if (!SWIG_IsOK(res2)) {
36399 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36400 }
36401 arg2 = reinterpret_cast< wxWindow * >(argp2);
36402 {
36403 PyThreadState* __tstate = wxPyBeginAllowThreads();
36404 (arg1)->AddChild(arg2);
36405 wxPyEndAllowThreads(__tstate);
36406 if (PyErr_Occurred()) SWIG_fail;
36407 }
36408 resultobj = SWIG_Py_Void();
36409 return resultobj;
36410 fail:
36411 return NULL;
36412 }
36413
36414
36415 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36416 PyObject *resultobj = 0;
36417 wxWindow *arg1 = (wxWindow *) 0 ;
36418 wxWindow *arg2 = (wxWindow *) 0 ;
36419 void *argp1 = 0 ;
36420 int res1 = 0 ;
36421 void *argp2 = 0 ;
36422 int res2 = 0 ;
36423 PyObject * obj0 = 0 ;
36424 PyObject * obj1 = 0 ;
36425 char * kwnames[] = {
36426 (char *) "self",(char *) "child", NULL
36427 };
36428
36429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36431 if (!SWIG_IsOK(res1)) {
36432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36433 }
36434 arg1 = reinterpret_cast< wxWindow * >(argp1);
36435 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36436 if (!SWIG_IsOK(res2)) {
36437 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36438 }
36439 arg2 = reinterpret_cast< wxWindow * >(argp2);
36440 {
36441 PyThreadState* __tstate = wxPyBeginAllowThreads();
36442 (arg1)->RemoveChild(arg2);
36443 wxPyEndAllowThreads(__tstate);
36444 if (PyErr_Occurred()) SWIG_fail;
36445 }
36446 resultobj = SWIG_Py_Void();
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj = 0;
36455 wxWindow *arg1 = (wxWindow *) 0 ;
36456 bool arg2 ;
36457 void *argp1 = 0 ;
36458 int res1 = 0 ;
36459 bool val2 ;
36460 int ecode2 = 0 ;
36461 PyObject * obj0 = 0 ;
36462 PyObject * obj1 = 0 ;
36463 char * kwnames[] = {
36464 (char *) "self",(char *) "on", NULL
36465 };
36466
36467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36469 if (!SWIG_IsOK(res1)) {
36470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36471 }
36472 arg1 = reinterpret_cast< wxWindow * >(argp1);
36473 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36474 if (!SWIG_IsOK(ecode2)) {
36475 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36476 }
36477 arg2 = static_cast< bool >(val2);
36478 {
36479 PyThreadState* __tstate = wxPyBeginAllowThreads();
36480 wxWindow_SetDoubleBuffered(arg1,arg2);
36481 wxPyEndAllowThreads(__tstate);
36482 if (PyErr_Occurred()) SWIG_fail;
36483 }
36484 resultobj = SWIG_Py_Void();
36485 return resultobj;
36486 fail:
36487 return NULL;
36488 }
36489
36490
36491 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36492 PyObject *resultobj = 0;
36493 wxWindow *arg1 = (wxWindow *) 0 ;
36494 long arg2 ;
36495 wxWindow *result = 0 ;
36496 void *argp1 = 0 ;
36497 int res1 = 0 ;
36498 long val2 ;
36499 int ecode2 = 0 ;
36500 PyObject * obj0 = 0 ;
36501 PyObject * obj1 = 0 ;
36502 char * kwnames[] = {
36503 (char *) "self",(char *) "winid", NULL
36504 };
36505
36506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36508 if (!SWIG_IsOK(res1)) {
36509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36510 }
36511 arg1 = reinterpret_cast< wxWindow * >(argp1);
36512 ecode2 = SWIG_AsVal_long(obj1, &val2);
36513 if (!SWIG_IsOK(ecode2)) {
36514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36515 }
36516 arg2 = static_cast< long >(val2);
36517 {
36518 PyThreadState* __tstate = wxPyBeginAllowThreads();
36519 result = (wxWindow *)(arg1)->FindWindow(arg2);
36520 wxPyEndAllowThreads(__tstate);
36521 if (PyErr_Occurred()) SWIG_fail;
36522 }
36523 {
36524 resultobj = wxPyMake_wxObject(result, 0);
36525 }
36526 return resultobj;
36527 fail:
36528 return NULL;
36529 }
36530
36531
36532 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36533 PyObject *resultobj = 0;
36534 wxWindow *arg1 = (wxWindow *) 0 ;
36535 wxString *arg2 = 0 ;
36536 wxWindow *result = 0 ;
36537 void *argp1 = 0 ;
36538 int res1 = 0 ;
36539 bool temp2 = false ;
36540 PyObject * obj0 = 0 ;
36541 PyObject * obj1 = 0 ;
36542 char * kwnames[] = {
36543 (char *) "self",(char *) "name", NULL
36544 };
36545
36546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36548 if (!SWIG_IsOK(res1)) {
36549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36550 }
36551 arg1 = reinterpret_cast< wxWindow * >(argp1);
36552 {
36553 arg2 = wxString_in_helper(obj1);
36554 if (arg2 == NULL) SWIG_fail;
36555 temp2 = true;
36556 }
36557 {
36558 PyThreadState* __tstate = wxPyBeginAllowThreads();
36559 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36560 wxPyEndAllowThreads(__tstate);
36561 if (PyErr_Occurred()) SWIG_fail;
36562 }
36563 {
36564 resultobj = wxPyMake_wxObject(result, 0);
36565 }
36566 {
36567 if (temp2)
36568 delete arg2;
36569 }
36570 return resultobj;
36571 fail:
36572 {
36573 if (temp2)
36574 delete arg2;
36575 }
36576 return NULL;
36577 }
36578
36579
36580 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36581 PyObject *resultobj = 0;
36582 wxWindow *arg1 = (wxWindow *) 0 ;
36583 wxEvtHandler *result = 0 ;
36584 void *argp1 = 0 ;
36585 int res1 = 0 ;
36586 PyObject *swig_obj[1] ;
36587
36588 if (!args) SWIG_fail;
36589 swig_obj[0] = args;
36590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36591 if (!SWIG_IsOK(res1)) {
36592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 {
36596 PyThreadState* __tstate = wxPyBeginAllowThreads();
36597 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36598 wxPyEndAllowThreads(__tstate);
36599 if (PyErr_Occurred()) SWIG_fail;
36600 }
36601 {
36602 resultobj = wxPyMake_wxObject(result, 0);
36603 }
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36614 void *argp1 = 0 ;
36615 int res1 = 0 ;
36616 void *argp2 = 0 ;
36617 int res2 = 0 ;
36618 PyObject * obj0 = 0 ;
36619 PyObject * obj1 = 0 ;
36620 char * kwnames[] = {
36621 (char *) "self",(char *) "handler", NULL
36622 };
36623
36624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36626 if (!SWIG_IsOK(res1)) {
36627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36628 }
36629 arg1 = reinterpret_cast< wxWindow * >(argp1);
36630 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36631 if (!SWIG_IsOK(res2)) {
36632 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36633 }
36634 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36635 {
36636 PyThreadState* __tstate = wxPyBeginAllowThreads();
36637 (arg1)->SetEventHandler(arg2);
36638 wxPyEndAllowThreads(__tstate);
36639 if (PyErr_Occurred()) SWIG_fail;
36640 }
36641 resultobj = SWIG_Py_Void();
36642 return resultobj;
36643 fail:
36644 return NULL;
36645 }
36646
36647
36648 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36649 PyObject *resultobj = 0;
36650 wxWindow *arg1 = (wxWindow *) 0 ;
36651 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36652 void *argp1 = 0 ;
36653 int res1 = 0 ;
36654 void *argp2 = 0 ;
36655 int res2 = 0 ;
36656 PyObject * obj0 = 0 ;
36657 PyObject * obj1 = 0 ;
36658 char * kwnames[] = {
36659 (char *) "self",(char *) "handler", NULL
36660 };
36661
36662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36663 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36664 if (!SWIG_IsOK(res1)) {
36665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36666 }
36667 arg1 = reinterpret_cast< wxWindow * >(argp1);
36668 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36669 if (!SWIG_IsOK(res2)) {
36670 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36671 }
36672 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36673 {
36674 PyThreadState* __tstate = wxPyBeginAllowThreads();
36675 (arg1)->PushEventHandler(arg2);
36676 wxPyEndAllowThreads(__tstate);
36677 if (PyErr_Occurred()) SWIG_fail;
36678 }
36679 resultobj = SWIG_Py_Void();
36680 return resultobj;
36681 fail:
36682 return NULL;
36683 }
36684
36685
36686 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36687 PyObject *resultobj = 0;
36688 wxWindow *arg1 = (wxWindow *) 0 ;
36689 bool arg2 = (bool) false ;
36690 wxEvtHandler *result = 0 ;
36691 void *argp1 = 0 ;
36692 int res1 = 0 ;
36693 bool val2 ;
36694 int ecode2 = 0 ;
36695 PyObject * obj0 = 0 ;
36696 PyObject * obj1 = 0 ;
36697 char * kwnames[] = {
36698 (char *) "self",(char *) "deleteHandler", NULL
36699 };
36700
36701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36703 if (!SWIG_IsOK(res1)) {
36704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36705 }
36706 arg1 = reinterpret_cast< wxWindow * >(argp1);
36707 if (obj1) {
36708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36709 if (!SWIG_IsOK(ecode2)) {
36710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36711 }
36712 arg2 = static_cast< bool >(val2);
36713 }
36714 {
36715 PyThreadState* __tstate = wxPyBeginAllowThreads();
36716 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36717 wxPyEndAllowThreads(__tstate);
36718 if (PyErr_Occurred()) SWIG_fail;
36719 }
36720 {
36721 resultobj = wxPyMake_wxObject(result, 0);
36722 }
36723 return resultobj;
36724 fail:
36725 return NULL;
36726 }
36727
36728
36729 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36730 PyObject *resultobj = 0;
36731 wxWindow *arg1 = (wxWindow *) 0 ;
36732 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36733 bool result;
36734 void *argp1 = 0 ;
36735 int res1 = 0 ;
36736 void *argp2 = 0 ;
36737 int res2 = 0 ;
36738 PyObject * obj0 = 0 ;
36739 PyObject * obj1 = 0 ;
36740 char * kwnames[] = {
36741 (char *) "self",(char *) "handler", NULL
36742 };
36743
36744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36746 if (!SWIG_IsOK(res1)) {
36747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36748 }
36749 arg1 = reinterpret_cast< wxWindow * >(argp1);
36750 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36751 if (!SWIG_IsOK(res2)) {
36752 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36753 }
36754 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36755 {
36756 PyThreadState* __tstate = wxPyBeginAllowThreads();
36757 result = (bool)(arg1)->RemoveEventHandler(arg2);
36758 wxPyEndAllowThreads(__tstate);
36759 if (PyErr_Occurred()) SWIG_fail;
36760 }
36761 {
36762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36763 }
36764 return resultobj;
36765 fail:
36766 return NULL;
36767 }
36768
36769
36770 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36771 PyObject *resultobj = 0;
36772 wxWindow *arg1 = (wxWindow *) 0 ;
36773 wxValidator *arg2 = 0 ;
36774 void *argp1 = 0 ;
36775 int res1 = 0 ;
36776 void *argp2 = 0 ;
36777 int res2 = 0 ;
36778 PyObject * obj0 = 0 ;
36779 PyObject * obj1 = 0 ;
36780 char * kwnames[] = {
36781 (char *) "self",(char *) "validator", NULL
36782 };
36783
36784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
36785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36786 if (!SWIG_IsOK(res1)) {
36787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36788 }
36789 arg1 = reinterpret_cast< wxWindow * >(argp1);
36790 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
36791 if (!SWIG_IsOK(res2)) {
36792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36793 }
36794 if (!argp2) {
36795 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
36796 }
36797 arg2 = reinterpret_cast< wxValidator * >(argp2);
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 (arg1)->SetValidator((wxValidator const &)*arg2);
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 resultobj = SWIG_Py_Void();
36805 return resultobj;
36806 fail:
36807 return NULL;
36808 }
36809
36810
36811 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36812 PyObject *resultobj = 0;
36813 wxWindow *arg1 = (wxWindow *) 0 ;
36814 wxValidator *result = 0 ;
36815 void *argp1 = 0 ;
36816 int res1 = 0 ;
36817 PyObject *swig_obj[1] ;
36818
36819 if (!args) SWIG_fail;
36820 swig_obj[0] = args;
36821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36822 if (!SWIG_IsOK(res1)) {
36823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
36824 }
36825 arg1 = reinterpret_cast< wxWindow * >(argp1);
36826 {
36827 PyThreadState* __tstate = wxPyBeginAllowThreads();
36828 result = (wxValidator *)(arg1)->GetValidator();
36829 wxPyEndAllowThreads(__tstate);
36830 if (PyErr_Occurred()) SWIG_fail;
36831 }
36832 {
36833 resultobj = wxPyMake_wxObject(result, (bool)0);
36834 }
36835 return resultobj;
36836 fail:
36837 return NULL;
36838 }
36839
36840
36841 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36842 PyObject *resultobj = 0;
36843 wxWindow *arg1 = (wxWindow *) 0 ;
36844 bool result;
36845 void *argp1 = 0 ;
36846 int res1 = 0 ;
36847 PyObject *swig_obj[1] ;
36848
36849 if (!args) SWIG_fail;
36850 swig_obj[0] = args;
36851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36852 if (!SWIG_IsOK(res1)) {
36853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
36854 }
36855 arg1 = reinterpret_cast< wxWindow * >(argp1);
36856 {
36857 PyThreadState* __tstate = wxPyBeginAllowThreads();
36858 result = (bool)(arg1)->Validate();
36859 wxPyEndAllowThreads(__tstate);
36860 if (PyErr_Occurred()) SWIG_fail;
36861 }
36862 {
36863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36864 }
36865 return resultobj;
36866 fail:
36867 return NULL;
36868 }
36869
36870
36871 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36872 PyObject *resultobj = 0;
36873 wxWindow *arg1 = (wxWindow *) 0 ;
36874 bool result;
36875 void *argp1 = 0 ;
36876 int res1 = 0 ;
36877 PyObject *swig_obj[1] ;
36878
36879 if (!args) SWIG_fail;
36880 swig_obj[0] = args;
36881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36882 if (!SWIG_IsOK(res1)) {
36883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36884 }
36885 arg1 = reinterpret_cast< wxWindow * >(argp1);
36886 {
36887 PyThreadState* __tstate = wxPyBeginAllowThreads();
36888 result = (bool)(arg1)->TransferDataToWindow();
36889 wxPyEndAllowThreads(__tstate);
36890 if (PyErr_Occurred()) SWIG_fail;
36891 }
36892 {
36893 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36894 }
36895 return resultobj;
36896 fail:
36897 return NULL;
36898 }
36899
36900
36901 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36902 PyObject *resultobj = 0;
36903 wxWindow *arg1 = (wxWindow *) 0 ;
36904 bool result;
36905 void *argp1 = 0 ;
36906 int res1 = 0 ;
36907 PyObject *swig_obj[1] ;
36908
36909 if (!args) SWIG_fail;
36910 swig_obj[0] = args;
36911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36912 if (!SWIG_IsOK(res1)) {
36913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36914 }
36915 arg1 = reinterpret_cast< wxWindow * >(argp1);
36916 {
36917 PyThreadState* __tstate = wxPyBeginAllowThreads();
36918 result = (bool)(arg1)->TransferDataFromWindow();
36919 wxPyEndAllowThreads(__tstate);
36920 if (PyErr_Occurred()) SWIG_fail;
36921 }
36922 {
36923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36924 }
36925 return resultobj;
36926 fail:
36927 return NULL;
36928 }
36929
36930
36931 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36932 PyObject *resultobj = 0;
36933 wxWindow *arg1 = (wxWindow *) 0 ;
36934 void *argp1 = 0 ;
36935 int res1 = 0 ;
36936 PyObject *swig_obj[1] ;
36937
36938 if (!args) SWIG_fail;
36939 swig_obj[0] = args;
36940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36941 if (!SWIG_IsOK(res1)) {
36942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
36943 }
36944 arg1 = reinterpret_cast< wxWindow * >(argp1);
36945 {
36946 PyThreadState* __tstate = wxPyBeginAllowThreads();
36947 (arg1)->InitDialog();
36948 wxPyEndAllowThreads(__tstate);
36949 if (PyErr_Occurred()) SWIG_fail;
36950 }
36951 resultobj = SWIG_Py_Void();
36952 return resultobj;
36953 fail:
36954 return NULL;
36955 }
36956
36957
36958 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36959 PyObject *resultobj = 0;
36960 wxWindow *arg1 = (wxWindow *) 0 ;
36961 wxAcceleratorTable *arg2 = 0 ;
36962 void *argp1 = 0 ;
36963 int res1 = 0 ;
36964 void *argp2 = 0 ;
36965 int res2 = 0 ;
36966 PyObject * obj0 = 0 ;
36967 PyObject * obj1 = 0 ;
36968 char * kwnames[] = {
36969 (char *) "self",(char *) "accel", NULL
36970 };
36971
36972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
36973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36974 if (!SWIG_IsOK(res1)) {
36975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
36976 }
36977 arg1 = reinterpret_cast< wxWindow * >(argp1);
36978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
36979 if (!SWIG_IsOK(res2)) {
36980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36981 }
36982 if (!argp2) {
36983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
36984 }
36985 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
36986 {
36987 PyThreadState* __tstate = wxPyBeginAllowThreads();
36988 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
36989 wxPyEndAllowThreads(__tstate);
36990 if (PyErr_Occurred()) SWIG_fail;
36991 }
36992 resultobj = SWIG_Py_Void();
36993 return resultobj;
36994 fail:
36995 return NULL;
36996 }
36997
36998
36999 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37000 PyObject *resultobj = 0;
37001 wxWindow *arg1 = (wxWindow *) 0 ;
37002 wxAcceleratorTable *result = 0 ;
37003 void *argp1 = 0 ;
37004 int res1 = 0 ;
37005 PyObject *swig_obj[1] ;
37006
37007 if (!args) SWIG_fail;
37008 swig_obj[0] = args;
37009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37010 if (!SWIG_IsOK(res1)) {
37011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37012 }
37013 arg1 = reinterpret_cast< wxWindow * >(argp1);
37014 {
37015 PyThreadState* __tstate = wxPyBeginAllowThreads();
37016 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37017 wxPyEndAllowThreads(__tstate);
37018 if (PyErr_Occurred()) SWIG_fail;
37019 }
37020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37021 return resultobj;
37022 fail:
37023 return NULL;
37024 }
37025
37026
37027 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37028 PyObject *resultobj = 0;
37029 wxWindow *arg1 = (wxWindow *) 0 ;
37030 int arg2 ;
37031 int arg3 ;
37032 int arg4 ;
37033 bool result;
37034 void *argp1 = 0 ;
37035 int res1 = 0 ;
37036 int val2 ;
37037 int ecode2 = 0 ;
37038 int val3 ;
37039 int ecode3 = 0 ;
37040 int val4 ;
37041 int ecode4 = 0 ;
37042 PyObject * obj0 = 0 ;
37043 PyObject * obj1 = 0 ;
37044 PyObject * obj2 = 0 ;
37045 PyObject * obj3 = 0 ;
37046 char * kwnames[] = {
37047 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37048 };
37049
37050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37052 if (!SWIG_IsOK(res1)) {
37053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37054 }
37055 arg1 = reinterpret_cast< wxWindow * >(argp1);
37056 ecode2 = SWIG_AsVal_int(obj1, &val2);
37057 if (!SWIG_IsOK(ecode2)) {
37058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37059 }
37060 arg2 = static_cast< int >(val2);
37061 ecode3 = SWIG_AsVal_int(obj2, &val3);
37062 if (!SWIG_IsOK(ecode3)) {
37063 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37064 }
37065 arg3 = static_cast< int >(val3);
37066 ecode4 = SWIG_AsVal_int(obj3, &val4);
37067 if (!SWIG_IsOK(ecode4)) {
37068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37069 }
37070 arg4 = static_cast< int >(val4);
37071 {
37072 PyThreadState* __tstate = wxPyBeginAllowThreads();
37073 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37074 wxPyEndAllowThreads(__tstate);
37075 if (PyErr_Occurred()) SWIG_fail;
37076 }
37077 {
37078 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37079 }
37080 return resultobj;
37081 fail:
37082 return NULL;
37083 }
37084
37085
37086 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37087 PyObject *resultobj = 0;
37088 wxWindow *arg1 = (wxWindow *) 0 ;
37089 int arg2 ;
37090 bool result;
37091 void *argp1 = 0 ;
37092 int res1 = 0 ;
37093 int val2 ;
37094 int ecode2 = 0 ;
37095 PyObject * obj0 = 0 ;
37096 PyObject * obj1 = 0 ;
37097 char * kwnames[] = {
37098 (char *) "self",(char *) "hotkeyId", NULL
37099 };
37100
37101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37103 if (!SWIG_IsOK(res1)) {
37104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37105 }
37106 arg1 = reinterpret_cast< wxWindow * >(argp1);
37107 ecode2 = SWIG_AsVal_int(obj1, &val2);
37108 if (!SWIG_IsOK(ecode2)) {
37109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37110 }
37111 arg2 = static_cast< int >(val2);
37112 {
37113 PyThreadState* __tstate = wxPyBeginAllowThreads();
37114 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37115 wxPyEndAllowThreads(__tstate);
37116 if (PyErr_Occurred()) SWIG_fail;
37117 }
37118 {
37119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37120 }
37121 return resultobj;
37122 fail:
37123 return NULL;
37124 }
37125
37126
37127 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37128 PyObject *resultobj = 0;
37129 wxWindow *arg1 = (wxWindow *) 0 ;
37130 wxPoint *arg2 = 0 ;
37131 wxPoint result;
37132 void *argp1 = 0 ;
37133 int res1 = 0 ;
37134 wxPoint temp2 ;
37135 PyObject * obj0 = 0 ;
37136 PyObject * obj1 = 0 ;
37137 char * kwnames[] = {
37138 (char *) "self",(char *) "pt", NULL
37139 };
37140
37141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37143 if (!SWIG_IsOK(res1)) {
37144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37145 }
37146 arg1 = reinterpret_cast< wxWindow * >(argp1);
37147 {
37148 arg2 = &temp2;
37149 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37150 }
37151 {
37152 PyThreadState* __tstate = wxPyBeginAllowThreads();
37153 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37154 wxPyEndAllowThreads(__tstate);
37155 if (PyErr_Occurred()) SWIG_fail;
37156 }
37157 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37158 return resultobj;
37159 fail:
37160 return NULL;
37161 }
37162
37163
37164 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37165 PyObject *resultobj = 0;
37166 wxWindow *arg1 = (wxWindow *) 0 ;
37167 wxSize *arg2 = 0 ;
37168 wxSize result;
37169 void *argp1 = 0 ;
37170 int res1 = 0 ;
37171 wxSize temp2 ;
37172 PyObject * obj0 = 0 ;
37173 PyObject * obj1 = 0 ;
37174 char * kwnames[] = {
37175 (char *) "self",(char *) "sz", NULL
37176 };
37177
37178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37180 if (!SWIG_IsOK(res1)) {
37181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37182 }
37183 arg1 = reinterpret_cast< wxWindow * >(argp1);
37184 {
37185 arg2 = &temp2;
37186 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37187 }
37188 {
37189 PyThreadState* __tstate = wxPyBeginAllowThreads();
37190 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37191 wxPyEndAllowThreads(__tstate);
37192 if (PyErr_Occurred()) SWIG_fail;
37193 }
37194 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37195 return resultobj;
37196 fail:
37197 return NULL;
37198 }
37199
37200
37201 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37202 PyObject *resultobj = 0;
37203 wxWindow *arg1 = (wxWindow *) 0 ;
37204 wxPoint *arg2 = 0 ;
37205 wxPoint result;
37206 void *argp1 = 0 ;
37207 int res1 = 0 ;
37208 wxPoint temp2 ;
37209 PyObject * obj0 = 0 ;
37210 PyObject * obj1 = 0 ;
37211 char * kwnames[] = {
37212 (char *) "self",(char *) "pt", NULL
37213 };
37214
37215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37217 if (!SWIG_IsOK(res1)) {
37218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37219 }
37220 arg1 = reinterpret_cast< wxWindow * >(argp1);
37221 {
37222 arg2 = &temp2;
37223 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37224 }
37225 {
37226 PyThreadState* __tstate = wxPyBeginAllowThreads();
37227 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37232 return resultobj;
37233 fail:
37234 return NULL;
37235 }
37236
37237
37238 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37239 PyObject *resultobj = 0;
37240 wxWindow *arg1 = (wxWindow *) 0 ;
37241 wxSize *arg2 = 0 ;
37242 wxSize result;
37243 void *argp1 = 0 ;
37244 int res1 = 0 ;
37245 wxSize temp2 ;
37246 PyObject * obj0 = 0 ;
37247 PyObject * obj1 = 0 ;
37248 char * kwnames[] = {
37249 (char *) "self",(char *) "sz", NULL
37250 };
37251
37252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37254 if (!SWIG_IsOK(res1)) {
37255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37256 }
37257 arg1 = reinterpret_cast< wxWindow * >(argp1);
37258 {
37259 arg2 = &temp2;
37260 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37261 }
37262 {
37263 PyThreadState* __tstate = wxPyBeginAllowThreads();
37264 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37265 wxPyEndAllowThreads(__tstate);
37266 if (PyErr_Occurred()) SWIG_fail;
37267 }
37268 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37269 return resultobj;
37270 fail:
37271 return NULL;
37272 }
37273
37274
37275 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37276 PyObject *resultobj = 0;
37277 wxWindow *arg1 = (wxWindow *) 0 ;
37278 wxPoint *arg2 = 0 ;
37279 wxPoint result;
37280 void *argp1 = 0 ;
37281 int res1 = 0 ;
37282 wxPoint temp2 ;
37283 PyObject * obj0 = 0 ;
37284 PyObject * obj1 = 0 ;
37285 char * kwnames[] = {
37286 (char *) "self",(char *) "pt", NULL
37287 };
37288
37289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37291 if (!SWIG_IsOK(res1)) {
37292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37293 }
37294 arg1 = reinterpret_cast< wxWindow * >(argp1);
37295 {
37296 arg2 = &temp2;
37297 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37298 }
37299 {
37300 PyThreadState* __tstate = wxPyBeginAllowThreads();
37301 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37302 wxPyEndAllowThreads(__tstate);
37303 if (PyErr_Occurred()) SWIG_fail;
37304 }
37305 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37306 return resultobj;
37307 fail:
37308 return NULL;
37309 }
37310
37311
37312 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37313 PyObject *resultobj = 0;
37314 wxWindow *arg1 = (wxWindow *) 0 ;
37315 wxSize *arg2 = 0 ;
37316 wxSize result;
37317 void *argp1 = 0 ;
37318 int res1 = 0 ;
37319 wxSize temp2 ;
37320 PyObject * obj0 = 0 ;
37321 PyObject * obj1 = 0 ;
37322 char * kwnames[] = {
37323 (char *) "self",(char *) "sz", NULL
37324 };
37325
37326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37328 if (!SWIG_IsOK(res1)) {
37329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37330 }
37331 arg1 = reinterpret_cast< wxWindow * >(argp1);
37332 {
37333 arg2 = &temp2;
37334 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37335 }
37336 {
37337 PyThreadState* __tstate = wxPyBeginAllowThreads();
37338 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37339 wxPyEndAllowThreads(__tstate);
37340 if (PyErr_Occurred()) SWIG_fail;
37341 }
37342 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37343 return resultobj;
37344 fail:
37345 return NULL;
37346 }
37347
37348
37349 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37350 PyObject *resultobj = 0;
37351 wxWindow *arg1 = (wxWindow *) 0 ;
37352 int arg2 ;
37353 int arg3 ;
37354 void *argp1 = 0 ;
37355 int res1 = 0 ;
37356 int val2 ;
37357 int ecode2 = 0 ;
37358 int val3 ;
37359 int ecode3 = 0 ;
37360 PyObject * obj0 = 0 ;
37361 PyObject * obj1 = 0 ;
37362 PyObject * obj2 = 0 ;
37363 char * kwnames[] = {
37364 (char *) "self",(char *) "x",(char *) "y", NULL
37365 };
37366
37367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37369 if (!SWIG_IsOK(res1)) {
37370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37371 }
37372 arg1 = reinterpret_cast< wxWindow * >(argp1);
37373 ecode2 = SWIG_AsVal_int(obj1, &val2);
37374 if (!SWIG_IsOK(ecode2)) {
37375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37376 }
37377 arg2 = static_cast< int >(val2);
37378 ecode3 = SWIG_AsVal_int(obj2, &val3);
37379 if (!SWIG_IsOK(ecode3)) {
37380 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37381 }
37382 arg3 = static_cast< int >(val3);
37383 {
37384 PyThreadState* __tstate = wxPyBeginAllowThreads();
37385 (arg1)->WarpPointer(arg2,arg3);
37386 wxPyEndAllowThreads(__tstate);
37387 if (PyErr_Occurred()) SWIG_fail;
37388 }
37389 resultobj = SWIG_Py_Void();
37390 return resultobj;
37391 fail:
37392 return NULL;
37393 }
37394
37395
37396 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37397 PyObject *resultobj = 0;
37398 wxWindow *arg1 = (wxWindow *) 0 ;
37399 void *argp1 = 0 ;
37400 int res1 = 0 ;
37401 PyObject *swig_obj[1] ;
37402
37403 if (!args) SWIG_fail;
37404 swig_obj[0] = args;
37405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37406 if (!SWIG_IsOK(res1)) {
37407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37408 }
37409 arg1 = reinterpret_cast< wxWindow * >(argp1);
37410 {
37411 PyThreadState* __tstate = wxPyBeginAllowThreads();
37412 (arg1)->CaptureMouse();
37413 wxPyEndAllowThreads(__tstate);
37414 if (PyErr_Occurred()) SWIG_fail;
37415 }
37416 resultobj = SWIG_Py_Void();
37417 return resultobj;
37418 fail:
37419 return NULL;
37420 }
37421
37422
37423 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37424 PyObject *resultobj = 0;
37425 wxWindow *arg1 = (wxWindow *) 0 ;
37426 void *argp1 = 0 ;
37427 int res1 = 0 ;
37428 PyObject *swig_obj[1] ;
37429
37430 if (!args) SWIG_fail;
37431 swig_obj[0] = args;
37432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37433 if (!SWIG_IsOK(res1)) {
37434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37435 }
37436 arg1 = reinterpret_cast< wxWindow * >(argp1);
37437 {
37438 PyThreadState* __tstate = wxPyBeginAllowThreads();
37439 (arg1)->ReleaseMouse();
37440 wxPyEndAllowThreads(__tstate);
37441 if (PyErr_Occurred()) SWIG_fail;
37442 }
37443 resultobj = SWIG_Py_Void();
37444 return resultobj;
37445 fail:
37446 return NULL;
37447 }
37448
37449
37450 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37451 PyObject *resultobj = 0;
37452 wxWindow *result = 0 ;
37453
37454 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37455 {
37456 if (!wxPyCheckForApp()) SWIG_fail;
37457 PyThreadState* __tstate = wxPyBeginAllowThreads();
37458 result = (wxWindow *)wxWindow::GetCapture();
37459 wxPyEndAllowThreads(__tstate);
37460 if (PyErr_Occurred()) SWIG_fail;
37461 }
37462 {
37463 resultobj = wxPyMake_wxObject(result, 0);
37464 }
37465 return resultobj;
37466 fail:
37467 return NULL;
37468 }
37469
37470
37471 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37472 PyObject *resultobj = 0;
37473 wxWindow *arg1 = (wxWindow *) 0 ;
37474 bool result;
37475 void *argp1 = 0 ;
37476 int res1 = 0 ;
37477 PyObject *swig_obj[1] ;
37478
37479 if (!args) SWIG_fail;
37480 swig_obj[0] = args;
37481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37482 if (!SWIG_IsOK(res1)) {
37483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37484 }
37485 arg1 = reinterpret_cast< wxWindow * >(argp1);
37486 {
37487 PyThreadState* __tstate = wxPyBeginAllowThreads();
37488 result = (bool)((wxWindow const *)arg1)->HasCapture();
37489 wxPyEndAllowThreads(__tstate);
37490 if (PyErr_Occurred()) SWIG_fail;
37491 }
37492 {
37493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37494 }
37495 return resultobj;
37496 fail:
37497 return NULL;
37498 }
37499
37500
37501 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37502 PyObject *resultobj = 0;
37503 wxWindow *arg1 = (wxWindow *) 0 ;
37504 bool arg2 = (bool) true ;
37505 wxRect *arg3 = (wxRect *) NULL ;
37506 void *argp1 = 0 ;
37507 int res1 = 0 ;
37508 bool val2 ;
37509 int ecode2 = 0 ;
37510 void *argp3 = 0 ;
37511 int res3 = 0 ;
37512 PyObject * obj0 = 0 ;
37513 PyObject * obj1 = 0 ;
37514 PyObject * obj2 = 0 ;
37515 char * kwnames[] = {
37516 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37517 };
37518
37519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37521 if (!SWIG_IsOK(res1)) {
37522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37523 }
37524 arg1 = reinterpret_cast< wxWindow * >(argp1);
37525 if (obj1) {
37526 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37527 if (!SWIG_IsOK(ecode2)) {
37528 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37529 }
37530 arg2 = static_cast< bool >(val2);
37531 }
37532 if (obj2) {
37533 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37534 if (!SWIG_IsOK(res3)) {
37535 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37536 }
37537 arg3 = reinterpret_cast< wxRect * >(argp3);
37538 }
37539 {
37540 PyThreadState* __tstate = wxPyBeginAllowThreads();
37541 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37542 wxPyEndAllowThreads(__tstate);
37543 if (PyErr_Occurred()) SWIG_fail;
37544 }
37545 resultobj = SWIG_Py_Void();
37546 return resultobj;
37547 fail:
37548 return NULL;
37549 }
37550
37551
37552 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37553 PyObject *resultobj = 0;
37554 wxWindow *arg1 = (wxWindow *) 0 ;
37555 wxRect *arg2 = 0 ;
37556 bool arg3 = (bool) true ;
37557 void *argp1 = 0 ;
37558 int res1 = 0 ;
37559 wxRect temp2 ;
37560 bool val3 ;
37561 int ecode3 = 0 ;
37562 PyObject * obj0 = 0 ;
37563 PyObject * obj1 = 0 ;
37564 PyObject * obj2 = 0 ;
37565 char * kwnames[] = {
37566 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37567 };
37568
37569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37571 if (!SWIG_IsOK(res1)) {
37572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37573 }
37574 arg1 = reinterpret_cast< wxWindow * >(argp1);
37575 {
37576 arg2 = &temp2;
37577 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37578 }
37579 if (obj2) {
37580 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37581 if (!SWIG_IsOK(ecode3)) {
37582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37583 }
37584 arg3 = static_cast< bool >(val3);
37585 }
37586 {
37587 PyThreadState* __tstate = wxPyBeginAllowThreads();
37588 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37589 wxPyEndAllowThreads(__tstate);
37590 if (PyErr_Occurred()) SWIG_fail;
37591 }
37592 resultobj = SWIG_Py_Void();
37593 return resultobj;
37594 fail:
37595 return NULL;
37596 }
37597
37598
37599 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37600 PyObject *resultobj = 0;
37601 wxWindow *arg1 = (wxWindow *) 0 ;
37602 void *argp1 = 0 ;
37603 int res1 = 0 ;
37604 PyObject *swig_obj[1] ;
37605
37606 if (!args) SWIG_fail;
37607 swig_obj[0] = args;
37608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37609 if (!SWIG_IsOK(res1)) {
37610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37611 }
37612 arg1 = reinterpret_cast< wxWindow * >(argp1);
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 (arg1)->Update();
37616 wxPyEndAllowThreads(__tstate);
37617 if (PyErr_Occurred()) SWIG_fail;
37618 }
37619 resultobj = SWIG_Py_Void();
37620 return resultobj;
37621 fail:
37622 return NULL;
37623 }
37624
37625
37626 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37627 PyObject *resultobj = 0;
37628 wxWindow *arg1 = (wxWindow *) 0 ;
37629 void *argp1 = 0 ;
37630 int res1 = 0 ;
37631 PyObject *swig_obj[1] ;
37632
37633 if (!args) SWIG_fail;
37634 swig_obj[0] = args;
37635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37636 if (!SWIG_IsOK(res1)) {
37637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37638 }
37639 arg1 = reinterpret_cast< wxWindow * >(argp1);
37640 {
37641 PyThreadState* __tstate = wxPyBeginAllowThreads();
37642 (arg1)->ClearBackground();
37643 wxPyEndAllowThreads(__tstate);
37644 if (PyErr_Occurred()) SWIG_fail;
37645 }
37646 resultobj = SWIG_Py_Void();
37647 return resultobj;
37648 fail:
37649 return NULL;
37650 }
37651
37652
37653 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37654 PyObject *resultobj = 0;
37655 wxWindow *arg1 = (wxWindow *) 0 ;
37656 void *argp1 = 0 ;
37657 int res1 = 0 ;
37658 PyObject *swig_obj[1] ;
37659
37660 if (!args) SWIG_fail;
37661 swig_obj[0] = args;
37662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37663 if (!SWIG_IsOK(res1)) {
37664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37665 }
37666 arg1 = reinterpret_cast< wxWindow * >(argp1);
37667 {
37668 PyThreadState* __tstate = wxPyBeginAllowThreads();
37669 (arg1)->Freeze();
37670 wxPyEndAllowThreads(__tstate);
37671 if (PyErr_Occurred()) SWIG_fail;
37672 }
37673 resultobj = SWIG_Py_Void();
37674 return resultobj;
37675 fail:
37676 return NULL;
37677 }
37678
37679
37680 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37681 PyObject *resultobj = 0;
37682 wxWindow *arg1 = (wxWindow *) 0 ;
37683 bool result;
37684 void *argp1 = 0 ;
37685 int res1 = 0 ;
37686 PyObject *swig_obj[1] ;
37687
37688 if (!args) SWIG_fail;
37689 swig_obj[0] = args;
37690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37691 if (!SWIG_IsOK(res1)) {
37692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37693 }
37694 arg1 = reinterpret_cast< wxWindow * >(argp1);
37695 {
37696 PyThreadState* __tstate = wxPyBeginAllowThreads();
37697 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37698 wxPyEndAllowThreads(__tstate);
37699 if (PyErr_Occurred()) SWIG_fail;
37700 }
37701 {
37702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37703 }
37704 return resultobj;
37705 fail:
37706 return NULL;
37707 }
37708
37709
37710 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37711 PyObject *resultobj = 0;
37712 wxWindow *arg1 = (wxWindow *) 0 ;
37713 void *argp1 = 0 ;
37714 int res1 = 0 ;
37715 PyObject *swig_obj[1] ;
37716
37717 if (!args) SWIG_fail;
37718 swig_obj[0] = args;
37719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37720 if (!SWIG_IsOK(res1)) {
37721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37722 }
37723 arg1 = reinterpret_cast< wxWindow * >(argp1);
37724 {
37725 PyThreadState* __tstate = wxPyBeginAllowThreads();
37726 (arg1)->Thaw();
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 resultobj = SWIG_Py_Void();
37731 return resultobj;
37732 fail:
37733 return NULL;
37734 }
37735
37736
37737 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37738 PyObject *resultobj = 0;
37739 wxWindow *arg1 = (wxWindow *) 0 ;
37740 wxDC *arg2 = 0 ;
37741 void *argp1 = 0 ;
37742 int res1 = 0 ;
37743 void *argp2 = 0 ;
37744 int res2 = 0 ;
37745 PyObject * obj0 = 0 ;
37746 PyObject * obj1 = 0 ;
37747 char * kwnames[] = {
37748 (char *) "self",(char *) "dc", NULL
37749 };
37750
37751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37753 if (!SWIG_IsOK(res1)) {
37754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37755 }
37756 arg1 = reinterpret_cast< wxWindow * >(argp1);
37757 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37758 if (!SWIG_IsOK(res2)) {
37759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37760 }
37761 if (!argp2) {
37762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37763 }
37764 arg2 = reinterpret_cast< wxDC * >(argp2);
37765 {
37766 PyThreadState* __tstate = wxPyBeginAllowThreads();
37767 (arg1)->PrepareDC(*arg2);
37768 wxPyEndAllowThreads(__tstate);
37769 if (PyErr_Occurred()) SWIG_fail;
37770 }
37771 resultobj = SWIG_Py_Void();
37772 return resultobj;
37773 fail:
37774 return NULL;
37775 }
37776
37777
37778 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37779 PyObject *resultobj = 0;
37780 wxWindow *arg1 = (wxWindow *) 0 ;
37781 bool result;
37782 void *argp1 = 0 ;
37783 int res1 = 0 ;
37784 PyObject *swig_obj[1] ;
37785
37786 if (!args) SWIG_fail;
37787 swig_obj[0] = args;
37788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37789 if (!SWIG_IsOK(res1)) {
37790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
37791 }
37792 arg1 = reinterpret_cast< wxWindow * >(argp1);
37793 {
37794 PyThreadState* __tstate = wxPyBeginAllowThreads();
37795 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
37796 wxPyEndAllowThreads(__tstate);
37797 if (PyErr_Occurred()) SWIG_fail;
37798 }
37799 {
37800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37801 }
37802 return resultobj;
37803 fail:
37804 return NULL;
37805 }
37806
37807
37808 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37809 PyObject *resultobj = 0;
37810 wxWindow *arg1 = (wxWindow *) 0 ;
37811 wxRegion *result = 0 ;
37812 void *argp1 = 0 ;
37813 int res1 = 0 ;
37814 PyObject *swig_obj[1] ;
37815
37816 if (!args) SWIG_fail;
37817 swig_obj[0] = args;
37818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37819 if (!SWIG_IsOK(res1)) {
37820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
37821 }
37822 arg1 = reinterpret_cast< wxWindow * >(argp1);
37823 {
37824 PyThreadState* __tstate = wxPyBeginAllowThreads();
37825 {
37826 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
37827 result = (wxRegion *) &_result_ref;
37828 }
37829 wxPyEndAllowThreads(__tstate);
37830 if (PyErr_Occurred()) SWIG_fail;
37831 }
37832 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
37833 return resultobj;
37834 fail:
37835 return NULL;
37836 }
37837
37838
37839 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37840 PyObject *resultobj = 0;
37841 wxWindow *arg1 = (wxWindow *) 0 ;
37842 wxRect result;
37843 void *argp1 = 0 ;
37844 int res1 = 0 ;
37845 PyObject *swig_obj[1] ;
37846
37847 if (!args) SWIG_fail;
37848 swig_obj[0] = args;
37849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37850 if (!SWIG_IsOK(res1)) {
37851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37852 }
37853 arg1 = reinterpret_cast< wxWindow * >(argp1);
37854 {
37855 PyThreadState* __tstate = wxPyBeginAllowThreads();
37856 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
37857 wxPyEndAllowThreads(__tstate);
37858 if (PyErr_Occurred()) SWIG_fail;
37859 }
37860 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
37861 return resultobj;
37862 fail:
37863 return NULL;
37864 }
37865
37866
37867 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37868 PyObject *resultobj = 0;
37869 wxWindow *arg1 = (wxWindow *) 0 ;
37870 int arg2 ;
37871 int arg3 ;
37872 int arg4 = (int) 1 ;
37873 int arg5 = (int) 1 ;
37874 bool result;
37875 void *argp1 = 0 ;
37876 int res1 = 0 ;
37877 int val2 ;
37878 int ecode2 = 0 ;
37879 int val3 ;
37880 int ecode3 = 0 ;
37881 int val4 ;
37882 int ecode4 = 0 ;
37883 int val5 ;
37884 int ecode5 = 0 ;
37885 PyObject * obj0 = 0 ;
37886 PyObject * obj1 = 0 ;
37887 PyObject * obj2 = 0 ;
37888 PyObject * obj3 = 0 ;
37889 PyObject * obj4 = 0 ;
37890 char * kwnames[] = {
37891 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
37892 };
37893
37894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
37895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37896 if (!SWIG_IsOK(res1)) {
37897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
37898 }
37899 arg1 = reinterpret_cast< wxWindow * >(argp1);
37900 ecode2 = SWIG_AsVal_int(obj1, &val2);
37901 if (!SWIG_IsOK(ecode2)) {
37902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
37903 }
37904 arg2 = static_cast< int >(val2);
37905 ecode3 = SWIG_AsVal_int(obj2, &val3);
37906 if (!SWIG_IsOK(ecode3)) {
37907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
37908 }
37909 arg3 = static_cast< int >(val3);
37910 if (obj3) {
37911 ecode4 = SWIG_AsVal_int(obj3, &val4);
37912 if (!SWIG_IsOK(ecode4)) {
37913 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
37914 }
37915 arg4 = static_cast< int >(val4);
37916 }
37917 if (obj4) {
37918 ecode5 = SWIG_AsVal_int(obj4, &val5);
37919 if (!SWIG_IsOK(ecode5)) {
37920 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
37921 }
37922 arg5 = static_cast< int >(val5);
37923 }
37924 {
37925 PyThreadState* __tstate = wxPyBeginAllowThreads();
37926 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
37927 wxPyEndAllowThreads(__tstate);
37928 if (PyErr_Occurred()) SWIG_fail;
37929 }
37930 {
37931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37932 }
37933 return resultobj;
37934 fail:
37935 return NULL;
37936 }
37937
37938
37939 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37940 PyObject *resultobj = 0;
37941 wxWindow *arg1 = (wxWindow *) 0 ;
37942 wxPoint *arg2 = 0 ;
37943 bool result;
37944 void *argp1 = 0 ;
37945 int res1 = 0 ;
37946 wxPoint temp2 ;
37947 PyObject * obj0 = 0 ;
37948 PyObject * obj1 = 0 ;
37949 char * kwnames[] = {
37950 (char *) "self",(char *) "pt", NULL
37951 };
37952
37953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
37954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37955 if (!SWIG_IsOK(res1)) {
37956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
37957 }
37958 arg1 = reinterpret_cast< wxWindow * >(argp1);
37959 {
37960 arg2 = &temp2;
37961 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37962 }
37963 {
37964 PyThreadState* __tstate = wxPyBeginAllowThreads();
37965 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
37966 wxPyEndAllowThreads(__tstate);
37967 if (PyErr_Occurred()) SWIG_fail;
37968 }
37969 {
37970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37971 }
37972 return resultobj;
37973 fail:
37974 return NULL;
37975 }
37976
37977
37978 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37979 PyObject *resultobj = 0;
37980 wxWindow *arg1 = (wxWindow *) 0 ;
37981 wxRect *arg2 = 0 ;
37982 bool result;
37983 void *argp1 = 0 ;
37984 int res1 = 0 ;
37985 wxRect temp2 ;
37986 PyObject * obj0 = 0 ;
37987 PyObject * obj1 = 0 ;
37988 char * kwnames[] = {
37989 (char *) "self",(char *) "rect", NULL
37990 };
37991
37992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
37993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37994 if (!SWIG_IsOK(res1)) {
37995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
37996 }
37997 arg1 = reinterpret_cast< wxWindow * >(argp1);
37998 {
37999 arg2 = &temp2;
38000 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38001 }
38002 {
38003 PyThreadState* __tstate = wxPyBeginAllowThreads();
38004 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38005 wxPyEndAllowThreads(__tstate);
38006 if (PyErr_Occurred()) SWIG_fail;
38007 }
38008 {
38009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38010 }
38011 return resultobj;
38012 fail:
38013 return NULL;
38014 }
38015
38016
38017 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38018 PyObject *resultobj = 0;
38019 wxWindow *arg1 = (wxWindow *) 0 ;
38020 SwigValueWrapper<wxVisualAttributes > result;
38021 void *argp1 = 0 ;
38022 int res1 = 0 ;
38023 PyObject *swig_obj[1] ;
38024
38025 if (!args) SWIG_fail;
38026 swig_obj[0] = args;
38027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38028 if (!SWIG_IsOK(res1)) {
38029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38030 }
38031 arg1 = reinterpret_cast< wxWindow * >(argp1);
38032 {
38033 PyThreadState* __tstate = wxPyBeginAllowThreads();
38034 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38035 wxPyEndAllowThreads(__tstate);
38036 if (PyErr_Occurred()) SWIG_fail;
38037 }
38038 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38039 return resultobj;
38040 fail:
38041 return NULL;
38042 }
38043
38044
38045 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38046 PyObject *resultobj = 0;
38047 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38048 SwigValueWrapper<wxVisualAttributes > result;
38049 int val1 ;
38050 int ecode1 = 0 ;
38051 PyObject * obj0 = 0 ;
38052 char * kwnames[] = {
38053 (char *) "variant", NULL
38054 };
38055
38056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38057 if (obj0) {
38058 ecode1 = SWIG_AsVal_int(obj0, &val1);
38059 if (!SWIG_IsOK(ecode1)) {
38060 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38061 }
38062 arg1 = static_cast< wxWindowVariant >(val1);
38063 }
38064 {
38065 if (!wxPyCheckForApp()) SWIG_fail;
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 result = wxWindow::GetClassDefaultAttributes(arg1);
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38079 PyObject *resultobj = 0;
38080 wxWindow *arg1 = (wxWindow *) 0 ;
38081 wxColour *arg2 = 0 ;
38082 bool result;
38083 void *argp1 = 0 ;
38084 int res1 = 0 ;
38085 wxColour temp2 ;
38086 PyObject * obj0 = 0 ;
38087 PyObject * obj1 = 0 ;
38088 char * kwnames[] = {
38089 (char *) "self",(char *) "colour", NULL
38090 };
38091
38092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",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_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38096 }
38097 arg1 = reinterpret_cast< wxWindow * >(argp1);
38098 {
38099 arg2 = &temp2;
38100 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38101 }
38102 {
38103 PyThreadState* __tstate = wxPyBeginAllowThreads();
38104 result = (bool)(arg1)->SetBackgroundColour((wxColour 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_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38118 PyObject *resultobj = 0;
38119 wxWindow *arg1 = (wxWindow *) 0 ;
38120 wxColour *arg2 = 0 ;
38121 void *argp1 = 0 ;
38122 int res1 = 0 ;
38123 wxColour temp2 ;
38124 PyObject * obj0 = 0 ;
38125 PyObject * obj1 = 0 ;
38126 char * kwnames[] = {
38127 (char *) "self",(char *) "colour", NULL
38128 };
38129
38130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38132 if (!SWIG_IsOK(res1)) {
38133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38134 }
38135 arg1 = reinterpret_cast< wxWindow * >(argp1);
38136 {
38137 arg2 = &temp2;
38138 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38139 }
38140 {
38141 PyThreadState* __tstate = wxPyBeginAllowThreads();
38142 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38143 wxPyEndAllowThreads(__tstate);
38144 if (PyErr_Occurred()) SWIG_fail;
38145 }
38146 resultobj = SWIG_Py_Void();
38147 return resultobj;
38148 fail:
38149 return NULL;
38150 }
38151
38152
38153 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38154 PyObject *resultobj = 0;
38155 wxWindow *arg1 = (wxWindow *) 0 ;
38156 wxColour *arg2 = 0 ;
38157 bool result;
38158 void *argp1 = 0 ;
38159 int res1 = 0 ;
38160 wxColour temp2 ;
38161 PyObject * obj0 = 0 ;
38162 PyObject * obj1 = 0 ;
38163 char * kwnames[] = {
38164 (char *) "self",(char *) "colour", NULL
38165 };
38166
38167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38169 if (!SWIG_IsOK(res1)) {
38170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38171 }
38172 arg1 = reinterpret_cast< wxWindow * >(argp1);
38173 {
38174 arg2 = &temp2;
38175 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38176 }
38177 {
38178 PyThreadState* __tstate = wxPyBeginAllowThreads();
38179 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38180 wxPyEndAllowThreads(__tstate);
38181 if (PyErr_Occurred()) SWIG_fail;
38182 }
38183 {
38184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38185 }
38186 return resultobj;
38187 fail:
38188 return NULL;
38189 }
38190
38191
38192 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38193 PyObject *resultobj = 0;
38194 wxWindow *arg1 = (wxWindow *) 0 ;
38195 wxColour *arg2 = 0 ;
38196 void *argp1 = 0 ;
38197 int res1 = 0 ;
38198 wxColour temp2 ;
38199 PyObject * obj0 = 0 ;
38200 PyObject * obj1 = 0 ;
38201 char * kwnames[] = {
38202 (char *) "self",(char *) "colour", NULL
38203 };
38204
38205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38207 if (!SWIG_IsOK(res1)) {
38208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38209 }
38210 arg1 = reinterpret_cast< wxWindow * >(argp1);
38211 {
38212 arg2 = &temp2;
38213 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38214 }
38215 {
38216 PyThreadState* __tstate = wxPyBeginAllowThreads();
38217 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38218 wxPyEndAllowThreads(__tstate);
38219 if (PyErr_Occurred()) SWIG_fail;
38220 }
38221 resultobj = SWIG_Py_Void();
38222 return resultobj;
38223 fail:
38224 return NULL;
38225 }
38226
38227
38228 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38229 PyObject *resultobj = 0;
38230 wxWindow *arg1 = (wxWindow *) 0 ;
38231 wxColour result;
38232 void *argp1 = 0 ;
38233 int res1 = 0 ;
38234 PyObject *swig_obj[1] ;
38235
38236 if (!args) SWIG_fail;
38237 swig_obj[0] = args;
38238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38239 if (!SWIG_IsOK(res1)) {
38240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38241 }
38242 arg1 = reinterpret_cast< wxWindow * >(argp1);
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38250 return resultobj;
38251 fail:
38252 return NULL;
38253 }
38254
38255
38256 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38257 PyObject *resultobj = 0;
38258 wxWindow *arg1 = (wxWindow *) 0 ;
38259 wxColour result;
38260 void *argp1 = 0 ;
38261 int res1 = 0 ;
38262 PyObject *swig_obj[1] ;
38263
38264 if (!args) SWIG_fail;
38265 swig_obj[0] = args;
38266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38267 if (!SWIG_IsOK(res1)) {
38268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38269 }
38270 arg1 = reinterpret_cast< wxWindow * >(argp1);
38271 {
38272 PyThreadState* __tstate = wxPyBeginAllowThreads();
38273 result = ((wxWindow const *)arg1)->GetForegroundColour();
38274 wxPyEndAllowThreads(__tstate);
38275 if (PyErr_Occurred()) SWIG_fail;
38276 }
38277 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38278 return resultobj;
38279 fail:
38280 return NULL;
38281 }
38282
38283
38284 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38285 PyObject *resultobj = 0;
38286 wxWindow *arg1 = (wxWindow *) 0 ;
38287 bool result;
38288 void *argp1 = 0 ;
38289 int res1 = 0 ;
38290 PyObject *swig_obj[1] ;
38291
38292 if (!args) SWIG_fail;
38293 swig_obj[0] = args;
38294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38295 if (!SWIG_IsOK(res1)) {
38296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38297 }
38298 arg1 = reinterpret_cast< wxWindow * >(argp1);
38299 {
38300 PyThreadState* __tstate = wxPyBeginAllowThreads();
38301 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38302 wxPyEndAllowThreads(__tstate);
38303 if (PyErr_Occurred()) SWIG_fail;
38304 }
38305 {
38306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38307 }
38308 return resultobj;
38309 fail:
38310 return NULL;
38311 }
38312
38313
38314 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38315 PyObject *resultobj = 0;
38316 wxWindow *arg1 = (wxWindow *) 0 ;
38317 bool result;
38318 void *argp1 = 0 ;
38319 int res1 = 0 ;
38320 PyObject *swig_obj[1] ;
38321
38322 if (!args) SWIG_fail;
38323 swig_obj[0] = args;
38324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38325 if (!SWIG_IsOK(res1)) {
38326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38327 }
38328 arg1 = reinterpret_cast< wxWindow * >(argp1);
38329 {
38330 PyThreadState* __tstate = wxPyBeginAllowThreads();
38331 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38332 wxPyEndAllowThreads(__tstate);
38333 if (PyErr_Occurred()) SWIG_fail;
38334 }
38335 {
38336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38337 }
38338 return resultobj;
38339 fail:
38340 return NULL;
38341 }
38342
38343
38344 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38345 PyObject *resultobj = 0;
38346 wxWindow *arg1 = (wxWindow *) 0 ;
38347 wxBackgroundStyle arg2 ;
38348 bool result;
38349 void *argp1 = 0 ;
38350 int res1 = 0 ;
38351 int val2 ;
38352 int ecode2 = 0 ;
38353 PyObject * obj0 = 0 ;
38354 PyObject * obj1 = 0 ;
38355 char * kwnames[] = {
38356 (char *) "self",(char *) "style", NULL
38357 };
38358
38359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38361 if (!SWIG_IsOK(res1)) {
38362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38363 }
38364 arg1 = reinterpret_cast< wxWindow * >(argp1);
38365 ecode2 = SWIG_AsVal_int(obj1, &val2);
38366 if (!SWIG_IsOK(ecode2)) {
38367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38368 }
38369 arg2 = static_cast< wxBackgroundStyle >(val2);
38370 {
38371 PyThreadState* __tstate = wxPyBeginAllowThreads();
38372 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38373 wxPyEndAllowThreads(__tstate);
38374 if (PyErr_Occurred()) SWIG_fail;
38375 }
38376 {
38377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38378 }
38379 return resultobj;
38380 fail:
38381 return NULL;
38382 }
38383
38384
38385 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38386 PyObject *resultobj = 0;
38387 wxWindow *arg1 = (wxWindow *) 0 ;
38388 wxBackgroundStyle result;
38389 void *argp1 = 0 ;
38390 int res1 = 0 ;
38391 PyObject *swig_obj[1] ;
38392
38393 if (!args) SWIG_fail;
38394 swig_obj[0] = args;
38395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38396 if (!SWIG_IsOK(res1)) {
38397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38398 }
38399 arg1 = reinterpret_cast< wxWindow * >(argp1);
38400 {
38401 PyThreadState* __tstate = wxPyBeginAllowThreads();
38402 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38403 wxPyEndAllowThreads(__tstate);
38404 if (PyErr_Occurred()) SWIG_fail;
38405 }
38406 resultobj = SWIG_From_int(static_cast< int >(result));
38407 return resultobj;
38408 fail:
38409 return NULL;
38410 }
38411
38412
38413 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38414 PyObject *resultobj = 0;
38415 wxWindow *arg1 = (wxWindow *) 0 ;
38416 bool result;
38417 void *argp1 = 0 ;
38418 int res1 = 0 ;
38419 PyObject *swig_obj[1] ;
38420
38421 if (!args) SWIG_fail;
38422 swig_obj[0] = args;
38423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38424 if (!SWIG_IsOK(res1)) {
38425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38426 }
38427 arg1 = reinterpret_cast< wxWindow * >(argp1);
38428 {
38429 PyThreadState* __tstate = wxPyBeginAllowThreads();
38430 result = (bool)(arg1)->HasTransparentBackground();
38431 wxPyEndAllowThreads(__tstate);
38432 if (PyErr_Occurred()) SWIG_fail;
38433 }
38434 {
38435 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38436 }
38437 return resultobj;
38438 fail:
38439 return NULL;
38440 }
38441
38442
38443 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38444 PyObject *resultobj = 0;
38445 wxWindow *arg1 = (wxWindow *) 0 ;
38446 wxCursor *arg2 = 0 ;
38447 bool result;
38448 void *argp1 = 0 ;
38449 int res1 = 0 ;
38450 void *argp2 = 0 ;
38451 int res2 = 0 ;
38452 PyObject * obj0 = 0 ;
38453 PyObject * obj1 = 0 ;
38454 char * kwnames[] = {
38455 (char *) "self",(char *) "cursor", NULL
38456 };
38457
38458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38460 if (!SWIG_IsOK(res1)) {
38461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38462 }
38463 arg1 = reinterpret_cast< wxWindow * >(argp1);
38464 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38465 if (!SWIG_IsOK(res2)) {
38466 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38467 }
38468 if (!argp2) {
38469 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38470 }
38471 arg2 = reinterpret_cast< wxCursor * >(argp2);
38472 {
38473 PyThreadState* __tstate = wxPyBeginAllowThreads();
38474 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38475 wxPyEndAllowThreads(__tstate);
38476 if (PyErr_Occurred()) SWIG_fail;
38477 }
38478 {
38479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38480 }
38481 return resultobj;
38482 fail:
38483 return NULL;
38484 }
38485
38486
38487 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38488 PyObject *resultobj = 0;
38489 wxWindow *arg1 = (wxWindow *) 0 ;
38490 wxCursor result;
38491 void *argp1 = 0 ;
38492 int res1 = 0 ;
38493 PyObject *swig_obj[1] ;
38494
38495 if (!args) SWIG_fail;
38496 swig_obj[0] = args;
38497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38498 if (!SWIG_IsOK(res1)) {
38499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38500 }
38501 arg1 = reinterpret_cast< wxWindow * >(argp1);
38502 {
38503 PyThreadState* __tstate = wxPyBeginAllowThreads();
38504 result = (arg1)->GetCursor();
38505 wxPyEndAllowThreads(__tstate);
38506 if (PyErr_Occurred()) SWIG_fail;
38507 }
38508 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38509 return resultobj;
38510 fail:
38511 return NULL;
38512 }
38513
38514
38515 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38516 PyObject *resultobj = 0;
38517 wxWindow *arg1 = (wxWindow *) 0 ;
38518 wxFont *arg2 = 0 ;
38519 bool result;
38520 void *argp1 = 0 ;
38521 int res1 = 0 ;
38522 void *argp2 = 0 ;
38523 int res2 = 0 ;
38524 PyObject * obj0 = 0 ;
38525 PyObject * obj1 = 0 ;
38526 char * kwnames[] = {
38527 (char *) "self",(char *) "font", NULL
38528 };
38529
38530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38532 if (!SWIG_IsOK(res1)) {
38533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38534 }
38535 arg1 = reinterpret_cast< wxWindow * >(argp1);
38536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38537 if (!SWIG_IsOK(res2)) {
38538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38539 }
38540 if (!argp2) {
38541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38542 }
38543 arg2 = reinterpret_cast< wxFont * >(argp2);
38544 {
38545 PyThreadState* __tstate = wxPyBeginAllowThreads();
38546 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38547 wxPyEndAllowThreads(__tstate);
38548 if (PyErr_Occurred()) SWIG_fail;
38549 }
38550 {
38551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38552 }
38553 return resultobj;
38554 fail:
38555 return NULL;
38556 }
38557
38558
38559 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38560 PyObject *resultobj = 0;
38561 wxWindow *arg1 = (wxWindow *) 0 ;
38562 wxFont *arg2 = 0 ;
38563 void *argp1 = 0 ;
38564 int res1 = 0 ;
38565 void *argp2 = 0 ;
38566 int res2 = 0 ;
38567 PyObject * obj0 = 0 ;
38568 PyObject * obj1 = 0 ;
38569 char * kwnames[] = {
38570 (char *) "self",(char *) "font", NULL
38571 };
38572
38573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38575 if (!SWIG_IsOK(res1)) {
38576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38577 }
38578 arg1 = reinterpret_cast< wxWindow * >(argp1);
38579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38580 if (!SWIG_IsOK(res2)) {
38581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38582 }
38583 if (!argp2) {
38584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38585 }
38586 arg2 = reinterpret_cast< wxFont * >(argp2);
38587 {
38588 PyThreadState* __tstate = wxPyBeginAllowThreads();
38589 (arg1)->SetOwnFont((wxFont const &)*arg2);
38590 wxPyEndAllowThreads(__tstate);
38591 if (PyErr_Occurred()) SWIG_fail;
38592 }
38593 resultobj = SWIG_Py_Void();
38594 return resultobj;
38595 fail:
38596 return NULL;
38597 }
38598
38599
38600 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38601 PyObject *resultobj = 0;
38602 wxWindow *arg1 = (wxWindow *) 0 ;
38603 wxFont result;
38604 void *argp1 = 0 ;
38605 int res1 = 0 ;
38606 PyObject *swig_obj[1] ;
38607
38608 if (!args) SWIG_fail;
38609 swig_obj[0] = args;
38610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38611 if (!SWIG_IsOK(res1)) {
38612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38613 }
38614 arg1 = reinterpret_cast< wxWindow * >(argp1);
38615 {
38616 PyThreadState* __tstate = wxPyBeginAllowThreads();
38617 result = (arg1)->GetFont();
38618 wxPyEndAllowThreads(__tstate);
38619 if (PyErr_Occurred()) SWIG_fail;
38620 }
38621 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38622 return resultobj;
38623 fail:
38624 return NULL;
38625 }
38626
38627
38628 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38629 PyObject *resultobj = 0;
38630 wxWindow *arg1 = (wxWindow *) 0 ;
38631 wxCaret *arg2 = (wxCaret *) 0 ;
38632 void *argp1 = 0 ;
38633 int res1 = 0 ;
38634 int res2 = 0 ;
38635 PyObject * obj0 = 0 ;
38636 PyObject * obj1 = 0 ;
38637 char * kwnames[] = {
38638 (char *) "self",(char *) "caret", NULL
38639 };
38640
38641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38643 if (!SWIG_IsOK(res1)) {
38644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38645 }
38646 arg1 = reinterpret_cast< wxWindow * >(argp1);
38647 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38648 if (!SWIG_IsOK(res2)) {
38649 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38650 }
38651 {
38652 PyThreadState* __tstate = wxPyBeginAllowThreads();
38653 (arg1)->SetCaret(arg2);
38654 wxPyEndAllowThreads(__tstate);
38655 if (PyErr_Occurred()) SWIG_fail;
38656 }
38657 resultobj = SWIG_Py_Void();
38658 return resultobj;
38659 fail:
38660 return NULL;
38661 }
38662
38663
38664 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38665 PyObject *resultobj = 0;
38666 wxWindow *arg1 = (wxWindow *) 0 ;
38667 wxCaret *result = 0 ;
38668 void *argp1 = 0 ;
38669 int res1 = 0 ;
38670 PyObject *swig_obj[1] ;
38671
38672 if (!args) SWIG_fail;
38673 swig_obj[0] = args;
38674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38675 if (!SWIG_IsOK(res1)) {
38676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38677 }
38678 arg1 = reinterpret_cast< wxWindow * >(argp1);
38679 {
38680 PyThreadState* __tstate = wxPyBeginAllowThreads();
38681 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38682 wxPyEndAllowThreads(__tstate);
38683 if (PyErr_Occurred()) SWIG_fail;
38684 }
38685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38686 return resultobj;
38687 fail:
38688 return NULL;
38689 }
38690
38691
38692 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38693 PyObject *resultobj = 0;
38694 wxWindow *arg1 = (wxWindow *) 0 ;
38695 int result;
38696 void *argp1 = 0 ;
38697 int res1 = 0 ;
38698 PyObject *swig_obj[1] ;
38699
38700 if (!args) SWIG_fail;
38701 swig_obj[0] = args;
38702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38703 if (!SWIG_IsOK(res1)) {
38704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38705 }
38706 arg1 = reinterpret_cast< wxWindow * >(argp1);
38707 {
38708 PyThreadState* __tstate = wxPyBeginAllowThreads();
38709 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38710 wxPyEndAllowThreads(__tstate);
38711 if (PyErr_Occurred()) SWIG_fail;
38712 }
38713 resultobj = SWIG_From_int(static_cast< int >(result));
38714 return resultobj;
38715 fail:
38716 return NULL;
38717 }
38718
38719
38720 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38721 PyObject *resultobj = 0;
38722 wxWindow *arg1 = (wxWindow *) 0 ;
38723 int result;
38724 void *argp1 = 0 ;
38725 int res1 = 0 ;
38726 PyObject *swig_obj[1] ;
38727
38728 if (!args) SWIG_fail;
38729 swig_obj[0] = args;
38730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38731 if (!SWIG_IsOK(res1)) {
38732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38733 }
38734 arg1 = reinterpret_cast< wxWindow * >(argp1);
38735 {
38736 PyThreadState* __tstate = wxPyBeginAllowThreads();
38737 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38738 wxPyEndAllowThreads(__tstate);
38739 if (PyErr_Occurred()) SWIG_fail;
38740 }
38741 resultobj = SWIG_From_int(static_cast< int >(result));
38742 return resultobj;
38743 fail:
38744 return NULL;
38745 }
38746
38747
38748 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38749 PyObject *resultobj = 0;
38750 wxWindow *arg1 = (wxWindow *) 0 ;
38751 wxString *arg2 = 0 ;
38752 int *arg3 = (int *) 0 ;
38753 int *arg4 = (int *) 0 ;
38754 void *argp1 = 0 ;
38755 int res1 = 0 ;
38756 bool temp2 = false ;
38757 int temp3 ;
38758 int res3 = SWIG_TMPOBJ ;
38759 int temp4 ;
38760 int res4 = SWIG_TMPOBJ ;
38761 PyObject * obj0 = 0 ;
38762 PyObject * obj1 = 0 ;
38763 char * kwnames[] = {
38764 (char *) "self",(char *) "string", NULL
38765 };
38766
38767 arg3 = &temp3;
38768 arg4 = &temp4;
38769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38771 if (!SWIG_IsOK(res1)) {
38772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38773 }
38774 arg1 = reinterpret_cast< wxWindow * >(argp1);
38775 {
38776 arg2 = wxString_in_helper(obj1);
38777 if (arg2 == NULL) SWIG_fail;
38778 temp2 = true;
38779 }
38780 {
38781 PyThreadState* __tstate = wxPyBeginAllowThreads();
38782 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
38783 wxPyEndAllowThreads(__tstate);
38784 if (PyErr_Occurred()) SWIG_fail;
38785 }
38786 resultobj = SWIG_Py_Void();
38787 if (SWIG_IsTmpObj(res3)) {
38788 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38789 } else {
38790 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38791 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38792 }
38793 if (SWIG_IsTmpObj(res4)) {
38794 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38795 } else {
38796 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38797 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38798 }
38799 {
38800 if (temp2)
38801 delete arg2;
38802 }
38803 return resultobj;
38804 fail:
38805 {
38806 if (temp2)
38807 delete arg2;
38808 }
38809 return NULL;
38810 }
38811
38812
38813 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38814 PyObject *resultobj = 0;
38815 wxWindow *arg1 = (wxWindow *) 0 ;
38816 wxString *arg2 = 0 ;
38817 int *arg3 = (int *) 0 ;
38818 int *arg4 = (int *) 0 ;
38819 int *arg5 = (int *) 0 ;
38820 int *arg6 = (int *) 0 ;
38821 wxFont *arg7 = (wxFont *) NULL ;
38822 void *argp1 = 0 ;
38823 int res1 = 0 ;
38824 bool temp2 = false ;
38825 int temp3 ;
38826 int res3 = SWIG_TMPOBJ ;
38827 int temp4 ;
38828 int res4 = SWIG_TMPOBJ ;
38829 int temp5 ;
38830 int res5 = SWIG_TMPOBJ ;
38831 int temp6 ;
38832 int res6 = SWIG_TMPOBJ ;
38833 void *argp7 = 0 ;
38834 int res7 = 0 ;
38835 PyObject * obj0 = 0 ;
38836 PyObject * obj1 = 0 ;
38837 PyObject * obj2 = 0 ;
38838 char * kwnames[] = {
38839 (char *) "self",(char *) "string",(char *) "font", NULL
38840 };
38841
38842 arg3 = &temp3;
38843 arg4 = &temp4;
38844 arg5 = &temp5;
38845 arg6 = &temp6;
38846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38848 if (!SWIG_IsOK(res1)) {
38849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38850 }
38851 arg1 = reinterpret_cast< wxWindow * >(argp1);
38852 {
38853 arg2 = wxString_in_helper(obj1);
38854 if (arg2 == NULL) SWIG_fail;
38855 temp2 = true;
38856 }
38857 if (obj2) {
38858 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
38859 if (!SWIG_IsOK(res7)) {
38860 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
38861 }
38862 arg7 = reinterpret_cast< wxFont * >(argp7);
38863 }
38864 {
38865 PyThreadState* __tstate = wxPyBeginAllowThreads();
38866 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
38867 wxPyEndAllowThreads(__tstate);
38868 if (PyErr_Occurred()) SWIG_fail;
38869 }
38870 resultobj = SWIG_Py_Void();
38871 if (SWIG_IsTmpObj(res3)) {
38872 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38873 } else {
38874 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38875 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38876 }
38877 if (SWIG_IsTmpObj(res4)) {
38878 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
38879 } else {
38880 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38881 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
38882 }
38883 if (SWIG_IsTmpObj(res5)) {
38884 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
38885 } else {
38886 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38887 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
38888 }
38889 if (SWIG_IsTmpObj(res6)) {
38890 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
38891 } else {
38892 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
38894 }
38895 {
38896 if (temp2)
38897 delete arg2;
38898 }
38899 return resultobj;
38900 fail:
38901 {
38902 if (temp2)
38903 delete arg2;
38904 }
38905 return NULL;
38906 }
38907
38908
38909 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38910 PyObject *resultobj = 0;
38911 wxWindow *arg1 = (wxWindow *) 0 ;
38912 int *arg2 = (int *) 0 ;
38913 int *arg3 = (int *) 0 ;
38914 void *argp1 = 0 ;
38915 int res1 = 0 ;
38916 int temp2 ;
38917 int res2 = 0 ;
38918 int temp3 ;
38919 int res3 = 0 ;
38920 PyObject * obj0 = 0 ;
38921 PyObject * obj1 = 0 ;
38922 PyObject * obj2 = 0 ;
38923 char * kwnames[] = {
38924 (char *) "self",(char *) "x",(char *) "y", NULL
38925 };
38926
38927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38929 if (!SWIG_IsOK(res1)) {
38930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
38931 }
38932 arg1 = reinterpret_cast< wxWindow * >(argp1);
38933 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
38934 int val;
38935 int ecode = SWIG_AsVal_int(obj1, &val);
38936 if (!SWIG_IsOK(ecode)) {
38937 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
38938 }
38939 temp2 = static_cast< int >(val);
38940 arg2 = &temp2;
38941 res2 = SWIG_AddTmpMask(ecode);
38942 }
38943 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
38944 int val;
38945 int ecode = SWIG_AsVal_int(obj2, &val);
38946 if (!SWIG_IsOK(ecode)) {
38947 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
38948 }
38949 temp3 = static_cast< int >(val);
38950 arg3 = &temp3;
38951 res3 = SWIG_AddTmpMask(ecode);
38952 }
38953 {
38954 PyThreadState* __tstate = wxPyBeginAllowThreads();
38955 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
38956 wxPyEndAllowThreads(__tstate);
38957 if (PyErr_Occurred()) SWIG_fail;
38958 }
38959 resultobj = SWIG_Py_Void();
38960 if (SWIG_IsTmpObj(res2)) {
38961 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
38962 } else {
38963 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38964 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
38965 }
38966 if (SWIG_IsTmpObj(res3)) {
38967 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
38968 } else {
38969 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
38970 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
38971 }
38972 return resultobj;
38973 fail:
38974 return NULL;
38975 }
38976
38977
38978 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38979 PyObject *resultobj = 0;
38980 wxWindow *arg1 = (wxWindow *) 0 ;
38981 int *arg2 = (int *) 0 ;
38982 int *arg3 = (int *) 0 ;
38983 void *argp1 = 0 ;
38984 int res1 = 0 ;
38985 int temp2 ;
38986 int res2 = 0 ;
38987 int temp3 ;
38988 int res3 = 0 ;
38989 PyObject * obj0 = 0 ;
38990 PyObject * obj1 = 0 ;
38991 PyObject * obj2 = 0 ;
38992 char * kwnames[] = {
38993 (char *) "self",(char *) "x",(char *) "y", NULL
38994 };
38995
38996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38998 if (!SWIG_IsOK(res1)) {
38999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39000 }
39001 arg1 = reinterpret_cast< wxWindow * >(argp1);
39002 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39003 int val;
39004 int ecode = SWIG_AsVal_int(obj1, &val);
39005 if (!SWIG_IsOK(ecode)) {
39006 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39007 }
39008 temp2 = static_cast< int >(val);
39009 arg2 = &temp2;
39010 res2 = SWIG_AddTmpMask(ecode);
39011 }
39012 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39013 int val;
39014 int ecode = SWIG_AsVal_int(obj2, &val);
39015 if (!SWIG_IsOK(ecode)) {
39016 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39017 }
39018 temp3 = static_cast< int >(val);
39019 arg3 = &temp3;
39020 res3 = SWIG_AddTmpMask(ecode);
39021 }
39022 {
39023 PyThreadState* __tstate = wxPyBeginAllowThreads();
39024 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39025 wxPyEndAllowThreads(__tstate);
39026 if (PyErr_Occurred()) SWIG_fail;
39027 }
39028 resultobj = SWIG_Py_Void();
39029 if (SWIG_IsTmpObj(res2)) {
39030 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39031 } else {
39032 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39033 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39034 }
39035 if (SWIG_IsTmpObj(res3)) {
39036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39037 } else {
39038 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39040 }
39041 return resultobj;
39042 fail:
39043 return NULL;
39044 }
39045
39046
39047 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39048 PyObject *resultobj = 0;
39049 wxWindow *arg1 = (wxWindow *) 0 ;
39050 wxPoint *arg2 = 0 ;
39051 wxPoint result;
39052 void *argp1 = 0 ;
39053 int res1 = 0 ;
39054 wxPoint temp2 ;
39055 PyObject * obj0 = 0 ;
39056 PyObject * obj1 = 0 ;
39057 char * kwnames[] = {
39058 (char *) "self",(char *) "pt", NULL
39059 };
39060
39061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39063 if (!SWIG_IsOK(res1)) {
39064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39065 }
39066 arg1 = reinterpret_cast< wxWindow * >(argp1);
39067 {
39068 arg2 = &temp2;
39069 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39070 }
39071 {
39072 PyThreadState* __tstate = wxPyBeginAllowThreads();
39073 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39074 wxPyEndAllowThreads(__tstate);
39075 if (PyErr_Occurred()) SWIG_fail;
39076 }
39077 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39078 return resultobj;
39079 fail:
39080 return NULL;
39081 }
39082
39083
39084 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39085 PyObject *resultobj = 0;
39086 wxWindow *arg1 = (wxWindow *) 0 ;
39087 wxPoint *arg2 = 0 ;
39088 wxPoint result;
39089 void *argp1 = 0 ;
39090 int res1 = 0 ;
39091 wxPoint temp2 ;
39092 PyObject * obj0 = 0 ;
39093 PyObject * obj1 = 0 ;
39094 char * kwnames[] = {
39095 (char *) "self",(char *) "pt", NULL
39096 };
39097
39098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39100 if (!SWIG_IsOK(res1)) {
39101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39102 }
39103 arg1 = reinterpret_cast< wxWindow * >(argp1);
39104 {
39105 arg2 = &temp2;
39106 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39107 }
39108 {
39109 PyThreadState* __tstate = wxPyBeginAllowThreads();
39110 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39111 wxPyEndAllowThreads(__tstate);
39112 if (PyErr_Occurred()) SWIG_fail;
39113 }
39114 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39115 return resultobj;
39116 fail:
39117 return NULL;
39118 }
39119
39120
39121 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39122 PyObject *resultobj = 0;
39123 wxWindow *arg1 = (wxWindow *) 0 ;
39124 int arg2 ;
39125 int arg3 ;
39126 wxHitTest result;
39127 void *argp1 = 0 ;
39128 int res1 = 0 ;
39129 int val2 ;
39130 int ecode2 = 0 ;
39131 int val3 ;
39132 int ecode3 = 0 ;
39133 PyObject * obj0 = 0 ;
39134 PyObject * obj1 = 0 ;
39135 PyObject * obj2 = 0 ;
39136 char * kwnames[] = {
39137 (char *) "self",(char *) "x",(char *) "y", NULL
39138 };
39139
39140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39142 if (!SWIG_IsOK(res1)) {
39143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39144 }
39145 arg1 = reinterpret_cast< wxWindow * >(argp1);
39146 ecode2 = SWIG_AsVal_int(obj1, &val2);
39147 if (!SWIG_IsOK(ecode2)) {
39148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39149 }
39150 arg2 = static_cast< int >(val2);
39151 ecode3 = SWIG_AsVal_int(obj2, &val3);
39152 if (!SWIG_IsOK(ecode3)) {
39153 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39154 }
39155 arg3 = static_cast< int >(val3);
39156 {
39157 PyThreadState* __tstate = wxPyBeginAllowThreads();
39158 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39159 wxPyEndAllowThreads(__tstate);
39160 if (PyErr_Occurred()) SWIG_fail;
39161 }
39162 resultobj = SWIG_From_int(static_cast< int >(result));
39163 return resultobj;
39164 fail:
39165 return NULL;
39166 }
39167
39168
39169 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39170 PyObject *resultobj = 0;
39171 wxWindow *arg1 = (wxWindow *) 0 ;
39172 wxPoint *arg2 = 0 ;
39173 wxHitTest result;
39174 void *argp1 = 0 ;
39175 int res1 = 0 ;
39176 wxPoint temp2 ;
39177 PyObject * obj0 = 0 ;
39178 PyObject * obj1 = 0 ;
39179 char * kwnames[] = {
39180 (char *) "self",(char *) "pt", NULL
39181 };
39182
39183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39185 if (!SWIG_IsOK(res1)) {
39186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39187 }
39188 arg1 = reinterpret_cast< wxWindow * >(argp1);
39189 {
39190 arg2 = &temp2;
39191 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39192 }
39193 {
39194 PyThreadState* __tstate = wxPyBeginAllowThreads();
39195 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39196 wxPyEndAllowThreads(__tstate);
39197 if (PyErr_Occurred()) SWIG_fail;
39198 }
39199 resultobj = SWIG_From_int(static_cast< int >(result));
39200 return resultobj;
39201 fail:
39202 return NULL;
39203 }
39204
39205
39206 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39207 PyObject *resultobj = 0;
39208 wxWindow *arg1 = (wxWindow *) 0 ;
39209 long arg2 ;
39210 wxBorder result;
39211 void *argp1 = 0 ;
39212 int res1 = 0 ;
39213 long val2 ;
39214 int ecode2 = 0 ;
39215
39216 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39218 if (!SWIG_IsOK(res1)) {
39219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39220 }
39221 arg1 = reinterpret_cast< wxWindow * >(argp1);
39222 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39223 if (!SWIG_IsOK(ecode2)) {
39224 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39225 }
39226 arg2 = static_cast< long >(val2);
39227 {
39228 PyThreadState* __tstate = wxPyBeginAllowThreads();
39229 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39230 wxPyEndAllowThreads(__tstate);
39231 if (PyErr_Occurred()) SWIG_fail;
39232 }
39233 resultobj = SWIG_From_int(static_cast< int >(result));
39234 return resultobj;
39235 fail:
39236 return NULL;
39237 }
39238
39239
39240 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39241 PyObject *resultobj = 0;
39242 wxWindow *arg1 = (wxWindow *) 0 ;
39243 wxBorder result;
39244 void *argp1 = 0 ;
39245 int res1 = 0 ;
39246
39247 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39249 if (!SWIG_IsOK(res1)) {
39250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39251 }
39252 arg1 = reinterpret_cast< wxWindow * >(argp1);
39253 {
39254 PyThreadState* __tstate = wxPyBeginAllowThreads();
39255 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39256 wxPyEndAllowThreads(__tstate);
39257 if (PyErr_Occurred()) SWIG_fail;
39258 }
39259 resultobj = SWIG_From_int(static_cast< int >(result));
39260 return resultobj;
39261 fail:
39262 return NULL;
39263 }
39264
39265
39266 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39267 int argc;
39268 PyObject *argv[3];
39269
39270 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39271 --argc;
39272 if (argc == 1) {
39273 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39274 }
39275 if (argc == 2) {
39276 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39277 }
39278
39279 fail:
39280 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39281 return NULL;
39282 }
39283
39284
39285 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39286 PyObject *resultobj = 0;
39287 wxWindow *arg1 = (wxWindow *) 0 ;
39288 long arg2 = (long) wxUPDATE_UI_NONE ;
39289 void *argp1 = 0 ;
39290 int res1 = 0 ;
39291 long val2 ;
39292 int ecode2 = 0 ;
39293 PyObject * obj0 = 0 ;
39294 PyObject * obj1 = 0 ;
39295 char * kwnames[] = {
39296 (char *) "self",(char *) "flags", NULL
39297 };
39298
39299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39301 if (!SWIG_IsOK(res1)) {
39302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39303 }
39304 arg1 = reinterpret_cast< wxWindow * >(argp1);
39305 if (obj1) {
39306 ecode2 = SWIG_AsVal_long(obj1, &val2);
39307 if (!SWIG_IsOK(ecode2)) {
39308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39309 }
39310 arg2 = static_cast< long >(val2);
39311 }
39312 {
39313 PyThreadState* __tstate = wxPyBeginAllowThreads();
39314 (arg1)->UpdateWindowUI(arg2);
39315 wxPyEndAllowThreads(__tstate);
39316 if (PyErr_Occurred()) SWIG_fail;
39317 }
39318 resultobj = SWIG_Py_Void();
39319 return resultobj;
39320 fail:
39321 return NULL;
39322 }
39323
39324
39325 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39326 PyObject *resultobj = 0;
39327 wxWindow *arg1 = (wxWindow *) 0 ;
39328 wxMenu *arg2 = (wxMenu *) 0 ;
39329 int arg3 = (int) -1 ;
39330 int arg4 = (int) -1 ;
39331 bool result;
39332 void *argp1 = 0 ;
39333 int res1 = 0 ;
39334 void *argp2 = 0 ;
39335 int res2 = 0 ;
39336 int val3 ;
39337 int ecode3 = 0 ;
39338 int val4 ;
39339 int ecode4 = 0 ;
39340 PyObject * obj0 = 0 ;
39341 PyObject * obj1 = 0 ;
39342 PyObject * obj2 = 0 ;
39343 PyObject * obj3 = 0 ;
39344 char * kwnames[] = {
39345 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39346 };
39347
39348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39350 if (!SWIG_IsOK(res1)) {
39351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39352 }
39353 arg1 = reinterpret_cast< wxWindow * >(argp1);
39354 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39355 if (!SWIG_IsOK(res2)) {
39356 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39357 }
39358 arg2 = reinterpret_cast< wxMenu * >(argp2);
39359 if (obj2) {
39360 ecode3 = SWIG_AsVal_int(obj2, &val3);
39361 if (!SWIG_IsOK(ecode3)) {
39362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39363 }
39364 arg3 = static_cast< int >(val3);
39365 }
39366 if (obj3) {
39367 ecode4 = SWIG_AsVal_int(obj3, &val4);
39368 if (!SWIG_IsOK(ecode4)) {
39369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39370 }
39371 arg4 = static_cast< int >(val4);
39372 }
39373 {
39374 PyThreadState* __tstate = wxPyBeginAllowThreads();
39375 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39376 wxPyEndAllowThreads(__tstate);
39377 if (PyErr_Occurred()) SWIG_fail;
39378 }
39379 {
39380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39381 }
39382 return resultobj;
39383 fail:
39384 return NULL;
39385 }
39386
39387
39388 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39389 PyObject *resultobj = 0;
39390 wxWindow *arg1 = (wxWindow *) 0 ;
39391 wxMenu *arg2 = (wxMenu *) 0 ;
39392 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39393 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39394 bool result;
39395 void *argp1 = 0 ;
39396 int res1 = 0 ;
39397 void *argp2 = 0 ;
39398 int res2 = 0 ;
39399 wxPoint temp3 ;
39400 PyObject * obj0 = 0 ;
39401 PyObject * obj1 = 0 ;
39402 PyObject * obj2 = 0 ;
39403 char * kwnames[] = {
39404 (char *) "self",(char *) "menu",(char *) "pos", NULL
39405 };
39406
39407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39409 if (!SWIG_IsOK(res1)) {
39410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39411 }
39412 arg1 = reinterpret_cast< wxWindow * >(argp1);
39413 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39414 if (!SWIG_IsOK(res2)) {
39415 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39416 }
39417 arg2 = reinterpret_cast< wxMenu * >(argp2);
39418 if (obj2) {
39419 {
39420 arg3 = &temp3;
39421 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39422 }
39423 }
39424 {
39425 PyThreadState* __tstate = wxPyBeginAllowThreads();
39426 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39427 wxPyEndAllowThreads(__tstate);
39428 if (PyErr_Occurred()) SWIG_fail;
39429 }
39430 {
39431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39432 }
39433 return resultobj;
39434 fail:
39435 return NULL;
39436 }
39437
39438
39439 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39440 PyObject *resultobj = 0;
39441 wxWindow *arg1 = (wxWindow *) 0 ;
39442 bool result;
39443 void *argp1 = 0 ;
39444 int res1 = 0 ;
39445 PyObject *swig_obj[1] ;
39446
39447 if (!args) SWIG_fail;
39448 swig_obj[0] = args;
39449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39450 if (!SWIG_IsOK(res1)) {
39451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39452 }
39453 arg1 = reinterpret_cast< wxWindow * >(argp1);
39454 {
39455 PyThreadState* __tstate = wxPyBeginAllowThreads();
39456 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39457 wxPyEndAllowThreads(__tstate);
39458 if (PyErr_Occurred()) SWIG_fail;
39459 }
39460 {
39461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39462 }
39463 return resultobj;
39464 fail:
39465 return NULL;
39466 }
39467
39468
39469 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39470 PyObject *resultobj = 0;
39471 wxWindow *arg1 = (wxWindow *) 0 ;
39472 long result;
39473 void *argp1 = 0 ;
39474 int res1 = 0 ;
39475 PyObject *swig_obj[1] ;
39476
39477 if (!args) SWIG_fail;
39478 swig_obj[0] = args;
39479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39480 if (!SWIG_IsOK(res1)) {
39481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39482 }
39483 arg1 = reinterpret_cast< wxWindow * >(argp1);
39484 {
39485 PyThreadState* __tstate = wxPyBeginAllowThreads();
39486 result = (long)wxWindow_GetHandle(arg1);
39487 wxPyEndAllowThreads(__tstate);
39488 if (PyErr_Occurred()) SWIG_fail;
39489 }
39490 resultobj = SWIG_From_long(static_cast< long >(result));
39491 return resultobj;
39492 fail:
39493 return NULL;
39494 }
39495
39496
39497 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39498 PyObject *resultobj = 0;
39499 wxWindow *arg1 = (wxWindow *) 0 ;
39500 long arg2 ;
39501 void *argp1 = 0 ;
39502 int res1 = 0 ;
39503 long val2 ;
39504 int ecode2 = 0 ;
39505 PyObject * obj0 = 0 ;
39506 PyObject * obj1 = 0 ;
39507 char * kwnames[] = {
39508 (char *) "self",(char *) "handle", NULL
39509 };
39510
39511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39513 if (!SWIG_IsOK(res1)) {
39514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39515 }
39516 arg1 = reinterpret_cast< wxWindow * >(argp1);
39517 ecode2 = SWIG_AsVal_long(obj1, &val2);
39518 if (!SWIG_IsOK(ecode2)) {
39519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39520 }
39521 arg2 = static_cast< long >(val2);
39522 {
39523 PyThreadState* __tstate = wxPyBeginAllowThreads();
39524 wxWindow_AssociateHandle(arg1,arg2);
39525 wxPyEndAllowThreads(__tstate);
39526 if (PyErr_Occurred()) SWIG_fail;
39527 }
39528 resultobj = SWIG_Py_Void();
39529 return resultobj;
39530 fail:
39531 return NULL;
39532 }
39533
39534
39535 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39536 PyObject *resultobj = 0;
39537 wxWindow *arg1 = (wxWindow *) 0 ;
39538 void *argp1 = 0 ;
39539 int res1 = 0 ;
39540 PyObject *swig_obj[1] ;
39541
39542 if (!args) SWIG_fail;
39543 swig_obj[0] = args;
39544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39545 if (!SWIG_IsOK(res1)) {
39546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39547 }
39548 arg1 = reinterpret_cast< wxWindow * >(argp1);
39549 {
39550 PyThreadState* __tstate = wxPyBeginAllowThreads();
39551 (arg1)->DissociateHandle();
39552 wxPyEndAllowThreads(__tstate);
39553 if (PyErr_Occurred()) SWIG_fail;
39554 }
39555 resultobj = SWIG_Py_Void();
39556 return resultobj;
39557 fail:
39558 return NULL;
39559 }
39560
39561
39562 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39563 PyObject *resultobj = 0;
39564 wxWindow *arg1 = (wxWindow *) 0 ;
39565 wxPaintEvent *arg2 = 0 ;
39566 void *argp1 = 0 ;
39567 int res1 = 0 ;
39568 void *argp2 = 0 ;
39569 int res2 = 0 ;
39570 PyObject * obj0 = 0 ;
39571 PyObject * obj1 = 0 ;
39572 char * kwnames[] = {
39573 (char *) "self",(char *) "event", NULL
39574 };
39575
39576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39578 if (!SWIG_IsOK(res1)) {
39579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39580 }
39581 arg1 = reinterpret_cast< wxWindow * >(argp1);
39582 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39583 if (!SWIG_IsOK(res2)) {
39584 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39585 }
39586 if (!argp2) {
39587 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39588 }
39589 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39590 {
39591 PyThreadState* __tstate = wxPyBeginAllowThreads();
39592 (arg1)->OnPaint(*arg2);
39593 wxPyEndAllowThreads(__tstate);
39594 if (PyErr_Occurred()) SWIG_fail;
39595 }
39596 resultobj = SWIG_Py_Void();
39597 return resultobj;
39598 fail:
39599 return NULL;
39600 }
39601
39602
39603 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39604 PyObject *resultobj = 0;
39605 wxWindow *arg1 = (wxWindow *) 0 ;
39606 int arg2 ;
39607 bool result;
39608 void *argp1 = 0 ;
39609 int res1 = 0 ;
39610 int val2 ;
39611 int ecode2 = 0 ;
39612 PyObject * obj0 = 0 ;
39613 PyObject * obj1 = 0 ;
39614 char * kwnames[] = {
39615 (char *) "self",(char *) "orient", NULL
39616 };
39617
39618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39620 if (!SWIG_IsOK(res1)) {
39621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39622 }
39623 arg1 = reinterpret_cast< wxWindow * >(argp1);
39624 ecode2 = SWIG_AsVal_int(obj1, &val2);
39625 if (!SWIG_IsOK(ecode2)) {
39626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39627 }
39628 arg2 = static_cast< int >(val2);
39629 {
39630 PyThreadState* __tstate = wxPyBeginAllowThreads();
39631 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39632 wxPyEndAllowThreads(__tstate);
39633 if (PyErr_Occurred()) SWIG_fail;
39634 }
39635 {
39636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39637 }
39638 return resultobj;
39639 fail:
39640 return NULL;
39641 }
39642
39643
39644 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39645 PyObject *resultobj = 0;
39646 wxWindow *arg1 = (wxWindow *) 0 ;
39647 int arg2 ;
39648 int arg3 ;
39649 int arg4 ;
39650 int arg5 ;
39651 bool arg6 = (bool) true ;
39652 void *argp1 = 0 ;
39653 int res1 = 0 ;
39654 int val2 ;
39655 int ecode2 = 0 ;
39656 int val3 ;
39657 int ecode3 = 0 ;
39658 int val4 ;
39659 int ecode4 = 0 ;
39660 int val5 ;
39661 int ecode5 = 0 ;
39662 bool val6 ;
39663 int ecode6 = 0 ;
39664 PyObject * obj0 = 0 ;
39665 PyObject * obj1 = 0 ;
39666 PyObject * obj2 = 0 ;
39667 PyObject * obj3 = 0 ;
39668 PyObject * obj4 = 0 ;
39669 PyObject * obj5 = 0 ;
39670 char * kwnames[] = {
39671 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39672 };
39673
39674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39676 if (!SWIG_IsOK(res1)) {
39677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39678 }
39679 arg1 = reinterpret_cast< wxWindow * >(argp1);
39680 ecode2 = SWIG_AsVal_int(obj1, &val2);
39681 if (!SWIG_IsOK(ecode2)) {
39682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39683 }
39684 arg2 = static_cast< int >(val2);
39685 ecode3 = SWIG_AsVal_int(obj2, &val3);
39686 if (!SWIG_IsOK(ecode3)) {
39687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39688 }
39689 arg3 = static_cast< int >(val3);
39690 ecode4 = SWIG_AsVal_int(obj3, &val4);
39691 if (!SWIG_IsOK(ecode4)) {
39692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39693 }
39694 arg4 = static_cast< int >(val4);
39695 ecode5 = SWIG_AsVal_int(obj4, &val5);
39696 if (!SWIG_IsOK(ecode5)) {
39697 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39698 }
39699 arg5 = static_cast< int >(val5);
39700 if (obj5) {
39701 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39702 if (!SWIG_IsOK(ecode6)) {
39703 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39704 }
39705 arg6 = static_cast< bool >(val6);
39706 }
39707 {
39708 PyThreadState* __tstate = wxPyBeginAllowThreads();
39709 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39710 wxPyEndAllowThreads(__tstate);
39711 if (PyErr_Occurred()) SWIG_fail;
39712 }
39713 resultobj = SWIG_Py_Void();
39714 return resultobj;
39715 fail:
39716 return NULL;
39717 }
39718
39719
39720 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39721 PyObject *resultobj = 0;
39722 wxWindow *arg1 = (wxWindow *) 0 ;
39723 int arg2 ;
39724 int arg3 ;
39725 bool arg4 = (bool) true ;
39726 void *argp1 = 0 ;
39727 int res1 = 0 ;
39728 int val2 ;
39729 int ecode2 = 0 ;
39730 int val3 ;
39731 int ecode3 = 0 ;
39732 bool val4 ;
39733 int ecode4 = 0 ;
39734 PyObject * obj0 = 0 ;
39735 PyObject * obj1 = 0 ;
39736 PyObject * obj2 = 0 ;
39737 PyObject * obj3 = 0 ;
39738 char * kwnames[] = {
39739 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39740 };
39741
39742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39744 if (!SWIG_IsOK(res1)) {
39745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39746 }
39747 arg1 = reinterpret_cast< wxWindow * >(argp1);
39748 ecode2 = SWIG_AsVal_int(obj1, &val2);
39749 if (!SWIG_IsOK(ecode2)) {
39750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39751 }
39752 arg2 = static_cast< int >(val2);
39753 ecode3 = SWIG_AsVal_int(obj2, &val3);
39754 if (!SWIG_IsOK(ecode3)) {
39755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39756 }
39757 arg3 = static_cast< int >(val3);
39758 if (obj3) {
39759 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39760 if (!SWIG_IsOK(ecode4)) {
39761 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39762 }
39763 arg4 = static_cast< bool >(val4);
39764 }
39765 {
39766 PyThreadState* __tstate = wxPyBeginAllowThreads();
39767 (arg1)->SetScrollPos(arg2,arg3,arg4);
39768 wxPyEndAllowThreads(__tstate);
39769 if (PyErr_Occurred()) SWIG_fail;
39770 }
39771 resultobj = SWIG_Py_Void();
39772 return resultobj;
39773 fail:
39774 return NULL;
39775 }
39776
39777
39778 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39779 PyObject *resultobj = 0;
39780 wxWindow *arg1 = (wxWindow *) 0 ;
39781 int arg2 ;
39782 int result;
39783 void *argp1 = 0 ;
39784 int res1 = 0 ;
39785 int val2 ;
39786 int ecode2 = 0 ;
39787 PyObject * obj0 = 0 ;
39788 PyObject * obj1 = 0 ;
39789 char * kwnames[] = {
39790 (char *) "self",(char *) "orientation", NULL
39791 };
39792
39793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39795 if (!SWIG_IsOK(res1)) {
39796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39797 }
39798 arg1 = reinterpret_cast< wxWindow * >(argp1);
39799 ecode2 = SWIG_AsVal_int(obj1, &val2);
39800 if (!SWIG_IsOK(ecode2)) {
39801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
39802 }
39803 arg2 = static_cast< int >(val2);
39804 {
39805 PyThreadState* __tstate = wxPyBeginAllowThreads();
39806 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
39807 wxPyEndAllowThreads(__tstate);
39808 if (PyErr_Occurred()) SWIG_fail;
39809 }
39810 resultobj = SWIG_From_int(static_cast< int >(result));
39811 return resultobj;
39812 fail:
39813 return NULL;
39814 }
39815
39816
39817 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39818 PyObject *resultobj = 0;
39819 wxWindow *arg1 = (wxWindow *) 0 ;
39820 int arg2 ;
39821 int result;
39822 void *argp1 = 0 ;
39823 int res1 = 0 ;
39824 int val2 ;
39825 int ecode2 = 0 ;
39826 PyObject * obj0 = 0 ;
39827 PyObject * obj1 = 0 ;
39828 char * kwnames[] = {
39829 (char *) "self",(char *) "orientation", NULL
39830 };
39831
39832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
39833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39834 if (!SWIG_IsOK(res1)) {
39835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
39836 }
39837 arg1 = reinterpret_cast< wxWindow * >(argp1);
39838 ecode2 = SWIG_AsVal_int(obj1, &val2);
39839 if (!SWIG_IsOK(ecode2)) {
39840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
39841 }
39842 arg2 = static_cast< int >(val2);
39843 {
39844 PyThreadState* __tstate = wxPyBeginAllowThreads();
39845 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
39846 wxPyEndAllowThreads(__tstate);
39847 if (PyErr_Occurred()) SWIG_fail;
39848 }
39849 resultobj = SWIG_From_int(static_cast< int >(result));
39850 return resultobj;
39851 fail:
39852 return NULL;
39853 }
39854
39855
39856 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39857 PyObject *resultobj = 0;
39858 wxWindow *arg1 = (wxWindow *) 0 ;
39859 int arg2 ;
39860 int result;
39861 void *argp1 = 0 ;
39862 int res1 = 0 ;
39863 int val2 ;
39864 int ecode2 = 0 ;
39865 PyObject * obj0 = 0 ;
39866 PyObject * obj1 = 0 ;
39867 char * kwnames[] = {
39868 (char *) "self",(char *) "orientation", NULL
39869 };
39870
39871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
39872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39873 if (!SWIG_IsOK(res1)) {
39874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
39875 }
39876 arg1 = reinterpret_cast< wxWindow * >(argp1);
39877 ecode2 = SWIG_AsVal_int(obj1, &val2);
39878 if (!SWIG_IsOK(ecode2)) {
39879 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
39880 }
39881 arg2 = static_cast< int >(val2);
39882 {
39883 PyThreadState* __tstate = wxPyBeginAllowThreads();
39884 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
39885 wxPyEndAllowThreads(__tstate);
39886 if (PyErr_Occurred()) SWIG_fail;
39887 }
39888 resultobj = SWIG_From_int(static_cast< int >(result));
39889 return resultobj;
39890 fail:
39891 return NULL;
39892 }
39893
39894
39895 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39896 PyObject *resultobj = 0;
39897 wxWindow *arg1 = (wxWindow *) 0 ;
39898 int arg2 ;
39899 int arg3 ;
39900 wxRect *arg4 = (wxRect *) NULL ;
39901 void *argp1 = 0 ;
39902 int res1 = 0 ;
39903 int val2 ;
39904 int ecode2 = 0 ;
39905 int val3 ;
39906 int ecode3 = 0 ;
39907 void *argp4 = 0 ;
39908 int res4 = 0 ;
39909 PyObject * obj0 = 0 ;
39910 PyObject * obj1 = 0 ;
39911 PyObject * obj2 = 0 ;
39912 PyObject * obj3 = 0 ;
39913 char * kwnames[] = {
39914 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
39915 };
39916
39917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39919 if (!SWIG_IsOK(res1)) {
39920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
39921 }
39922 arg1 = reinterpret_cast< wxWindow * >(argp1);
39923 ecode2 = SWIG_AsVal_int(obj1, &val2);
39924 if (!SWIG_IsOK(ecode2)) {
39925 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
39926 }
39927 arg2 = static_cast< int >(val2);
39928 ecode3 = SWIG_AsVal_int(obj2, &val3);
39929 if (!SWIG_IsOK(ecode3)) {
39930 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
39931 }
39932 arg3 = static_cast< int >(val3);
39933 if (obj3) {
39934 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
39935 if (!SWIG_IsOK(res4)) {
39936 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
39937 }
39938 arg4 = reinterpret_cast< wxRect * >(argp4);
39939 }
39940 {
39941 PyThreadState* __tstate = wxPyBeginAllowThreads();
39942 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
39943 wxPyEndAllowThreads(__tstate);
39944 if (PyErr_Occurred()) SWIG_fail;
39945 }
39946 resultobj = SWIG_Py_Void();
39947 return resultobj;
39948 fail:
39949 return NULL;
39950 }
39951
39952
39953 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39954 PyObject *resultobj = 0;
39955 wxWindow *arg1 = (wxWindow *) 0 ;
39956 int arg2 ;
39957 bool result;
39958 void *argp1 = 0 ;
39959 int res1 = 0 ;
39960 int val2 ;
39961 int ecode2 = 0 ;
39962 PyObject * obj0 = 0 ;
39963 PyObject * obj1 = 0 ;
39964 char * kwnames[] = {
39965 (char *) "self",(char *) "lines", NULL
39966 };
39967
39968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
39969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
39972 }
39973 arg1 = reinterpret_cast< wxWindow * >(argp1);
39974 ecode2 = SWIG_AsVal_int(obj1, &val2);
39975 if (!SWIG_IsOK(ecode2)) {
39976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
39977 }
39978 arg2 = static_cast< int >(val2);
39979 {
39980 PyThreadState* __tstate = wxPyBeginAllowThreads();
39981 result = (bool)(arg1)->ScrollLines(arg2);
39982 wxPyEndAllowThreads(__tstate);
39983 if (PyErr_Occurred()) SWIG_fail;
39984 }
39985 {
39986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39987 }
39988 return resultobj;
39989 fail:
39990 return NULL;
39991 }
39992
39993
39994 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39995 PyObject *resultobj = 0;
39996 wxWindow *arg1 = (wxWindow *) 0 ;
39997 int arg2 ;
39998 bool result;
39999 void *argp1 = 0 ;
40000 int res1 = 0 ;
40001 int val2 ;
40002 int ecode2 = 0 ;
40003 PyObject * obj0 = 0 ;
40004 PyObject * obj1 = 0 ;
40005 char * kwnames[] = {
40006 (char *) "self",(char *) "pages", NULL
40007 };
40008
40009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40011 if (!SWIG_IsOK(res1)) {
40012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40013 }
40014 arg1 = reinterpret_cast< wxWindow * >(argp1);
40015 ecode2 = SWIG_AsVal_int(obj1, &val2);
40016 if (!SWIG_IsOK(ecode2)) {
40017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40018 }
40019 arg2 = static_cast< int >(val2);
40020 {
40021 PyThreadState* __tstate = wxPyBeginAllowThreads();
40022 result = (bool)(arg1)->ScrollPages(arg2);
40023 wxPyEndAllowThreads(__tstate);
40024 if (PyErr_Occurred()) SWIG_fail;
40025 }
40026 {
40027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40028 }
40029 return resultobj;
40030 fail:
40031 return NULL;
40032 }
40033
40034
40035 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40036 PyObject *resultobj = 0;
40037 wxWindow *arg1 = (wxWindow *) 0 ;
40038 bool result;
40039 void *argp1 = 0 ;
40040 int res1 = 0 ;
40041 PyObject *swig_obj[1] ;
40042
40043 if (!args) SWIG_fail;
40044 swig_obj[0] = args;
40045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40046 if (!SWIG_IsOK(res1)) {
40047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40048 }
40049 arg1 = reinterpret_cast< wxWindow * >(argp1);
40050 {
40051 PyThreadState* __tstate = wxPyBeginAllowThreads();
40052 result = (bool)(arg1)->LineUp();
40053 wxPyEndAllowThreads(__tstate);
40054 if (PyErr_Occurred()) SWIG_fail;
40055 }
40056 {
40057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40058 }
40059 return resultobj;
40060 fail:
40061 return NULL;
40062 }
40063
40064
40065 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40066 PyObject *resultobj = 0;
40067 wxWindow *arg1 = (wxWindow *) 0 ;
40068 bool result;
40069 void *argp1 = 0 ;
40070 int res1 = 0 ;
40071 PyObject *swig_obj[1] ;
40072
40073 if (!args) SWIG_fail;
40074 swig_obj[0] = args;
40075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40076 if (!SWIG_IsOK(res1)) {
40077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40078 }
40079 arg1 = reinterpret_cast< wxWindow * >(argp1);
40080 {
40081 PyThreadState* __tstate = wxPyBeginAllowThreads();
40082 result = (bool)(arg1)->LineDown();
40083 wxPyEndAllowThreads(__tstate);
40084 if (PyErr_Occurred()) SWIG_fail;
40085 }
40086 {
40087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40088 }
40089 return resultobj;
40090 fail:
40091 return NULL;
40092 }
40093
40094
40095 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40096 PyObject *resultobj = 0;
40097 wxWindow *arg1 = (wxWindow *) 0 ;
40098 bool result;
40099 void *argp1 = 0 ;
40100 int res1 = 0 ;
40101 PyObject *swig_obj[1] ;
40102
40103 if (!args) SWIG_fail;
40104 swig_obj[0] = args;
40105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40106 if (!SWIG_IsOK(res1)) {
40107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40108 }
40109 arg1 = reinterpret_cast< wxWindow * >(argp1);
40110 {
40111 PyThreadState* __tstate = wxPyBeginAllowThreads();
40112 result = (bool)(arg1)->PageUp();
40113 wxPyEndAllowThreads(__tstate);
40114 if (PyErr_Occurred()) SWIG_fail;
40115 }
40116 {
40117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40118 }
40119 return resultobj;
40120 fail:
40121 return NULL;
40122 }
40123
40124
40125 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40126 PyObject *resultobj = 0;
40127 wxWindow *arg1 = (wxWindow *) 0 ;
40128 bool result;
40129 void *argp1 = 0 ;
40130 int res1 = 0 ;
40131 PyObject *swig_obj[1] ;
40132
40133 if (!args) SWIG_fail;
40134 swig_obj[0] = args;
40135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40136 if (!SWIG_IsOK(res1)) {
40137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40138 }
40139 arg1 = reinterpret_cast< wxWindow * >(argp1);
40140 {
40141 PyThreadState* __tstate = wxPyBeginAllowThreads();
40142 result = (bool)(arg1)->PageDown();
40143 wxPyEndAllowThreads(__tstate);
40144 if (PyErr_Occurred()) SWIG_fail;
40145 }
40146 {
40147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40148 }
40149 return resultobj;
40150 fail:
40151 return NULL;
40152 }
40153
40154
40155 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40156 PyObject *resultobj = 0;
40157 wxWindow *arg1 = (wxWindow *) 0 ;
40158 wxString *arg2 = 0 ;
40159 void *argp1 = 0 ;
40160 int res1 = 0 ;
40161 bool temp2 = false ;
40162 PyObject * obj0 = 0 ;
40163 PyObject * obj1 = 0 ;
40164 char * kwnames[] = {
40165 (char *) "self",(char *) "text", NULL
40166 };
40167
40168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40170 if (!SWIG_IsOK(res1)) {
40171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40172 }
40173 arg1 = reinterpret_cast< wxWindow * >(argp1);
40174 {
40175 arg2 = wxString_in_helper(obj1);
40176 if (arg2 == NULL) SWIG_fail;
40177 temp2 = true;
40178 }
40179 {
40180 PyThreadState* __tstate = wxPyBeginAllowThreads();
40181 (arg1)->SetHelpText((wxString const &)*arg2);
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 resultobj = SWIG_Py_Void();
40186 {
40187 if (temp2)
40188 delete arg2;
40189 }
40190 return resultobj;
40191 fail:
40192 {
40193 if (temp2)
40194 delete arg2;
40195 }
40196 return NULL;
40197 }
40198
40199
40200 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40201 PyObject *resultobj = 0;
40202 wxWindow *arg1 = (wxWindow *) 0 ;
40203 wxString *arg2 = 0 ;
40204 void *argp1 = 0 ;
40205 int res1 = 0 ;
40206 bool temp2 = false ;
40207 PyObject * obj0 = 0 ;
40208 PyObject * obj1 = 0 ;
40209 char * kwnames[] = {
40210 (char *) "self",(char *) "text", NULL
40211 };
40212
40213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40215 if (!SWIG_IsOK(res1)) {
40216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40217 }
40218 arg1 = reinterpret_cast< wxWindow * >(argp1);
40219 {
40220 arg2 = wxString_in_helper(obj1);
40221 if (arg2 == NULL) SWIG_fail;
40222 temp2 = true;
40223 }
40224 {
40225 PyThreadState* __tstate = wxPyBeginAllowThreads();
40226 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40227 wxPyEndAllowThreads(__tstate);
40228 if (PyErr_Occurred()) SWIG_fail;
40229 }
40230 resultobj = SWIG_Py_Void();
40231 {
40232 if (temp2)
40233 delete arg2;
40234 }
40235 return resultobj;
40236 fail:
40237 {
40238 if (temp2)
40239 delete arg2;
40240 }
40241 return NULL;
40242 }
40243
40244
40245 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40246 PyObject *resultobj = 0;
40247 wxWindow *arg1 = (wxWindow *) 0 ;
40248 wxPoint *arg2 = 0 ;
40249 wxHelpEvent::Origin arg3 ;
40250 wxString result;
40251 void *argp1 = 0 ;
40252 int res1 = 0 ;
40253 wxPoint temp2 ;
40254 void *argp3 ;
40255 int res3 = 0 ;
40256 PyObject * obj0 = 0 ;
40257 PyObject * obj1 = 0 ;
40258 PyObject * obj2 = 0 ;
40259 char * kwnames[] = {
40260 (char *) "self",(char *) "pt",(char *) "origin", NULL
40261 };
40262
40263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40265 if (!SWIG_IsOK(res1)) {
40266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40267 }
40268 arg1 = reinterpret_cast< wxWindow * >(argp1);
40269 {
40270 arg2 = &temp2;
40271 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40272 }
40273 {
40274 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40275 if (!SWIG_IsOK(res3)) {
40276 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40277 }
40278 if (!argp3) {
40279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40280 } else {
40281 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40282 arg3 = *temp;
40283 if (SWIG_IsNewObj(res3)) delete temp;
40284 }
40285 }
40286 {
40287 PyThreadState* __tstate = wxPyBeginAllowThreads();
40288 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40289 wxPyEndAllowThreads(__tstate);
40290 if (PyErr_Occurred()) SWIG_fail;
40291 }
40292 {
40293 #if wxUSE_UNICODE
40294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40295 #else
40296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40297 #endif
40298 }
40299 return resultobj;
40300 fail:
40301 return NULL;
40302 }
40303
40304
40305 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40306 PyObject *resultobj = 0;
40307 wxWindow *arg1 = (wxWindow *) 0 ;
40308 wxString result;
40309 void *argp1 = 0 ;
40310 int res1 = 0 ;
40311 PyObject *swig_obj[1] ;
40312
40313 if (!args) SWIG_fail;
40314 swig_obj[0] = args;
40315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40316 if (!SWIG_IsOK(res1)) {
40317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40318 }
40319 arg1 = reinterpret_cast< wxWindow * >(argp1);
40320 {
40321 PyThreadState* __tstate = wxPyBeginAllowThreads();
40322 result = ((wxWindow const *)arg1)->GetHelpText();
40323 wxPyEndAllowThreads(__tstate);
40324 if (PyErr_Occurred()) SWIG_fail;
40325 }
40326 {
40327 #if wxUSE_UNICODE
40328 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40329 #else
40330 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40331 #endif
40332 }
40333 return resultobj;
40334 fail:
40335 return NULL;
40336 }
40337
40338
40339 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40340 PyObject *resultobj = 0;
40341 wxWindow *arg1 = (wxWindow *) 0 ;
40342 wxString *arg2 = 0 ;
40343 void *argp1 = 0 ;
40344 int res1 = 0 ;
40345 bool temp2 = false ;
40346 PyObject * obj0 = 0 ;
40347 PyObject * obj1 = 0 ;
40348 char * kwnames[] = {
40349 (char *) "self",(char *) "tip", NULL
40350 };
40351
40352 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40353 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40354 if (!SWIG_IsOK(res1)) {
40355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40356 }
40357 arg1 = reinterpret_cast< wxWindow * >(argp1);
40358 {
40359 arg2 = wxString_in_helper(obj1);
40360 if (arg2 == NULL) SWIG_fail;
40361 temp2 = true;
40362 }
40363 {
40364 PyThreadState* __tstate = wxPyBeginAllowThreads();
40365 (arg1)->SetToolTip((wxString const &)*arg2);
40366 wxPyEndAllowThreads(__tstate);
40367 if (PyErr_Occurred()) SWIG_fail;
40368 }
40369 resultobj = SWIG_Py_Void();
40370 {
40371 if (temp2)
40372 delete arg2;
40373 }
40374 return resultobj;
40375 fail:
40376 {
40377 if (temp2)
40378 delete arg2;
40379 }
40380 return NULL;
40381 }
40382
40383
40384 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40385 PyObject *resultobj = 0;
40386 wxWindow *arg1 = (wxWindow *) 0 ;
40387 wxToolTip *arg2 = (wxToolTip *) 0 ;
40388 void *argp1 = 0 ;
40389 int res1 = 0 ;
40390 int res2 = 0 ;
40391 PyObject * obj0 = 0 ;
40392 PyObject * obj1 = 0 ;
40393 char * kwnames[] = {
40394 (char *) "self",(char *) "tip", NULL
40395 };
40396
40397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40399 if (!SWIG_IsOK(res1)) {
40400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40401 }
40402 arg1 = reinterpret_cast< wxWindow * >(argp1);
40403 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40404 if (!SWIG_IsOK(res2)) {
40405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40406 }
40407 {
40408 PyThreadState* __tstate = wxPyBeginAllowThreads();
40409 (arg1)->SetToolTip(arg2);
40410 wxPyEndAllowThreads(__tstate);
40411 if (PyErr_Occurred()) SWIG_fail;
40412 }
40413 resultobj = SWIG_Py_Void();
40414 return resultobj;
40415 fail:
40416 return NULL;
40417 }
40418
40419
40420 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40421 PyObject *resultobj = 0;
40422 wxWindow *arg1 = (wxWindow *) 0 ;
40423 wxToolTip *result = 0 ;
40424 void *argp1 = 0 ;
40425 int res1 = 0 ;
40426 PyObject *swig_obj[1] ;
40427
40428 if (!args) SWIG_fail;
40429 swig_obj[0] = args;
40430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40431 if (!SWIG_IsOK(res1)) {
40432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40433 }
40434 arg1 = reinterpret_cast< wxWindow * >(argp1);
40435 {
40436 PyThreadState* __tstate = wxPyBeginAllowThreads();
40437 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40438 wxPyEndAllowThreads(__tstate);
40439 if (PyErr_Occurred()) SWIG_fail;
40440 }
40441 {
40442 resultobj = wxPyMake_wxObject(result, (bool)0);
40443 }
40444 return resultobj;
40445 fail:
40446 return NULL;
40447 }
40448
40449
40450 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40451 PyObject *resultobj = 0;
40452 wxWindow *arg1 = (wxWindow *) 0 ;
40453 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40454 void *argp1 = 0 ;
40455 int res1 = 0 ;
40456 int res2 = 0 ;
40457 PyObject * obj0 = 0 ;
40458 PyObject * obj1 = 0 ;
40459 char * kwnames[] = {
40460 (char *) "self",(char *) "dropTarget", NULL
40461 };
40462
40463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40465 if (!SWIG_IsOK(res1)) {
40466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40467 }
40468 arg1 = reinterpret_cast< wxWindow * >(argp1);
40469 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40470 if (!SWIG_IsOK(res2)) {
40471 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40472 }
40473 {
40474 PyThreadState* __tstate = wxPyBeginAllowThreads();
40475 (arg1)->SetDropTarget(arg2);
40476 wxPyEndAllowThreads(__tstate);
40477 if (PyErr_Occurred()) SWIG_fail;
40478 }
40479 resultobj = SWIG_Py_Void();
40480 return resultobj;
40481 fail:
40482 return NULL;
40483 }
40484
40485
40486 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40487 PyObject *resultobj = 0;
40488 wxWindow *arg1 = (wxWindow *) 0 ;
40489 wxPyDropTarget *result = 0 ;
40490 void *argp1 = 0 ;
40491 int res1 = 0 ;
40492 PyObject *swig_obj[1] ;
40493
40494 if (!args) SWIG_fail;
40495 swig_obj[0] = args;
40496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40497 if (!SWIG_IsOK(res1)) {
40498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40499 }
40500 arg1 = reinterpret_cast< wxWindow * >(argp1);
40501 {
40502 PyThreadState* __tstate = wxPyBeginAllowThreads();
40503 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40504 wxPyEndAllowThreads(__tstate);
40505 if (PyErr_Occurred()) SWIG_fail;
40506 }
40507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40508 return resultobj;
40509 fail:
40510 return NULL;
40511 }
40512
40513
40514 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40515 PyObject *resultobj = 0;
40516 wxWindow *arg1 = (wxWindow *) 0 ;
40517 bool arg2 ;
40518 void *argp1 = 0 ;
40519 int res1 = 0 ;
40520 bool val2 ;
40521 int ecode2 = 0 ;
40522 PyObject * obj0 = 0 ;
40523 PyObject * obj1 = 0 ;
40524 char * kwnames[] = {
40525 (char *) "self",(char *) "accept", NULL
40526 };
40527
40528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40530 if (!SWIG_IsOK(res1)) {
40531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40532 }
40533 arg1 = reinterpret_cast< wxWindow * >(argp1);
40534 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40535 if (!SWIG_IsOK(ecode2)) {
40536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40537 }
40538 arg2 = static_cast< bool >(val2);
40539 {
40540 PyThreadState* __tstate = wxPyBeginAllowThreads();
40541 (arg1)->DragAcceptFiles(arg2);
40542 wxPyEndAllowThreads(__tstate);
40543 if (PyErr_Occurred()) SWIG_fail;
40544 }
40545 resultobj = SWIG_Py_Void();
40546 return resultobj;
40547 fail:
40548 return NULL;
40549 }
40550
40551
40552 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40553 PyObject *resultobj = 0;
40554 wxWindow *arg1 = (wxWindow *) 0 ;
40555 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40556 void *argp1 = 0 ;
40557 int res1 = 0 ;
40558 int res2 = 0 ;
40559 PyObject * obj0 = 0 ;
40560 PyObject * obj1 = 0 ;
40561 char * kwnames[] = {
40562 (char *) "self",(char *) "constraints", NULL
40563 };
40564
40565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40567 if (!SWIG_IsOK(res1)) {
40568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40569 }
40570 arg1 = reinterpret_cast< wxWindow * >(argp1);
40571 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40572 if (!SWIG_IsOK(res2)) {
40573 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40574 }
40575 {
40576 PyThreadState* __tstate = wxPyBeginAllowThreads();
40577 (arg1)->SetConstraints(arg2);
40578 wxPyEndAllowThreads(__tstate);
40579 if (PyErr_Occurred()) SWIG_fail;
40580 }
40581 resultobj = SWIG_Py_Void();
40582 return resultobj;
40583 fail:
40584 return NULL;
40585 }
40586
40587
40588 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40589 PyObject *resultobj = 0;
40590 wxWindow *arg1 = (wxWindow *) 0 ;
40591 wxLayoutConstraints *result = 0 ;
40592 void *argp1 = 0 ;
40593 int res1 = 0 ;
40594 PyObject *swig_obj[1] ;
40595
40596 if (!args) SWIG_fail;
40597 swig_obj[0] = args;
40598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40599 if (!SWIG_IsOK(res1)) {
40600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40601 }
40602 arg1 = reinterpret_cast< wxWindow * >(argp1);
40603 {
40604 PyThreadState* __tstate = wxPyBeginAllowThreads();
40605 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40606 wxPyEndAllowThreads(__tstate);
40607 if (PyErr_Occurred()) SWIG_fail;
40608 }
40609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40610 return resultobj;
40611 fail:
40612 return NULL;
40613 }
40614
40615
40616 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40617 PyObject *resultobj = 0;
40618 wxWindow *arg1 = (wxWindow *) 0 ;
40619 bool arg2 ;
40620 void *argp1 = 0 ;
40621 int res1 = 0 ;
40622 bool val2 ;
40623 int ecode2 = 0 ;
40624 PyObject * obj0 = 0 ;
40625 PyObject * obj1 = 0 ;
40626 char * kwnames[] = {
40627 (char *) "self",(char *) "autoLayout", NULL
40628 };
40629
40630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40632 if (!SWIG_IsOK(res1)) {
40633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40634 }
40635 arg1 = reinterpret_cast< wxWindow * >(argp1);
40636 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40637 if (!SWIG_IsOK(ecode2)) {
40638 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40639 }
40640 arg2 = static_cast< bool >(val2);
40641 {
40642 PyThreadState* __tstate = wxPyBeginAllowThreads();
40643 (arg1)->SetAutoLayout(arg2);
40644 wxPyEndAllowThreads(__tstate);
40645 if (PyErr_Occurred()) SWIG_fail;
40646 }
40647 resultobj = SWIG_Py_Void();
40648 return resultobj;
40649 fail:
40650 return NULL;
40651 }
40652
40653
40654 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40655 PyObject *resultobj = 0;
40656 wxWindow *arg1 = (wxWindow *) 0 ;
40657 bool result;
40658 void *argp1 = 0 ;
40659 int res1 = 0 ;
40660 PyObject *swig_obj[1] ;
40661
40662 if (!args) SWIG_fail;
40663 swig_obj[0] = args;
40664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40665 if (!SWIG_IsOK(res1)) {
40666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40667 }
40668 arg1 = reinterpret_cast< wxWindow * >(argp1);
40669 {
40670 PyThreadState* __tstate = wxPyBeginAllowThreads();
40671 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40672 wxPyEndAllowThreads(__tstate);
40673 if (PyErr_Occurred()) SWIG_fail;
40674 }
40675 {
40676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40677 }
40678 return resultobj;
40679 fail:
40680 return NULL;
40681 }
40682
40683
40684 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40685 PyObject *resultobj = 0;
40686 wxWindow *arg1 = (wxWindow *) 0 ;
40687 bool result;
40688 void *argp1 = 0 ;
40689 int res1 = 0 ;
40690 PyObject *swig_obj[1] ;
40691
40692 if (!args) SWIG_fail;
40693 swig_obj[0] = args;
40694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40695 if (!SWIG_IsOK(res1)) {
40696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40697 }
40698 arg1 = reinterpret_cast< wxWindow * >(argp1);
40699 {
40700 PyThreadState* __tstate = wxPyBeginAllowThreads();
40701 result = (bool)(arg1)->Layout();
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 {
40706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40707 }
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40715 PyObject *resultobj = 0;
40716 wxWindow *arg1 = (wxWindow *) 0 ;
40717 wxSizer *arg2 = (wxSizer *) 0 ;
40718 bool arg3 = (bool) true ;
40719 void *argp1 = 0 ;
40720 int res1 = 0 ;
40721 int res2 = 0 ;
40722 bool val3 ;
40723 int ecode3 = 0 ;
40724 PyObject * obj0 = 0 ;
40725 PyObject * obj1 = 0 ;
40726 PyObject * obj2 = 0 ;
40727 char * kwnames[] = {
40728 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40729 };
40730
40731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40733 if (!SWIG_IsOK(res1)) {
40734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40735 }
40736 arg1 = reinterpret_cast< wxWindow * >(argp1);
40737 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40738 if (!SWIG_IsOK(res2)) {
40739 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40740 }
40741 if (obj2) {
40742 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40743 if (!SWIG_IsOK(ecode3)) {
40744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40745 }
40746 arg3 = static_cast< bool >(val3);
40747 }
40748 {
40749 PyThreadState* __tstate = wxPyBeginAllowThreads();
40750 (arg1)->SetSizer(arg2,arg3);
40751 wxPyEndAllowThreads(__tstate);
40752 if (PyErr_Occurred()) SWIG_fail;
40753 }
40754 resultobj = SWIG_Py_Void();
40755 return resultobj;
40756 fail:
40757 return NULL;
40758 }
40759
40760
40761 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40762 PyObject *resultobj = 0;
40763 wxWindow *arg1 = (wxWindow *) 0 ;
40764 wxSizer *arg2 = (wxSizer *) 0 ;
40765 bool arg3 = (bool) true ;
40766 void *argp1 = 0 ;
40767 int res1 = 0 ;
40768 int res2 = 0 ;
40769 bool val3 ;
40770 int ecode3 = 0 ;
40771 PyObject * obj0 = 0 ;
40772 PyObject * obj1 = 0 ;
40773 PyObject * obj2 = 0 ;
40774 char * kwnames[] = {
40775 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40776 };
40777
40778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40780 if (!SWIG_IsOK(res1)) {
40781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40782 }
40783 arg1 = reinterpret_cast< wxWindow * >(argp1);
40784 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40785 if (!SWIG_IsOK(res2)) {
40786 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40787 }
40788 if (obj2) {
40789 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40790 if (!SWIG_IsOK(ecode3)) {
40791 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40792 }
40793 arg3 = static_cast< bool >(val3);
40794 }
40795 {
40796 PyThreadState* __tstate = wxPyBeginAllowThreads();
40797 (arg1)->SetSizerAndFit(arg2,arg3);
40798 wxPyEndAllowThreads(__tstate);
40799 if (PyErr_Occurred()) SWIG_fail;
40800 }
40801 resultobj = SWIG_Py_Void();
40802 return resultobj;
40803 fail:
40804 return NULL;
40805 }
40806
40807
40808 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40809 PyObject *resultobj = 0;
40810 wxWindow *arg1 = (wxWindow *) 0 ;
40811 wxSizer *result = 0 ;
40812 void *argp1 = 0 ;
40813 int res1 = 0 ;
40814 PyObject *swig_obj[1] ;
40815
40816 if (!args) SWIG_fail;
40817 swig_obj[0] = args;
40818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40819 if (!SWIG_IsOK(res1)) {
40820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40821 }
40822 arg1 = reinterpret_cast< wxWindow * >(argp1);
40823 {
40824 PyThreadState* __tstate = wxPyBeginAllowThreads();
40825 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
40826 wxPyEndAllowThreads(__tstate);
40827 if (PyErr_Occurred()) SWIG_fail;
40828 }
40829 {
40830 resultobj = wxPyMake_wxObject(result, (bool)0);
40831 }
40832 return resultobj;
40833 fail:
40834 return NULL;
40835 }
40836
40837
40838 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40839 PyObject *resultobj = 0;
40840 wxWindow *arg1 = (wxWindow *) 0 ;
40841 wxSizer *arg2 = (wxSizer *) 0 ;
40842 void *argp1 = 0 ;
40843 int res1 = 0 ;
40844 void *argp2 = 0 ;
40845 int res2 = 0 ;
40846 PyObject * obj0 = 0 ;
40847 PyObject * obj1 = 0 ;
40848 char * kwnames[] = {
40849 (char *) "self",(char *) "sizer", NULL
40850 };
40851
40852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
40853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40854 if (!SWIG_IsOK(res1)) {
40855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40856 }
40857 arg1 = reinterpret_cast< wxWindow * >(argp1);
40858 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
40859 if (!SWIG_IsOK(res2)) {
40860 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40861 }
40862 arg2 = reinterpret_cast< wxSizer * >(argp2);
40863 {
40864 PyThreadState* __tstate = wxPyBeginAllowThreads();
40865 (arg1)->SetContainingSizer(arg2);
40866 wxPyEndAllowThreads(__tstate);
40867 if (PyErr_Occurred()) SWIG_fail;
40868 }
40869 resultobj = SWIG_Py_Void();
40870 return resultobj;
40871 fail:
40872 return NULL;
40873 }
40874
40875
40876 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40877 PyObject *resultobj = 0;
40878 wxWindow *arg1 = (wxWindow *) 0 ;
40879 wxSizer *result = 0 ;
40880 void *argp1 = 0 ;
40881 int res1 = 0 ;
40882 PyObject *swig_obj[1] ;
40883
40884 if (!args) SWIG_fail;
40885 swig_obj[0] = args;
40886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40887 if (!SWIG_IsOK(res1)) {
40888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
40889 }
40890 arg1 = reinterpret_cast< wxWindow * >(argp1);
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = wxPyMake_wxObject(result, (bool)0);
40899 }
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40907 PyObject *resultobj = 0;
40908 wxWindow *arg1 = (wxWindow *) 0 ;
40909 void *argp1 = 0 ;
40910 int res1 = 0 ;
40911 PyObject *swig_obj[1] ;
40912
40913 if (!args) SWIG_fail;
40914 swig_obj[0] = args;
40915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40916 if (!SWIG_IsOK(res1)) {
40917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
40918 }
40919 arg1 = reinterpret_cast< wxWindow * >(argp1);
40920 {
40921 PyThreadState* __tstate = wxPyBeginAllowThreads();
40922 (arg1)->InheritAttributes();
40923 wxPyEndAllowThreads(__tstate);
40924 if (PyErr_Occurred()) SWIG_fail;
40925 }
40926 resultobj = SWIG_Py_Void();
40927 return resultobj;
40928 fail:
40929 return NULL;
40930 }
40931
40932
40933 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40934 PyObject *resultobj = 0;
40935 wxWindow *arg1 = (wxWindow *) 0 ;
40936 bool result;
40937 void *argp1 = 0 ;
40938 int res1 = 0 ;
40939 PyObject *swig_obj[1] ;
40940
40941 if (!args) SWIG_fail;
40942 swig_obj[0] = args;
40943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40944 if (!SWIG_IsOK(res1)) {
40945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
40946 }
40947 arg1 = reinterpret_cast< wxWindow * >(argp1);
40948 {
40949 PyThreadState* __tstate = wxPyBeginAllowThreads();
40950 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
40951 wxPyEndAllowThreads(__tstate);
40952 if (PyErr_Occurred()) SWIG_fail;
40953 }
40954 {
40955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40956 }
40957 return resultobj;
40958 fail:
40959 return NULL;
40960 }
40961
40962
40963 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40964 PyObject *resultobj = 0;
40965 wxWindow *arg1 = (wxWindow *) 0 ;
40966 bool result;
40967 void *argp1 = 0 ;
40968 int res1 = 0 ;
40969 PyObject *swig_obj[1] ;
40970
40971 if (!args) SWIG_fail;
40972 swig_obj[0] = args;
40973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40974 if (!SWIG_IsOK(res1)) {
40975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
40976 }
40977 arg1 = reinterpret_cast< wxWindow * >(argp1);
40978 {
40979 PyThreadState* __tstate = wxPyBeginAllowThreads();
40980 result = (bool)(arg1)->CanSetTransparent();
40981 wxPyEndAllowThreads(__tstate);
40982 if (PyErr_Occurred()) SWIG_fail;
40983 }
40984 {
40985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40986 }
40987 return resultobj;
40988 fail:
40989 return NULL;
40990 }
40991
40992
40993 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40994 PyObject *resultobj = 0;
40995 wxWindow *arg1 = (wxWindow *) 0 ;
40996 byte arg2 ;
40997 bool result;
40998 void *argp1 = 0 ;
40999 int res1 = 0 ;
41000 unsigned char val2 ;
41001 int ecode2 = 0 ;
41002 PyObject * obj0 = 0 ;
41003 PyObject * obj1 = 0 ;
41004 char * kwnames[] = {
41005 (char *) "self",(char *) "alpha", NULL
41006 };
41007
41008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41010 if (!SWIG_IsOK(res1)) {
41011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41012 }
41013 arg1 = reinterpret_cast< wxWindow * >(argp1);
41014 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41015 if (!SWIG_IsOK(ecode2)) {
41016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41017 }
41018 arg2 = static_cast< byte >(val2);
41019 {
41020 PyThreadState* __tstate = wxPyBeginAllowThreads();
41021 result = (bool)(arg1)->SetTransparent(arg2);
41022 wxPyEndAllowThreads(__tstate);
41023 if (PyErr_Occurred()) SWIG_fail;
41024 }
41025 {
41026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41027 }
41028 return resultobj;
41029 fail:
41030 return NULL;
41031 }
41032
41033
41034 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41035 PyObject *obj;
41036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41037 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41038 return SWIG_Py_Void();
41039 }
41040
41041 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41042 return SWIG_Python_InitShadowInstance(args);
41043 }
41044
41045 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41046 PyObject *resultobj = 0;
41047 long arg1 ;
41048 wxWindow *arg2 = (wxWindow *) NULL ;
41049 wxWindow *result = 0 ;
41050 long val1 ;
41051 int ecode1 = 0 ;
41052 void *argp2 = 0 ;
41053 int res2 = 0 ;
41054 PyObject * obj0 = 0 ;
41055 PyObject * obj1 = 0 ;
41056 char * kwnames[] = {
41057 (char *) "id",(char *) "parent", NULL
41058 };
41059
41060 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41061 ecode1 = SWIG_AsVal_long(obj0, &val1);
41062 if (!SWIG_IsOK(ecode1)) {
41063 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41064 }
41065 arg1 = static_cast< long >(val1);
41066 if (obj1) {
41067 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41068 if (!SWIG_IsOK(res2)) {
41069 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41070 }
41071 arg2 = reinterpret_cast< wxWindow * >(argp2);
41072 }
41073 {
41074 if (!wxPyCheckForApp()) SWIG_fail;
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 {
41081 resultobj = wxPyMake_wxObject(result, 0);
41082 }
41083 return resultobj;
41084 fail:
41085 return NULL;
41086 }
41087
41088
41089 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41090 PyObject *resultobj = 0;
41091 wxString *arg1 = 0 ;
41092 wxWindow *arg2 = (wxWindow *) NULL ;
41093 wxWindow *result = 0 ;
41094 bool temp1 = false ;
41095 void *argp2 = 0 ;
41096 int res2 = 0 ;
41097 PyObject * obj0 = 0 ;
41098 PyObject * obj1 = 0 ;
41099 char * kwnames[] = {
41100 (char *) "name",(char *) "parent", NULL
41101 };
41102
41103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41104 {
41105 arg1 = wxString_in_helper(obj0);
41106 if (arg1 == NULL) SWIG_fail;
41107 temp1 = true;
41108 }
41109 if (obj1) {
41110 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41111 if (!SWIG_IsOK(res2)) {
41112 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41113 }
41114 arg2 = reinterpret_cast< wxWindow * >(argp2);
41115 }
41116 {
41117 if (!wxPyCheckForApp()) SWIG_fail;
41118 PyThreadState* __tstate = wxPyBeginAllowThreads();
41119 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41120 wxPyEndAllowThreads(__tstate);
41121 if (PyErr_Occurred()) SWIG_fail;
41122 }
41123 {
41124 resultobj = wxPyMake_wxObject(result, 0);
41125 }
41126 {
41127 if (temp1)
41128 delete arg1;
41129 }
41130 return resultobj;
41131 fail:
41132 {
41133 if (temp1)
41134 delete arg1;
41135 }
41136 return NULL;
41137 }
41138
41139
41140 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41141 PyObject *resultobj = 0;
41142 wxString *arg1 = 0 ;
41143 wxWindow *arg2 = (wxWindow *) NULL ;
41144 wxWindow *result = 0 ;
41145 bool temp1 = false ;
41146 void *argp2 = 0 ;
41147 int res2 = 0 ;
41148 PyObject * obj0 = 0 ;
41149 PyObject * obj1 = 0 ;
41150 char * kwnames[] = {
41151 (char *) "label",(char *) "parent", NULL
41152 };
41153
41154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41155 {
41156 arg1 = wxString_in_helper(obj0);
41157 if (arg1 == NULL) SWIG_fail;
41158 temp1 = true;
41159 }
41160 if (obj1) {
41161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41162 if (!SWIG_IsOK(res2)) {
41163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41164 }
41165 arg2 = reinterpret_cast< wxWindow * >(argp2);
41166 }
41167 {
41168 if (!wxPyCheckForApp()) SWIG_fail;
41169 PyThreadState* __tstate = wxPyBeginAllowThreads();
41170 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41171 wxPyEndAllowThreads(__tstate);
41172 if (PyErr_Occurred()) SWIG_fail;
41173 }
41174 {
41175 resultobj = wxPyMake_wxObject(result, 0);
41176 }
41177 {
41178 if (temp1)
41179 delete arg1;
41180 }
41181 return resultobj;
41182 fail:
41183 {
41184 if (temp1)
41185 delete arg1;
41186 }
41187 return NULL;
41188 }
41189
41190
41191 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41192 PyObject *resultobj = 0;
41193 wxWindow *arg1 = (wxWindow *) 0 ;
41194 unsigned long arg2 ;
41195 wxWindow *result = 0 ;
41196 void *argp1 = 0 ;
41197 int res1 = 0 ;
41198 unsigned long val2 ;
41199 int ecode2 = 0 ;
41200 PyObject * obj0 = 0 ;
41201 PyObject * obj1 = 0 ;
41202 char * kwnames[] = {
41203 (char *) "parent",(char *) "_hWnd", NULL
41204 };
41205
41206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41208 if (!SWIG_IsOK(res1)) {
41209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41210 }
41211 arg1 = reinterpret_cast< wxWindow * >(argp1);
41212 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41213 if (!SWIG_IsOK(ecode2)) {
41214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41215 }
41216 arg2 = static_cast< unsigned long >(val2);
41217 {
41218 PyThreadState* __tstate = wxPyBeginAllowThreads();
41219 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41220 wxPyEndAllowThreads(__tstate);
41221 if (PyErr_Occurred()) SWIG_fail;
41222 }
41223 {
41224 resultobj = wxPyMake_wxObject(result, 0);
41225 }
41226 return resultobj;
41227 fail:
41228 return NULL;
41229 }
41230
41231
41232 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41233 PyObject *resultobj = 0;
41234 PyObject *result = 0 ;
41235
41236 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41237 {
41238 PyThreadState* __tstate = wxPyBeginAllowThreads();
41239 result = (PyObject *)GetTopLevelWindows();
41240 wxPyEndAllowThreads(__tstate);
41241 if (PyErr_Occurred()) SWIG_fail;
41242 }
41243 resultobj = result;
41244 return resultobj;
41245 fail:
41246 return NULL;
41247 }
41248
41249
41250 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41251 PyObject *resultobj = 0;
41252 wxValidator *result = 0 ;
41253
41254 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41255 {
41256 PyThreadState* __tstate = wxPyBeginAllowThreads();
41257 result = (wxValidator *)new wxValidator();
41258 wxPyEndAllowThreads(__tstate);
41259 if (PyErr_Occurred()) SWIG_fail;
41260 }
41261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41262 return resultobj;
41263 fail:
41264 return NULL;
41265 }
41266
41267
41268 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41269 PyObject *resultobj = 0;
41270 wxValidator *arg1 = (wxValidator *) 0 ;
41271 wxValidator *result = 0 ;
41272 void *argp1 = 0 ;
41273 int res1 = 0 ;
41274 PyObject *swig_obj[1] ;
41275
41276 if (!args) SWIG_fail;
41277 swig_obj[0] = args;
41278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41279 if (!SWIG_IsOK(res1)) {
41280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41281 }
41282 arg1 = reinterpret_cast< wxValidator * >(argp1);
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 result = (wxValidator *)(arg1)->Clone();
41286 wxPyEndAllowThreads(__tstate);
41287 if (PyErr_Occurred()) SWIG_fail;
41288 }
41289 {
41290 resultobj = wxPyMake_wxObject(result, 0);
41291 }
41292 return resultobj;
41293 fail:
41294 return NULL;
41295 }
41296
41297
41298 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41299 PyObject *resultobj = 0;
41300 wxValidator *arg1 = (wxValidator *) 0 ;
41301 wxWindow *arg2 = (wxWindow *) 0 ;
41302 bool result;
41303 void *argp1 = 0 ;
41304 int res1 = 0 ;
41305 void *argp2 = 0 ;
41306 int res2 = 0 ;
41307 PyObject * obj0 = 0 ;
41308 PyObject * obj1 = 0 ;
41309 char * kwnames[] = {
41310 (char *) "self",(char *) "parent", NULL
41311 };
41312
41313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41315 if (!SWIG_IsOK(res1)) {
41316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41317 }
41318 arg1 = reinterpret_cast< wxValidator * >(argp1);
41319 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41320 if (!SWIG_IsOK(res2)) {
41321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41322 }
41323 arg2 = reinterpret_cast< wxWindow * >(argp2);
41324 {
41325 PyThreadState* __tstate = wxPyBeginAllowThreads();
41326 result = (bool)(arg1)->Validate(arg2);
41327 wxPyEndAllowThreads(__tstate);
41328 if (PyErr_Occurred()) SWIG_fail;
41329 }
41330 {
41331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41332 }
41333 return resultobj;
41334 fail:
41335 return NULL;
41336 }
41337
41338
41339 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41340 PyObject *resultobj = 0;
41341 wxValidator *arg1 = (wxValidator *) 0 ;
41342 bool result;
41343 void *argp1 = 0 ;
41344 int res1 = 0 ;
41345 PyObject *swig_obj[1] ;
41346
41347 if (!args) SWIG_fail;
41348 swig_obj[0] = args;
41349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41350 if (!SWIG_IsOK(res1)) {
41351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41352 }
41353 arg1 = reinterpret_cast< wxValidator * >(argp1);
41354 {
41355 PyThreadState* __tstate = wxPyBeginAllowThreads();
41356 result = (bool)(arg1)->TransferToWindow();
41357 wxPyEndAllowThreads(__tstate);
41358 if (PyErr_Occurred()) SWIG_fail;
41359 }
41360 {
41361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41362 }
41363 return resultobj;
41364 fail:
41365 return NULL;
41366 }
41367
41368
41369 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41370 PyObject *resultobj = 0;
41371 wxValidator *arg1 = (wxValidator *) 0 ;
41372 bool result;
41373 void *argp1 = 0 ;
41374 int res1 = 0 ;
41375 PyObject *swig_obj[1] ;
41376
41377 if (!args) SWIG_fail;
41378 swig_obj[0] = args;
41379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41380 if (!SWIG_IsOK(res1)) {
41381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41382 }
41383 arg1 = reinterpret_cast< wxValidator * >(argp1);
41384 {
41385 PyThreadState* __tstate = wxPyBeginAllowThreads();
41386 result = (bool)(arg1)->TransferFromWindow();
41387 wxPyEndAllowThreads(__tstate);
41388 if (PyErr_Occurred()) SWIG_fail;
41389 }
41390 {
41391 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41392 }
41393 return resultobj;
41394 fail:
41395 return NULL;
41396 }
41397
41398
41399 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41400 PyObject *resultobj = 0;
41401 wxValidator *arg1 = (wxValidator *) 0 ;
41402 wxWindow *result = 0 ;
41403 void *argp1 = 0 ;
41404 int res1 = 0 ;
41405 PyObject *swig_obj[1] ;
41406
41407 if (!args) SWIG_fail;
41408 swig_obj[0] = args;
41409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41410 if (!SWIG_IsOK(res1)) {
41411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41412 }
41413 arg1 = reinterpret_cast< wxValidator * >(argp1);
41414 {
41415 PyThreadState* __tstate = wxPyBeginAllowThreads();
41416 result = (wxWindow *)(arg1)->GetWindow();
41417 wxPyEndAllowThreads(__tstate);
41418 if (PyErr_Occurred()) SWIG_fail;
41419 }
41420 {
41421 resultobj = wxPyMake_wxObject(result, 0);
41422 }
41423 return resultobj;
41424 fail:
41425 return NULL;
41426 }
41427
41428
41429 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41430 PyObject *resultobj = 0;
41431 wxValidator *arg1 = (wxValidator *) 0 ;
41432 wxWindow *arg2 = (wxWindow *) 0 ;
41433 void *argp1 = 0 ;
41434 int res1 = 0 ;
41435 void *argp2 = 0 ;
41436 int res2 = 0 ;
41437 PyObject * obj0 = 0 ;
41438 PyObject * obj1 = 0 ;
41439 char * kwnames[] = {
41440 (char *) "self",(char *) "window", NULL
41441 };
41442
41443 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41444 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41445 if (!SWIG_IsOK(res1)) {
41446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41447 }
41448 arg1 = reinterpret_cast< wxValidator * >(argp1);
41449 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41450 if (!SWIG_IsOK(res2)) {
41451 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41452 }
41453 arg2 = reinterpret_cast< wxWindow * >(argp2);
41454 {
41455 PyThreadState* __tstate = wxPyBeginAllowThreads();
41456 (arg1)->SetWindow(arg2);
41457 wxPyEndAllowThreads(__tstate);
41458 if (PyErr_Occurred()) SWIG_fail;
41459 }
41460 resultobj = SWIG_Py_Void();
41461 return resultobj;
41462 fail:
41463 return NULL;
41464 }
41465
41466
41467 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41468 PyObject *resultobj = 0;
41469 bool result;
41470
41471 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41472 {
41473 PyThreadState* __tstate = wxPyBeginAllowThreads();
41474 result = (bool)wxValidator::IsSilent();
41475 wxPyEndAllowThreads(__tstate);
41476 if (PyErr_Occurred()) SWIG_fail;
41477 }
41478 {
41479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41480 }
41481 return resultobj;
41482 fail:
41483 return NULL;
41484 }
41485
41486
41487 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41488 PyObject *resultobj = 0;
41489 int arg1 = (int) true ;
41490 int val1 ;
41491 int ecode1 = 0 ;
41492 PyObject * obj0 = 0 ;
41493 char * kwnames[] = {
41494 (char *) "doIt", NULL
41495 };
41496
41497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41498 if (obj0) {
41499 ecode1 = SWIG_AsVal_int(obj0, &val1);
41500 if (!SWIG_IsOK(ecode1)) {
41501 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41502 }
41503 arg1 = static_cast< int >(val1);
41504 }
41505 {
41506 PyThreadState* __tstate = wxPyBeginAllowThreads();
41507 wxValidator::SetBellOnError(arg1);
41508 wxPyEndAllowThreads(__tstate);
41509 if (PyErr_Occurred()) SWIG_fail;
41510 }
41511 resultobj = SWIG_Py_Void();
41512 return resultobj;
41513 fail:
41514 return NULL;
41515 }
41516
41517
41518 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41519 PyObject *obj;
41520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41521 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41522 return SWIG_Py_Void();
41523 }
41524
41525 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41526 return SWIG_Python_InitShadowInstance(args);
41527 }
41528
41529 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41530 PyObject *resultobj = 0;
41531 wxPyValidator *result = 0 ;
41532
41533 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41534 {
41535 PyThreadState* __tstate = wxPyBeginAllowThreads();
41536 result = (wxPyValidator *)new wxPyValidator();
41537 wxPyEndAllowThreads(__tstate);
41538 if (PyErr_Occurred()) SWIG_fail;
41539 }
41540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41541 return resultobj;
41542 fail:
41543 return NULL;
41544 }
41545
41546
41547 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41548 PyObject *resultobj = 0;
41549 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41550 PyObject *arg2 = (PyObject *) 0 ;
41551 PyObject *arg3 = (PyObject *) 0 ;
41552 int arg4 = (int) true ;
41553 void *argp1 = 0 ;
41554 int res1 = 0 ;
41555 int val4 ;
41556 int ecode4 = 0 ;
41557 PyObject * obj0 = 0 ;
41558 PyObject * obj1 = 0 ;
41559 PyObject * obj2 = 0 ;
41560 PyObject * obj3 = 0 ;
41561 char * kwnames[] = {
41562 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41563 };
41564
41565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41567 if (!SWIG_IsOK(res1)) {
41568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41569 }
41570 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41571 arg2 = obj1;
41572 arg3 = obj2;
41573 if (obj3) {
41574 ecode4 = SWIG_AsVal_int(obj3, &val4);
41575 if (!SWIG_IsOK(ecode4)) {
41576 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41577 }
41578 arg4 = static_cast< int >(val4);
41579 }
41580 {
41581 PyThreadState* __tstate = wxPyBeginAllowThreads();
41582 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 resultobj = SWIG_Py_Void();
41587 return resultobj;
41588 fail:
41589 return NULL;
41590 }
41591
41592
41593 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41594 PyObject *obj;
41595 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41596 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41597 return SWIG_Py_Void();
41598 }
41599
41600 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41601 return SWIG_Python_InitShadowInstance(args);
41602 }
41603
41604 SWIGINTERN int DefaultValidator_set(PyObject *) {
41605 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41606 return 1;
41607 }
41608
41609
41610 SWIGINTERN PyObject *DefaultValidator_get(void) {
41611 PyObject *pyobj = 0;
41612
41613 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41614 return pyobj;
41615 }
41616
41617
41618 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41619 PyObject *resultobj = 0;
41620 wxString const &arg1_defvalue = wxPyEmptyString ;
41621 wxString *arg1 = (wxString *) &arg1_defvalue ;
41622 long arg2 = (long) 0 ;
41623 wxMenu *result = 0 ;
41624 bool temp1 = false ;
41625 long val2 ;
41626 int ecode2 = 0 ;
41627 PyObject * obj0 = 0 ;
41628 PyObject * obj1 = 0 ;
41629 char * kwnames[] = {
41630 (char *) "title",(char *) "style", NULL
41631 };
41632
41633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41634 if (obj0) {
41635 {
41636 arg1 = wxString_in_helper(obj0);
41637 if (arg1 == NULL) SWIG_fail;
41638 temp1 = true;
41639 }
41640 }
41641 if (obj1) {
41642 ecode2 = SWIG_AsVal_long(obj1, &val2);
41643 if (!SWIG_IsOK(ecode2)) {
41644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41645 }
41646 arg2 = static_cast< long >(val2);
41647 }
41648 {
41649 if (!wxPyCheckForApp()) SWIG_fail;
41650 PyThreadState* __tstate = wxPyBeginAllowThreads();
41651 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41652 wxPyEndAllowThreads(__tstate);
41653 if (PyErr_Occurred()) SWIG_fail;
41654 }
41655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41656 {
41657 if (temp1)
41658 delete arg1;
41659 }
41660 return resultobj;
41661 fail:
41662 {
41663 if (temp1)
41664 delete arg1;
41665 }
41666 return NULL;
41667 }
41668
41669
41670 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41671 PyObject *resultobj = 0;
41672 wxMenu *arg1 = (wxMenu *) 0 ;
41673 int arg2 ;
41674 wxString const &arg3_defvalue = wxPyEmptyString ;
41675 wxString *arg3 = (wxString *) &arg3_defvalue ;
41676 wxString const &arg4_defvalue = wxPyEmptyString ;
41677 wxString *arg4 = (wxString *) &arg4_defvalue ;
41678 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41679 wxMenuItem *result = 0 ;
41680 void *argp1 = 0 ;
41681 int res1 = 0 ;
41682 int val2 ;
41683 int ecode2 = 0 ;
41684 bool temp3 = false ;
41685 bool temp4 = false ;
41686 int val5 ;
41687 int ecode5 = 0 ;
41688 PyObject * obj0 = 0 ;
41689 PyObject * obj1 = 0 ;
41690 PyObject * obj2 = 0 ;
41691 PyObject * obj3 = 0 ;
41692 PyObject * obj4 = 0 ;
41693 char * kwnames[] = {
41694 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41695 };
41696
41697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41699 if (!SWIG_IsOK(res1)) {
41700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41701 }
41702 arg1 = reinterpret_cast< wxMenu * >(argp1);
41703 ecode2 = SWIG_AsVal_int(obj1, &val2);
41704 if (!SWIG_IsOK(ecode2)) {
41705 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41706 }
41707 arg2 = static_cast< int >(val2);
41708 if (obj2) {
41709 {
41710 arg3 = wxString_in_helper(obj2);
41711 if (arg3 == NULL) SWIG_fail;
41712 temp3 = true;
41713 }
41714 }
41715 if (obj3) {
41716 {
41717 arg4 = wxString_in_helper(obj3);
41718 if (arg4 == NULL) SWIG_fail;
41719 temp4 = true;
41720 }
41721 }
41722 if (obj4) {
41723 ecode5 = SWIG_AsVal_int(obj4, &val5);
41724 if (!SWIG_IsOK(ecode5)) {
41725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41726 }
41727 arg5 = static_cast< wxItemKind >(val5);
41728 }
41729 {
41730 PyThreadState* __tstate = wxPyBeginAllowThreads();
41731 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41732 wxPyEndAllowThreads(__tstate);
41733 if (PyErr_Occurred()) SWIG_fail;
41734 }
41735 {
41736 resultobj = wxPyMake_wxObject(result, (bool)0);
41737 }
41738 {
41739 if (temp3)
41740 delete arg3;
41741 }
41742 {
41743 if (temp4)
41744 delete arg4;
41745 }
41746 return resultobj;
41747 fail:
41748 {
41749 if (temp3)
41750 delete arg3;
41751 }
41752 {
41753 if (temp4)
41754 delete arg4;
41755 }
41756 return NULL;
41757 }
41758
41759
41760 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41761 PyObject *resultobj = 0;
41762 wxMenu *arg1 = (wxMenu *) 0 ;
41763 wxMenuItem *result = 0 ;
41764 void *argp1 = 0 ;
41765 int res1 = 0 ;
41766 PyObject *swig_obj[1] ;
41767
41768 if (!args) SWIG_fail;
41769 swig_obj[0] = args;
41770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41771 if (!SWIG_IsOK(res1)) {
41772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41773 }
41774 arg1 = reinterpret_cast< wxMenu * >(argp1);
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 result = (wxMenuItem *)(arg1)->AppendSeparator();
41778 wxPyEndAllowThreads(__tstate);
41779 if (PyErr_Occurred()) SWIG_fail;
41780 }
41781 {
41782 resultobj = wxPyMake_wxObject(result, (bool)0);
41783 }
41784 return resultobj;
41785 fail:
41786 return NULL;
41787 }
41788
41789
41790 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41791 PyObject *resultobj = 0;
41792 wxMenu *arg1 = (wxMenu *) 0 ;
41793 int arg2 ;
41794 wxString *arg3 = 0 ;
41795 wxString const &arg4_defvalue = wxPyEmptyString ;
41796 wxString *arg4 = (wxString *) &arg4_defvalue ;
41797 wxMenuItem *result = 0 ;
41798 void *argp1 = 0 ;
41799 int res1 = 0 ;
41800 int val2 ;
41801 int ecode2 = 0 ;
41802 bool temp3 = false ;
41803 bool temp4 = false ;
41804 PyObject * obj0 = 0 ;
41805 PyObject * obj1 = 0 ;
41806 PyObject * obj2 = 0 ;
41807 PyObject * obj3 = 0 ;
41808 char * kwnames[] = {
41809 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41810 };
41811
41812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41814 if (!SWIG_IsOK(res1)) {
41815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41816 }
41817 arg1 = reinterpret_cast< wxMenu * >(argp1);
41818 ecode2 = SWIG_AsVal_int(obj1, &val2);
41819 if (!SWIG_IsOK(ecode2)) {
41820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
41821 }
41822 arg2 = static_cast< int >(val2);
41823 {
41824 arg3 = wxString_in_helper(obj2);
41825 if (arg3 == NULL) SWIG_fail;
41826 temp3 = true;
41827 }
41828 if (obj3) {
41829 {
41830 arg4 = wxString_in_helper(obj3);
41831 if (arg4 == NULL) SWIG_fail;
41832 temp4 = true;
41833 }
41834 }
41835 {
41836 PyThreadState* __tstate = wxPyBeginAllowThreads();
41837 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41838 wxPyEndAllowThreads(__tstate);
41839 if (PyErr_Occurred()) SWIG_fail;
41840 }
41841 {
41842 resultobj = wxPyMake_wxObject(result, (bool)0);
41843 }
41844 {
41845 if (temp3)
41846 delete arg3;
41847 }
41848 {
41849 if (temp4)
41850 delete arg4;
41851 }
41852 return resultobj;
41853 fail:
41854 {
41855 if (temp3)
41856 delete arg3;
41857 }
41858 {
41859 if (temp4)
41860 delete arg4;
41861 }
41862 return NULL;
41863 }
41864
41865
41866 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41867 PyObject *resultobj = 0;
41868 wxMenu *arg1 = (wxMenu *) 0 ;
41869 int arg2 ;
41870 wxString *arg3 = 0 ;
41871 wxString const &arg4_defvalue = wxPyEmptyString ;
41872 wxString *arg4 = (wxString *) &arg4_defvalue ;
41873 wxMenuItem *result = 0 ;
41874 void *argp1 = 0 ;
41875 int res1 = 0 ;
41876 int val2 ;
41877 int ecode2 = 0 ;
41878 bool temp3 = false ;
41879 bool temp4 = false ;
41880 PyObject * obj0 = 0 ;
41881 PyObject * obj1 = 0 ;
41882 PyObject * obj2 = 0 ;
41883 PyObject * obj3 = 0 ;
41884 char * kwnames[] = {
41885 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
41886 };
41887
41888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41890 if (!SWIG_IsOK(res1)) {
41891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41892 }
41893 arg1 = reinterpret_cast< wxMenu * >(argp1);
41894 ecode2 = SWIG_AsVal_int(obj1, &val2);
41895 if (!SWIG_IsOK(ecode2)) {
41896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
41897 }
41898 arg2 = static_cast< int >(val2);
41899 {
41900 arg3 = wxString_in_helper(obj2);
41901 if (arg3 == NULL) SWIG_fail;
41902 temp3 = true;
41903 }
41904 if (obj3) {
41905 {
41906 arg4 = wxString_in_helper(obj3);
41907 if (arg4 == NULL) SWIG_fail;
41908 temp4 = true;
41909 }
41910 }
41911 {
41912 PyThreadState* __tstate = wxPyBeginAllowThreads();
41913 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
41914 wxPyEndAllowThreads(__tstate);
41915 if (PyErr_Occurred()) SWIG_fail;
41916 }
41917 {
41918 resultobj = wxPyMake_wxObject(result, (bool)0);
41919 }
41920 {
41921 if (temp3)
41922 delete arg3;
41923 }
41924 {
41925 if (temp4)
41926 delete arg4;
41927 }
41928 return resultobj;
41929 fail:
41930 {
41931 if (temp3)
41932 delete arg3;
41933 }
41934 {
41935 if (temp4)
41936 delete arg4;
41937 }
41938 return NULL;
41939 }
41940
41941
41942 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41943 PyObject *resultobj = 0;
41944 wxMenu *arg1 = (wxMenu *) 0 ;
41945 int arg2 ;
41946 wxString *arg3 = 0 ;
41947 wxMenu *arg4 = (wxMenu *) 0 ;
41948 wxString const &arg5_defvalue = wxPyEmptyString ;
41949 wxString *arg5 = (wxString *) &arg5_defvalue ;
41950 wxMenuItem *result = 0 ;
41951 void *argp1 = 0 ;
41952 int res1 = 0 ;
41953 int val2 ;
41954 int ecode2 = 0 ;
41955 bool temp3 = false ;
41956 void *argp4 = 0 ;
41957 int res4 = 0 ;
41958 bool temp5 = false ;
41959 PyObject * obj0 = 0 ;
41960 PyObject * obj1 = 0 ;
41961 PyObject * obj2 = 0 ;
41962 PyObject * obj3 = 0 ;
41963 PyObject * obj4 = 0 ;
41964 char * kwnames[] = {
41965 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
41966 };
41967
41968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41970 if (!SWIG_IsOK(res1)) {
41971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
41972 }
41973 arg1 = reinterpret_cast< wxMenu * >(argp1);
41974 ecode2 = SWIG_AsVal_int(obj1, &val2);
41975 if (!SWIG_IsOK(ecode2)) {
41976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
41977 }
41978 arg2 = static_cast< int >(val2);
41979 {
41980 arg3 = wxString_in_helper(obj2);
41981 if (arg3 == NULL) SWIG_fail;
41982 temp3 = true;
41983 }
41984 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
41985 if (!SWIG_IsOK(res4)) {
41986 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
41987 }
41988 arg4 = reinterpret_cast< wxMenu * >(argp4);
41989 if (obj4) {
41990 {
41991 arg5 = wxString_in_helper(obj4);
41992 if (arg5 == NULL) SWIG_fail;
41993 temp5 = true;
41994 }
41995 }
41996 {
41997 PyThreadState* __tstate = wxPyBeginAllowThreads();
41998 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
41999 wxPyEndAllowThreads(__tstate);
42000 if (PyErr_Occurred()) SWIG_fail;
42001 }
42002 {
42003 resultobj = wxPyMake_wxObject(result, (bool)0);
42004 }
42005 {
42006 if (temp3)
42007 delete arg3;
42008 }
42009 {
42010 if (temp5)
42011 delete arg5;
42012 }
42013 return resultobj;
42014 fail:
42015 {
42016 if (temp3)
42017 delete arg3;
42018 }
42019 {
42020 if (temp5)
42021 delete arg5;
42022 }
42023 return NULL;
42024 }
42025
42026
42027 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42028 PyObject *resultobj = 0;
42029 wxMenu *arg1 = (wxMenu *) 0 ;
42030 wxMenu *arg2 = (wxMenu *) 0 ;
42031 wxString *arg3 = 0 ;
42032 wxString const &arg4_defvalue = wxPyEmptyString ;
42033 wxString *arg4 = (wxString *) &arg4_defvalue ;
42034 wxMenuItem *result = 0 ;
42035 void *argp1 = 0 ;
42036 int res1 = 0 ;
42037 void *argp2 = 0 ;
42038 int res2 = 0 ;
42039 bool temp3 = false ;
42040 bool temp4 = false ;
42041 PyObject * obj0 = 0 ;
42042 PyObject * obj1 = 0 ;
42043 PyObject * obj2 = 0 ;
42044 PyObject * obj3 = 0 ;
42045 char * kwnames[] = {
42046 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42047 };
42048
42049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42051 if (!SWIG_IsOK(res1)) {
42052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42053 }
42054 arg1 = reinterpret_cast< wxMenu * >(argp1);
42055 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42056 if (!SWIG_IsOK(res2)) {
42057 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42058 }
42059 arg2 = reinterpret_cast< wxMenu * >(argp2);
42060 {
42061 arg3 = wxString_in_helper(obj2);
42062 if (arg3 == NULL) SWIG_fail;
42063 temp3 = true;
42064 }
42065 if (obj3) {
42066 {
42067 arg4 = wxString_in_helper(obj3);
42068 if (arg4 == NULL) SWIG_fail;
42069 temp4 = true;
42070 }
42071 }
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42075 wxPyEndAllowThreads(__tstate);
42076 if (PyErr_Occurred()) SWIG_fail;
42077 }
42078 {
42079 resultobj = wxPyMake_wxObject(result, (bool)0);
42080 }
42081 {
42082 if (temp3)
42083 delete arg3;
42084 }
42085 {
42086 if (temp4)
42087 delete arg4;
42088 }
42089 return resultobj;
42090 fail:
42091 {
42092 if (temp3)
42093 delete arg3;
42094 }
42095 {
42096 if (temp4)
42097 delete arg4;
42098 }
42099 return NULL;
42100 }
42101
42102
42103 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42104 PyObject *resultobj = 0;
42105 wxMenu *arg1 = (wxMenu *) 0 ;
42106 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42107 wxMenuItem *result = 0 ;
42108 void *argp1 = 0 ;
42109 int res1 = 0 ;
42110 int res2 = 0 ;
42111 PyObject * obj0 = 0 ;
42112 PyObject * obj1 = 0 ;
42113 char * kwnames[] = {
42114 (char *) "self",(char *) "item", NULL
42115 };
42116
42117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42119 if (!SWIG_IsOK(res1)) {
42120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42121 }
42122 arg1 = reinterpret_cast< wxMenu * >(argp1);
42123 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42124 if (!SWIG_IsOK(res2)) {
42125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42126 }
42127 {
42128 PyThreadState* __tstate = wxPyBeginAllowThreads();
42129 result = (wxMenuItem *)(arg1)->Append(arg2);
42130 wxPyEndAllowThreads(__tstate);
42131 if (PyErr_Occurred()) SWIG_fail;
42132 }
42133 {
42134 resultobj = wxPyMake_wxObject(result, (bool)0);
42135 }
42136 return resultobj;
42137 fail:
42138 return NULL;
42139 }
42140
42141
42142 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42143 PyObject *resultobj = 0;
42144 wxMenu *arg1 = (wxMenu *) 0 ;
42145 size_t arg2 ;
42146 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42147 wxMenuItem *result = 0 ;
42148 void *argp1 = 0 ;
42149 int res1 = 0 ;
42150 size_t val2 ;
42151 int ecode2 = 0 ;
42152 int res3 = 0 ;
42153 PyObject * obj0 = 0 ;
42154 PyObject * obj1 = 0 ;
42155 PyObject * obj2 = 0 ;
42156 char * kwnames[] = {
42157 (char *) "self",(char *) "pos",(char *) "item", NULL
42158 };
42159
42160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42162 if (!SWIG_IsOK(res1)) {
42163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42164 }
42165 arg1 = reinterpret_cast< wxMenu * >(argp1);
42166 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42167 if (!SWIG_IsOK(ecode2)) {
42168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42169 }
42170 arg2 = static_cast< size_t >(val2);
42171 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42172 if (!SWIG_IsOK(res3)) {
42173 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42174 }
42175 {
42176 PyThreadState* __tstate = wxPyBeginAllowThreads();
42177 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42178 wxPyEndAllowThreads(__tstate);
42179 if (PyErr_Occurred()) SWIG_fail;
42180 }
42181 {
42182 resultobj = wxPyMake_wxObject(result, (bool)0);
42183 }
42184 return resultobj;
42185 fail:
42186 return NULL;
42187 }
42188
42189
42190 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42191 PyObject *resultobj = 0;
42192 wxMenu *arg1 = (wxMenu *) 0 ;
42193 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42194 wxMenuItem *result = 0 ;
42195 void *argp1 = 0 ;
42196 int res1 = 0 ;
42197 int res2 = 0 ;
42198 PyObject * obj0 = 0 ;
42199 PyObject * obj1 = 0 ;
42200 char * kwnames[] = {
42201 (char *) "self",(char *) "item", NULL
42202 };
42203
42204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42206 if (!SWIG_IsOK(res1)) {
42207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42208 }
42209 arg1 = reinterpret_cast< wxMenu * >(argp1);
42210 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42211 if (!SWIG_IsOK(res2)) {
42212 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42213 }
42214 {
42215 PyThreadState* __tstate = wxPyBeginAllowThreads();
42216 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42217 wxPyEndAllowThreads(__tstate);
42218 if (PyErr_Occurred()) SWIG_fail;
42219 }
42220 {
42221 resultobj = wxPyMake_wxObject(result, (bool)0);
42222 }
42223 return resultobj;
42224 fail:
42225 return NULL;
42226 }
42227
42228
42229 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42230 PyObject *resultobj = 0;
42231 wxMenu *arg1 = (wxMenu *) 0 ;
42232 void *argp1 = 0 ;
42233 int res1 = 0 ;
42234 PyObject *swig_obj[1] ;
42235
42236 if (!args) SWIG_fail;
42237 swig_obj[0] = args;
42238 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42239 if (!SWIG_IsOK(res1)) {
42240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42241 }
42242 arg1 = reinterpret_cast< wxMenu * >(argp1);
42243 {
42244 PyThreadState* __tstate = wxPyBeginAllowThreads();
42245 (arg1)->Break();
42246 wxPyEndAllowThreads(__tstate);
42247 if (PyErr_Occurred()) SWIG_fail;
42248 }
42249 resultobj = SWIG_Py_Void();
42250 return resultobj;
42251 fail:
42252 return NULL;
42253 }
42254
42255
42256 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42257 PyObject *resultobj = 0;
42258 wxMenu *arg1 = (wxMenu *) 0 ;
42259 size_t arg2 ;
42260 int arg3 ;
42261 wxString const &arg4_defvalue = wxPyEmptyString ;
42262 wxString *arg4 = (wxString *) &arg4_defvalue ;
42263 wxString const &arg5_defvalue = wxPyEmptyString ;
42264 wxString *arg5 = (wxString *) &arg5_defvalue ;
42265 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42266 wxMenuItem *result = 0 ;
42267 void *argp1 = 0 ;
42268 int res1 = 0 ;
42269 size_t val2 ;
42270 int ecode2 = 0 ;
42271 int val3 ;
42272 int ecode3 = 0 ;
42273 bool temp4 = false ;
42274 bool temp5 = false ;
42275 int val6 ;
42276 int ecode6 = 0 ;
42277 PyObject * obj0 = 0 ;
42278 PyObject * obj1 = 0 ;
42279 PyObject * obj2 = 0 ;
42280 PyObject * obj3 = 0 ;
42281 PyObject * obj4 = 0 ;
42282 PyObject * obj5 = 0 ;
42283 char * kwnames[] = {
42284 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42285 };
42286
42287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42289 if (!SWIG_IsOK(res1)) {
42290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42291 }
42292 arg1 = reinterpret_cast< wxMenu * >(argp1);
42293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42294 if (!SWIG_IsOK(ecode2)) {
42295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42296 }
42297 arg2 = static_cast< size_t >(val2);
42298 ecode3 = SWIG_AsVal_int(obj2, &val3);
42299 if (!SWIG_IsOK(ecode3)) {
42300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42301 }
42302 arg3 = static_cast< int >(val3);
42303 if (obj3) {
42304 {
42305 arg4 = wxString_in_helper(obj3);
42306 if (arg4 == NULL) SWIG_fail;
42307 temp4 = true;
42308 }
42309 }
42310 if (obj4) {
42311 {
42312 arg5 = wxString_in_helper(obj4);
42313 if (arg5 == NULL) SWIG_fail;
42314 temp5 = true;
42315 }
42316 }
42317 if (obj5) {
42318 ecode6 = SWIG_AsVal_int(obj5, &val6);
42319 if (!SWIG_IsOK(ecode6)) {
42320 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42321 }
42322 arg6 = static_cast< wxItemKind >(val6);
42323 }
42324 {
42325 PyThreadState* __tstate = wxPyBeginAllowThreads();
42326 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42327 wxPyEndAllowThreads(__tstate);
42328 if (PyErr_Occurred()) SWIG_fail;
42329 }
42330 {
42331 resultobj = wxPyMake_wxObject(result, (bool)0);
42332 }
42333 {
42334 if (temp4)
42335 delete arg4;
42336 }
42337 {
42338 if (temp5)
42339 delete arg5;
42340 }
42341 return resultobj;
42342 fail:
42343 {
42344 if (temp4)
42345 delete arg4;
42346 }
42347 {
42348 if (temp5)
42349 delete arg5;
42350 }
42351 return NULL;
42352 }
42353
42354
42355 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42356 PyObject *resultobj = 0;
42357 wxMenu *arg1 = (wxMenu *) 0 ;
42358 size_t arg2 ;
42359 wxMenuItem *result = 0 ;
42360 void *argp1 = 0 ;
42361 int res1 = 0 ;
42362 size_t val2 ;
42363 int ecode2 = 0 ;
42364 PyObject * obj0 = 0 ;
42365 PyObject * obj1 = 0 ;
42366 char * kwnames[] = {
42367 (char *) "self",(char *) "pos", NULL
42368 };
42369
42370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42372 if (!SWIG_IsOK(res1)) {
42373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42374 }
42375 arg1 = reinterpret_cast< wxMenu * >(argp1);
42376 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42377 if (!SWIG_IsOK(ecode2)) {
42378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42379 }
42380 arg2 = static_cast< size_t >(val2);
42381 {
42382 PyThreadState* __tstate = wxPyBeginAllowThreads();
42383 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42384 wxPyEndAllowThreads(__tstate);
42385 if (PyErr_Occurred()) SWIG_fail;
42386 }
42387 {
42388 resultobj = wxPyMake_wxObject(result, (bool)0);
42389 }
42390 return resultobj;
42391 fail:
42392 return NULL;
42393 }
42394
42395
42396 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42397 PyObject *resultobj = 0;
42398 wxMenu *arg1 = (wxMenu *) 0 ;
42399 size_t arg2 ;
42400 int arg3 ;
42401 wxString *arg4 = 0 ;
42402 wxString const &arg5_defvalue = wxPyEmptyString ;
42403 wxString *arg5 = (wxString *) &arg5_defvalue ;
42404 wxMenuItem *result = 0 ;
42405 void *argp1 = 0 ;
42406 int res1 = 0 ;
42407 size_t val2 ;
42408 int ecode2 = 0 ;
42409 int val3 ;
42410 int ecode3 = 0 ;
42411 bool temp4 = false ;
42412 bool temp5 = false ;
42413 PyObject * obj0 = 0 ;
42414 PyObject * obj1 = 0 ;
42415 PyObject * obj2 = 0 ;
42416 PyObject * obj3 = 0 ;
42417 PyObject * obj4 = 0 ;
42418 char * kwnames[] = {
42419 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42420 };
42421
42422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42424 if (!SWIG_IsOK(res1)) {
42425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42426 }
42427 arg1 = reinterpret_cast< wxMenu * >(argp1);
42428 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42429 if (!SWIG_IsOK(ecode2)) {
42430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42431 }
42432 arg2 = static_cast< size_t >(val2);
42433 ecode3 = SWIG_AsVal_int(obj2, &val3);
42434 if (!SWIG_IsOK(ecode3)) {
42435 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42436 }
42437 arg3 = static_cast< int >(val3);
42438 {
42439 arg4 = wxString_in_helper(obj3);
42440 if (arg4 == NULL) SWIG_fail;
42441 temp4 = true;
42442 }
42443 if (obj4) {
42444 {
42445 arg5 = wxString_in_helper(obj4);
42446 if (arg5 == NULL) SWIG_fail;
42447 temp5 = true;
42448 }
42449 }
42450 {
42451 PyThreadState* __tstate = wxPyBeginAllowThreads();
42452 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42453 wxPyEndAllowThreads(__tstate);
42454 if (PyErr_Occurred()) SWIG_fail;
42455 }
42456 {
42457 resultobj = wxPyMake_wxObject(result, (bool)0);
42458 }
42459 {
42460 if (temp4)
42461 delete arg4;
42462 }
42463 {
42464 if (temp5)
42465 delete arg5;
42466 }
42467 return resultobj;
42468 fail:
42469 {
42470 if (temp4)
42471 delete arg4;
42472 }
42473 {
42474 if (temp5)
42475 delete arg5;
42476 }
42477 return NULL;
42478 }
42479
42480
42481 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42482 PyObject *resultobj = 0;
42483 wxMenu *arg1 = (wxMenu *) 0 ;
42484 size_t arg2 ;
42485 int arg3 ;
42486 wxString *arg4 = 0 ;
42487 wxString const &arg5_defvalue = wxPyEmptyString ;
42488 wxString *arg5 = (wxString *) &arg5_defvalue ;
42489 wxMenuItem *result = 0 ;
42490 void *argp1 = 0 ;
42491 int res1 = 0 ;
42492 size_t val2 ;
42493 int ecode2 = 0 ;
42494 int val3 ;
42495 int ecode3 = 0 ;
42496 bool temp4 = false ;
42497 bool temp5 = false ;
42498 PyObject * obj0 = 0 ;
42499 PyObject * obj1 = 0 ;
42500 PyObject * obj2 = 0 ;
42501 PyObject * obj3 = 0 ;
42502 PyObject * obj4 = 0 ;
42503 char * kwnames[] = {
42504 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42505 };
42506
42507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42509 if (!SWIG_IsOK(res1)) {
42510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42511 }
42512 arg1 = reinterpret_cast< wxMenu * >(argp1);
42513 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42514 if (!SWIG_IsOK(ecode2)) {
42515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42516 }
42517 arg2 = static_cast< size_t >(val2);
42518 ecode3 = SWIG_AsVal_int(obj2, &val3);
42519 if (!SWIG_IsOK(ecode3)) {
42520 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42521 }
42522 arg3 = static_cast< int >(val3);
42523 {
42524 arg4 = wxString_in_helper(obj3);
42525 if (arg4 == NULL) SWIG_fail;
42526 temp4 = true;
42527 }
42528 if (obj4) {
42529 {
42530 arg5 = wxString_in_helper(obj4);
42531 if (arg5 == NULL) SWIG_fail;
42532 temp5 = true;
42533 }
42534 }
42535 {
42536 PyThreadState* __tstate = wxPyBeginAllowThreads();
42537 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42538 wxPyEndAllowThreads(__tstate);
42539 if (PyErr_Occurred()) SWIG_fail;
42540 }
42541 {
42542 resultobj = wxPyMake_wxObject(result, (bool)0);
42543 }
42544 {
42545 if (temp4)
42546 delete arg4;
42547 }
42548 {
42549 if (temp5)
42550 delete arg5;
42551 }
42552 return resultobj;
42553 fail:
42554 {
42555 if (temp4)
42556 delete arg4;
42557 }
42558 {
42559 if (temp5)
42560 delete arg5;
42561 }
42562 return NULL;
42563 }
42564
42565
42566 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42567 PyObject *resultobj = 0;
42568 wxMenu *arg1 = (wxMenu *) 0 ;
42569 size_t arg2 ;
42570 int arg3 ;
42571 wxString *arg4 = 0 ;
42572 wxMenu *arg5 = (wxMenu *) 0 ;
42573 wxString const &arg6_defvalue = wxPyEmptyString ;
42574 wxString *arg6 = (wxString *) &arg6_defvalue ;
42575 wxMenuItem *result = 0 ;
42576 void *argp1 = 0 ;
42577 int res1 = 0 ;
42578 size_t val2 ;
42579 int ecode2 = 0 ;
42580 int val3 ;
42581 int ecode3 = 0 ;
42582 bool temp4 = false ;
42583 void *argp5 = 0 ;
42584 int res5 = 0 ;
42585 bool temp6 = false ;
42586 PyObject * obj0 = 0 ;
42587 PyObject * obj1 = 0 ;
42588 PyObject * obj2 = 0 ;
42589 PyObject * obj3 = 0 ;
42590 PyObject * obj4 = 0 ;
42591 PyObject * obj5 = 0 ;
42592 char * kwnames[] = {
42593 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42594 };
42595
42596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42598 if (!SWIG_IsOK(res1)) {
42599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42600 }
42601 arg1 = reinterpret_cast< wxMenu * >(argp1);
42602 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42603 if (!SWIG_IsOK(ecode2)) {
42604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42605 }
42606 arg2 = static_cast< size_t >(val2);
42607 ecode3 = SWIG_AsVal_int(obj2, &val3);
42608 if (!SWIG_IsOK(ecode3)) {
42609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42610 }
42611 arg3 = static_cast< int >(val3);
42612 {
42613 arg4 = wxString_in_helper(obj3);
42614 if (arg4 == NULL) SWIG_fail;
42615 temp4 = true;
42616 }
42617 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42618 if (!SWIG_IsOK(res5)) {
42619 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42620 }
42621 arg5 = reinterpret_cast< wxMenu * >(argp5);
42622 if (obj5) {
42623 {
42624 arg6 = wxString_in_helper(obj5);
42625 if (arg6 == NULL) SWIG_fail;
42626 temp6 = true;
42627 }
42628 }
42629 {
42630 PyThreadState* __tstate = wxPyBeginAllowThreads();
42631 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42632 wxPyEndAllowThreads(__tstate);
42633 if (PyErr_Occurred()) SWIG_fail;
42634 }
42635 {
42636 resultobj = wxPyMake_wxObject(result, (bool)0);
42637 }
42638 {
42639 if (temp4)
42640 delete arg4;
42641 }
42642 {
42643 if (temp6)
42644 delete arg6;
42645 }
42646 return resultobj;
42647 fail:
42648 {
42649 if (temp4)
42650 delete arg4;
42651 }
42652 {
42653 if (temp6)
42654 delete arg6;
42655 }
42656 return NULL;
42657 }
42658
42659
42660 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42661 PyObject *resultobj = 0;
42662 wxMenu *arg1 = (wxMenu *) 0 ;
42663 int arg2 ;
42664 wxString const &arg3_defvalue = wxPyEmptyString ;
42665 wxString *arg3 = (wxString *) &arg3_defvalue ;
42666 wxString const &arg4_defvalue = wxPyEmptyString ;
42667 wxString *arg4 = (wxString *) &arg4_defvalue ;
42668 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42669 wxMenuItem *result = 0 ;
42670 void *argp1 = 0 ;
42671 int res1 = 0 ;
42672 int val2 ;
42673 int ecode2 = 0 ;
42674 bool temp3 = false ;
42675 bool temp4 = false ;
42676 int val5 ;
42677 int ecode5 = 0 ;
42678 PyObject * obj0 = 0 ;
42679 PyObject * obj1 = 0 ;
42680 PyObject * obj2 = 0 ;
42681 PyObject * obj3 = 0 ;
42682 PyObject * obj4 = 0 ;
42683 char * kwnames[] = {
42684 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42685 };
42686
42687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42689 if (!SWIG_IsOK(res1)) {
42690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42691 }
42692 arg1 = reinterpret_cast< wxMenu * >(argp1);
42693 ecode2 = SWIG_AsVal_int(obj1, &val2);
42694 if (!SWIG_IsOK(ecode2)) {
42695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42696 }
42697 arg2 = static_cast< int >(val2);
42698 if (obj2) {
42699 {
42700 arg3 = wxString_in_helper(obj2);
42701 if (arg3 == NULL) SWIG_fail;
42702 temp3 = true;
42703 }
42704 }
42705 if (obj3) {
42706 {
42707 arg4 = wxString_in_helper(obj3);
42708 if (arg4 == NULL) SWIG_fail;
42709 temp4 = true;
42710 }
42711 }
42712 if (obj4) {
42713 ecode5 = SWIG_AsVal_int(obj4, &val5);
42714 if (!SWIG_IsOK(ecode5)) {
42715 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42716 }
42717 arg5 = static_cast< wxItemKind >(val5);
42718 }
42719 {
42720 PyThreadState* __tstate = wxPyBeginAllowThreads();
42721 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42722 wxPyEndAllowThreads(__tstate);
42723 if (PyErr_Occurred()) SWIG_fail;
42724 }
42725 {
42726 resultobj = wxPyMake_wxObject(result, (bool)0);
42727 }
42728 {
42729 if (temp3)
42730 delete arg3;
42731 }
42732 {
42733 if (temp4)
42734 delete arg4;
42735 }
42736 return resultobj;
42737 fail:
42738 {
42739 if (temp3)
42740 delete arg3;
42741 }
42742 {
42743 if (temp4)
42744 delete arg4;
42745 }
42746 return NULL;
42747 }
42748
42749
42750 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42751 PyObject *resultobj = 0;
42752 wxMenu *arg1 = (wxMenu *) 0 ;
42753 wxMenuItem *result = 0 ;
42754 void *argp1 = 0 ;
42755 int res1 = 0 ;
42756 PyObject *swig_obj[1] ;
42757
42758 if (!args) SWIG_fail;
42759 swig_obj[0] = args;
42760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42761 if (!SWIG_IsOK(res1)) {
42762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42763 }
42764 arg1 = reinterpret_cast< wxMenu * >(argp1);
42765 {
42766 PyThreadState* __tstate = wxPyBeginAllowThreads();
42767 result = (wxMenuItem *)(arg1)->PrependSeparator();
42768 wxPyEndAllowThreads(__tstate);
42769 if (PyErr_Occurred()) SWIG_fail;
42770 }
42771 {
42772 resultobj = wxPyMake_wxObject(result, (bool)0);
42773 }
42774 return resultobj;
42775 fail:
42776 return NULL;
42777 }
42778
42779
42780 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42781 PyObject *resultobj = 0;
42782 wxMenu *arg1 = (wxMenu *) 0 ;
42783 int arg2 ;
42784 wxString *arg3 = 0 ;
42785 wxString const &arg4_defvalue = wxPyEmptyString ;
42786 wxString *arg4 = (wxString *) &arg4_defvalue ;
42787 wxMenuItem *result = 0 ;
42788 void *argp1 = 0 ;
42789 int res1 = 0 ;
42790 int val2 ;
42791 int ecode2 = 0 ;
42792 bool temp3 = false ;
42793 bool temp4 = false ;
42794 PyObject * obj0 = 0 ;
42795 PyObject * obj1 = 0 ;
42796 PyObject * obj2 = 0 ;
42797 PyObject * obj3 = 0 ;
42798 char * kwnames[] = {
42799 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42800 };
42801
42802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42804 if (!SWIG_IsOK(res1)) {
42805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42806 }
42807 arg1 = reinterpret_cast< wxMenu * >(argp1);
42808 ecode2 = SWIG_AsVal_int(obj1, &val2);
42809 if (!SWIG_IsOK(ecode2)) {
42810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
42811 }
42812 arg2 = static_cast< int >(val2);
42813 {
42814 arg3 = wxString_in_helper(obj2);
42815 if (arg3 == NULL) SWIG_fail;
42816 temp3 = true;
42817 }
42818 if (obj3) {
42819 {
42820 arg4 = wxString_in_helper(obj3);
42821 if (arg4 == NULL) SWIG_fail;
42822 temp4 = true;
42823 }
42824 }
42825 {
42826 PyThreadState* __tstate = wxPyBeginAllowThreads();
42827 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42828 wxPyEndAllowThreads(__tstate);
42829 if (PyErr_Occurred()) SWIG_fail;
42830 }
42831 {
42832 resultobj = wxPyMake_wxObject(result, (bool)0);
42833 }
42834 {
42835 if (temp3)
42836 delete arg3;
42837 }
42838 {
42839 if (temp4)
42840 delete arg4;
42841 }
42842 return resultobj;
42843 fail:
42844 {
42845 if (temp3)
42846 delete arg3;
42847 }
42848 {
42849 if (temp4)
42850 delete arg4;
42851 }
42852 return NULL;
42853 }
42854
42855
42856 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42857 PyObject *resultobj = 0;
42858 wxMenu *arg1 = (wxMenu *) 0 ;
42859 int arg2 ;
42860 wxString *arg3 = 0 ;
42861 wxString const &arg4_defvalue = wxPyEmptyString ;
42862 wxString *arg4 = (wxString *) &arg4_defvalue ;
42863 wxMenuItem *result = 0 ;
42864 void *argp1 = 0 ;
42865 int res1 = 0 ;
42866 int val2 ;
42867 int ecode2 = 0 ;
42868 bool temp3 = false ;
42869 bool temp4 = false ;
42870 PyObject * obj0 = 0 ;
42871 PyObject * obj1 = 0 ;
42872 PyObject * obj2 = 0 ;
42873 PyObject * obj3 = 0 ;
42874 char * kwnames[] = {
42875 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42876 };
42877
42878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42880 if (!SWIG_IsOK(res1)) {
42881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42882 }
42883 arg1 = reinterpret_cast< wxMenu * >(argp1);
42884 ecode2 = SWIG_AsVal_int(obj1, &val2);
42885 if (!SWIG_IsOK(ecode2)) {
42886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
42887 }
42888 arg2 = static_cast< int >(val2);
42889 {
42890 arg3 = wxString_in_helper(obj2);
42891 if (arg3 == NULL) SWIG_fail;
42892 temp3 = true;
42893 }
42894 if (obj3) {
42895 {
42896 arg4 = wxString_in_helper(obj3);
42897 if (arg4 == NULL) SWIG_fail;
42898 temp4 = true;
42899 }
42900 }
42901 {
42902 PyThreadState* __tstate = wxPyBeginAllowThreads();
42903 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42904 wxPyEndAllowThreads(__tstate);
42905 if (PyErr_Occurred()) SWIG_fail;
42906 }
42907 {
42908 resultobj = wxPyMake_wxObject(result, (bool)0);
42909 }
42910 {
42911 if (temp3)
42912 delete arg3;
42913 }
42914 {
42915 if (temp4)
42916 delete arg4;
42917 }
42918 return resultobj;
42919 fail:
42920 {
42921 if (temp3)
42922 delete arg3;
42923 }
42924 {
42925 if (temp4)
42926 delete arg4;
42927 }
42928 return NULL;
42929 }
42930
42931
42932 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42933 PyObject *resultobj = 0;
42934 wxMenu *arg1 = (wxMenu *) 0 ;
42935 int arg2 ;
42936 wxString *arg3 = 0 ;
42937 wxMenu *arg4 = (wxMenu *) 0 ;
42938 wxString const &arg5_defvalue = wxPyEmptyString ;
42939 wxString *arg5 = (wxString *) &arg5_defvalue ;
42940 wxMenuItem *result = 0 ;
42941 void *argp1 = 0 ;
42942 int res1 = 0 ;
42943 int val2 ;
42944 int ecode2 = 0 ;
42945 bool temp3 = false ;
42946 void *argp4 = 0 ;
42947 int res4 = 0 ;
42948 bool temp5 = false ;
42949 PyObject * obj0 = 0 ;
42950 PyObject * obj1 = 0 ;
42951 PyObject * obj2 = 0 ;
42952 PyObject * obj3 = 0 ;
42953 PyObject * obj4 = 0 ;
42954 char * kwnames[] = {
42955 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42956 };
42957
42958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42960 if (!SWIG_IsOK(res1)) {
42961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42962 }
42963 arg1 = reinterpret_cast< wxMenu * >(argp1);
42964 ecode2 = SWIG_AsVal_int(obj1, &val2);
42965 if (!SWIG_IsOK(ecode2)) {
42966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
42967 }
42968 arg2 = static_cast< int >(val2);
42969 {
42970 arg3 = wxString_in_helper(obj2);
42971 if (arg3 == NULL) SWIG_fail;
42972 temp3 = true;
42973 }
42974 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42975 if (!SWIG_IsOK(res4)) {
42976 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42977 }
42978 arg4 = reinterpret_cast< wxMenu * >(argp4);
42979 if (obj4) {
42980 {
42981 arg5 = wxString_in_helper(obj4);
42982 if (arg5 == NULL) SWIG_fail;
42983 temp5 = true;
42984 }
42985 }
42986 {
42987 PyThreadState* __tstate = wxPyBeginAllowThreads();
42988 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42989 wxPyEndAllowThreads(__tstate);
42990 if (PyErr_Occurred()) SWIG_fail;
42991 }
42992 {
42993 resultobj = wxPyMake_wxObject(result, (bool)0);
42994 }
42995 {
42996 if (temp3)
42997 delete arg3;
42998 }
42999 {
43000 if (temp5)
43001 delete arg5;
43002 }
43003 return resultobj;
43004 fail:
43005 {
43006 if (temp3)
43007 delete arg3;
43008 }
43009 {
43010 if (temp5)
43011 delete arg5;
43012 }
43013 return NULL;
43014 }
43015
43016
43017 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43018 PyObject *resultobj = 0;
43019 wxMenu *arg1 = (wxMenu *) 0 ;
43020 int arg2 ;
43021 wxMenuItem *result = 0 ;
43022 void *argp1 = 0 ;
43023 int res1 = 0 ;
43024 int val2 ;
43025 int ecode2 = 0 ;
43026 PyObject * obj0 = 0 ;
43027 PyObject * obj1 = 0 ;
43028 char * kwnames[] = {
43029 (char *) "self",(char *) "id", NULL
43030 };
43031
43032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43034 if (!SWIG_IsOK(res1)) {
43035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43036 }
43037 arg1 = reinterpret_cast< wxMenu * >(argp1);
43038 ecode2 = SWIG_AsVal_int(obj1, &val2);
43039 if (!SWIG_IsOK(ecode2)) {
43040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43041 }
43042 arg2 = static_cast< int >(val2);
43043 {
43044 PyThreadState* __tstate = wxPyBeginAllowThreads();
43045 result = (wxMenuItem *)(arg1)->Remove(arg2);
43046 wxPyEndAllowThreads(__tstate);
43047 if (PyErr_Occurred()) SWIG_fail;
43048 }
43049 {
43050 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43051 }
43052 return resultobj;
43053 fail:
43054 return NULL;
43055 }
43056
43057
43058 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43059 PyObject *resultobj = 0;
43060 wxMenu *arg1 = (wxMenu *) 0 ;
43061 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43062 wxMenuItem *result = 0 ;
43063 void *argp1 = 0 ;
43064 int res1 = 0 ;
43065 void *argp2 = 0 ;
43066 int res2 = 0 ;
43067 PyObject * obj0 = 0 ;
43068 PyObject * obj1 = 0 ;
43069 char * kwnames[] = {
43070 (char *) "self",(char *) "item", NULL
43071 };
43072
43073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43075 if (!SWIG_IsOK(res1)) {
43076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43077 }
43078 arg1 = reinterpret_cast< wxMenu * >(argp1);
43079 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43080 if (!SWIG_IsOK(res2)) {
43081 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43082 }
43083 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43084 {
43085 PyThreadState* __tstate = wxPyBeginAllowThreads();
43086 result = (wxMenuItem *)(arg1)->Remove(arg2);
43087 wxPyEndAllowThreads(__tstate);
43088 if (PyErr_Occurred()) SWIG_fail;
43089 }
43090 {
43091 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43092 }
43093 return resultobj;
43094 fail:
43095 return NULL;
43096 }
43097
43098
43099 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43100 PyObject *resultobj = 0;
43101 wxMenu *arg1 = (wxMenu *) 0 ;
43102 int arg2 ;
43103 bool result;
43104 void *argp1 = 0 ;
43105 int res1 = 0 ;
43106 int val2 ;
43107 int ecode2 = 0 ;
43108 PyObject * obj0 = 0 ;
43109 PyObject * obj1 = 0 ;
43110 char * kwnames[] = {
43111 (char *) "self",(char *) "id", NULL
43112 };
43113
43114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43116 if (!SWIG_IsOK(res1)) {
43117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43118 }
43119 arg1 = reinterpret_cast< wxMenu * >(argp1);
43120 ecode2 = SWIG_AsVal_int(obj1, &val2);
43121 if (!SWIG_IsOK(ecode2)) {
43122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43123 }
43124 arg2 = static_cast< int >(val2);
43125 {
43126 PyThreadState* __tstate = wxPyBeginAllowThreads();
43127 result = (bool)(arg1)->Delete(arg2);
43128 wxPyEndAllowThreads(__tstate);
43129 if (PyErr_Occurred()) SWIG_fail;
43130 }
43131 {
43132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43133 }
43134 return resultobj;
43135 fail:
43136 return NULL;
43137 }
43138
43139
43140 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43141 PyObject *resultobj = 0;
43142 wxMenu *arg1 = (wxMenu *) 0 ;
43143 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43144 bool result;
43145 void *argp1 = 0 ;
43146 int res1 = 0 ;
43147 void *argp2 = 0 ;
43148 int res2 = 0 ;
43149 PyObject * obj0 = 0 ;
43150 PyObject * obj1 = 0 ;
43151 char * kwnames[] = {
43152 (char *) "self",(char *) "item", NULL
43153 };
43154
43155 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43156 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43157 if (!SWIG_IsOK(res1)) {
43158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43159 }
43160 arg1 = reinterpret_cast< wxMenu * >(argp1);
43161 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43162 if (!SWIG_IsOK(res2)) {
43163 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43164 }
43165 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43166 {
43167 PyThreadState* __tstate = wxPyBeginAllowThreads();
43168 result = (bool)(arg1)->Delete(arg2);
43169 wxPyEndAllowThreads(__tstate);
43170 if (PyErr_Occurred()) SWIG_fail;
43171 }
43172 {
43173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43174 }
43175 return resultobj;
43176 fail:
43177 return NULL;
43178 }
43179
43180
43181 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43182 PyObject *resultobj = 0;
43183 wxMenu *arg1 = (wxMenu *) 0 ;
43184 void *argp1 = 0 ;
43185 int res1 = 0 ;
43186 PyObject *swig_obj[1] ;
43187
43188 if (!args) SWIG_fail;
43189 swig_obj[0] = args;
43190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43191 if (!SWIG_IsOK(res1)) {
43192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43193 }
43194 arg1 = reinterpret_cast< wxMenu * >(argp1);
43195 {
43196 PyThreadState* __tstate = wxPyBeginAllowThreads();
43197 wxMenu_Destroy(arg1);
43198 wxPyEndAllowThreads(__tstate);
43199 if (PyErr_Occurred()) SWIG_fail;
43200 }
43201 resultobj = SWIG_Py_Void();
43202 return resultobj;
43203 fail:
43204 return NULL;
43205 }
43206
43207
43208 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43209 PyObject *resultobj = 0;
43210 wxMenu *arg1 = (wxMenu *) 0 ;
43211 int arg2 ;
43212 bool result;
43213 void *argp1 = 0 ;
43214 int res1 = 0 ;
43215 int val2 ;
43216 int ecode2 = 0 ;
43217 PyObject * obj0 = 0 ;
43218 PyObject * obj1 = 0 ;
43219 char * kwnames[] = {
43220 (char *) "self",(char *) "id", NULL
43221 };
43222
43223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43224 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43225 if (!SWIG_IsOK(res1)) {
43226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43227 }
43228 arg1 = reinterpret_cast< wxMenu * >(argp1);
43229 ecode2 = SWIG_AsVal_int(obj1, &val2);
43230 if (!SWIG_IsOK(ecode2)) {
43231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43232 }
43233 arg2 = static_cast< int >(val2);
43234 {
43235 PyThreadState* __tstate = wxPyBeginAllowThreads();
43236 result = (bool)(arg1)->Destroy(arg2);
43237 wxPyEndAllowThreads(__tstate);
43238 if (PyErr_Occurred()) SWIG_fail;
43239 }
43240 {
43241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43242 }
43243 return resultobj;
43244 fail:
43245 return NULL;
43246 }
43247
43248
43249 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43250 PyObject *resultobj = 0;
43251 wxMenu *arg1 = (wxMenu *) 0 ;
43252 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43253 bool result;
43254 void *argp1 = 0 ;
43255 int res1 = 0 ;
43256 void *argp2 = 0 ;
43257 int res2 = 0 ;
43258 PyObject * obj0 = 0 ;
43259 PyObject * obj1 = 0 ;
43260 char * kwnames[] = {
43261 (char *) "self",(char *) "item", NULL
43262 };
43263
43264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43266 if (!SWIG_IsOK(res1)) {
43267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43268 }
43269 arg1 = reinterpret_cast< wxMenu * >(argp1);
43270 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43271 if (!SWIG_IsOK(res2)) {
43272 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43273 }
43274 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43275 {
43276 PyThreadState* __tstate = wxPyBeginAllowThreads();
43277 result = (bool)(arg1)->Destroy(arg2);
43278 wxPyEndAllowThreads(__tstate);
43279 if (PyErr_Occurred()) SWIG_fail;
43280 }
43281 {
43282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43283 }
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43291 PyObject *resultobj = 0;
43292 wxMenu *arg1 = (wxMenu *) 0 ;
43293 size_t result;
43294 void *argp1 = 0 ;
43295 int res1 = 0 ;
43296 PyObject *swig_obj[1] ;
43297
43298 if (!args) SWIG_fail;
43299 swig_obj[0] = args;
43300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43301 if (!SWIG_IsOK(res1)) {
43302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43303 }
43304 arg1 = reinterpret_cast< wxMenu * >(argp1);
43305 {
43306 PyThreadState* __tstate = wxPyBeginAllowThreads();
43307 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43308 wxPyEndAllowThreads(__tstate);
43309 if (PyErr_Occurred()) SWIG_fail;
43310 }
43311 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43312 return resultobj;
43313 fail:
43314 return NULL;
43315 }
43316
43317
43318 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43319 PyObject *resultobj = 0;
43320 wxMenu *arg1 = (wxMenu *) 0 ;
43321 PyObject *result = 0 ;
43322 void *argp1 = 0 ;
43323 int res1 = 0 ;
43324 PyObject *swig_obj[1] ;
43325
43326 if (!args) SWIG_fail;
43327 swig_obj[0] = args;
43328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43329 if (!SWIG_IsOK(res1)) {
43330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43331 }
43332 arg1 = reinterpret_cast< wxMenu * >(argp1);
43333 {
43334 PyThreadState* __tstate = wxPyBeginAllowThreads();
43335 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43336 wxPyEndAllowThreads(__tstate);
43337 if (PyErr_Occurred()) SWIG_fail;
43338 }
43339 resultobj = result;
43340 return resultobj;
43341 fail:
43342 return NULL;
43343 }
43344
43345
43346 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43347 PyObject *resultobj = 0;
43348 wxMenu *arg1 = (wxMenu *) 0 ;
43349 wxString *arg2 = 0 ;
43350 int result;
43351 void *argp1 = 0 ;
43352 int res1 = 0 ;
43353 bool temp2 = false ;
43354 PyObject * obj0 = 0 ;
43355 PyObject * obj1 = 0 ;
43356 char * kwnames[] = {
43357 (char *) "self",(char *) "item", NULL
43358 };
43359
43360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43362 if (!SWIG_IsOK(res1)) {
43363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43364 }
43365 arg1 = reinterpret_cast< wxMenu * >(argp1);
43366 {
43367 arg2 = wxString_in_helper(obj1);
43368 if (arg2 == NULL) SWIG_fail;
43369 temp2 = true;
43370 }
43371 {
43372 PyThreadState* __tstate = wxPyBeginAllowThreads();
43373 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43374 wxPyEndAllowThreads(__tstate);
43375 if (PyErr_Occurred()) SWIG_fail;
43376 }
43377 resultobj = SWIG_From_int(static_cast< int >(result));
43378 {
43379 if (temp2)
43380 delete arg2;
43381 }
43382 return resultobj;
43383 fail:
43384 {
43385 if (temp2)
43386 delete arg2;
43387 }
43388 return NULL;
43389 }
43390
43391
43392 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43393 PyObject *resultobj = 0;
43394 wxMenu *arg1 = (wxMenu *) 0 ;
43395 int arg2 ;
43396 wxMenuItem *result = 0 ;
43397 void *argp1 = 0 ;
43398 int res1 = 0 ;
43399 int val2 ;
43400 int ecode2 = 0 ;
43401 PyObject * obj0 = 0 ;
43402 PyObject * obj1 = 0 ;
43403 char * kwnames[] = {
43404 (char *) "self",(char *) "id", NULL
43405 };
43406
43407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43409 if (!SWIG_IsOK(res1)) {
43410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43411 }
43412 arg1 = reinterpret_cast< wxMenu * >(argp1);
43413 ecode2 = SWIG_AsVal_int(obj1, &val2);
43414 if (!SWIG_IsOK(ecode2)) {
43415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43416 }
43417 arg2 = static_cast< int >(val2);
43418 {
43419 PyThreadState* __tstate = wxPyBeginAllowThreads();
43420 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43421 wxPyEndAllowThreads(__tstate);
43422 if (PyErr_Occurred()) SWIG_fail;
43423 }
43424 {
43425 resultobj = wxPyMake_wxObject(result, (bool)0);
43426 }
43427 return resultobj;
43428 fail:
43429 return NULL;
43430 }
43431
43432
43433 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43434 PyObject *resultobj = 0;
43435 wxMenu *arg1 = (wxMenu *) 0 ;
43436 size_t arg2 ;
43437 wxMenuItem *result = 0 ;
43438 void *argp1 = 0 ;
43439 int res1 = 0 ;
43440 size_t val2 ;
43441 int ecode2 = 0 ;
43442 PyObject * obj0 = 0 ;
43443 PyObject * obj1 = 0 ;
43444 char * kwnames[] = {
43445 (char *) "self",(char *) "position", NULL
43446 };
43447
43448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43450 if (!SWIG_IsOK(res1)) {
43451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43452 }
43453 arg1 = reinterpret_cast< wxMenu * >(argp1);
43454 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43455 if (!SWIG_IsOK(ecode2)) {
43456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43457 }
43458 arg2 = static_cast< size_t >(val2);
43459 {
43460 PyThreadState* __tstate = wxPyBeginAllowThreads();
43461 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43462 wxPyEndAllowThreads(__tstate);
43463 if (PyErr_Occurred()) SWIG_fail;
43464 }
43465 {
43466 resultobj = wxPyMake_wxObject(result, (bool)0);
43467 }
43468 return resultobj;
43469 fail:
43470 return NULL;
43471 }
43472
43473
43474 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43475 PyObject *resultobj = 0;
43476 wxMenu *arg1 = (wxMenu *) 0 ;
43477 int arg2 ;
43478 bool arg3 ;
43479 void *argp1 = 0 ;
43480 int res1 = 0 ;
43481 int val2 ;
43482 int ecode2 = 0 ;
43483 bool val3 ;
43484 int ecode3 = 0 ;
43485 PyObject * obj0 = 0 ;
43486 PyObject * obj1 = 0 ;
43487 PyObject * obj2 = 0 ;
43488 char * kwnames[] = {
43489 (char *) "self",(char *) "id",(char *) "enable", NULL
43490 };
43491
43492 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43493 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43494 if (!SWIG_IsOK(res1)) {
43495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43496 }
43497 arg1 = reinterpret_cast< wxMenu * >(argp1);
43498 ecode2 = SWIG_AsVal_int(obj1, &val2);
43499 if (!SWIG_IsOK(ecode2)) {
43500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43501 }
43502 arg2 = static_cast< int >(val2);
43503 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43504 if (!SWIG_IsOK(ecode3)) {
43505 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43506 }
43507 arg3 = static_cast< bool >(val3);
43508 {
43509 PyThreadState* __tstate = wxPyBeginAllowThreads();
43510 (arg1)->Enable(arg2,arg3);
43511 wxPyEndAllowThreads(__tstate);
43512 if (PyErr_Occurred()) SWIG_fail;
43513 }
43514 resultobj = SWIG_Py_Void();
43515 return resultobj;
43516 fail:
43517 return NULL;
43518 }
43519
43520
43521 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43522 PyObject *resultobj = 0;
43523 wxMenu *arg1 = (wxMenu *) 0 ;
43524 int arg2 ;
43525 bool result;
43526 void *argp1 = 0 ;
43527 int res1 = 0 ;
43528 int val2 ;
43529 int ecode2 = 0 ;
43530 PyObject * obj0 = 0 ;
43531 PyObject * obj1 = 0 ;
43532 char * kwnames[] = {
43533 (char *) "self",(char *) "id", NULL
43534 };
43535
43536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43538 if (!SWIG_IsOK(res1)) {
43539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43540 }
43541 arg1 = reinterpret_cast< wxMenu * >(argp1);
43542 ecode2 = SWIG_AsVal_int(obj1, &val2);
43543 if (!SWIG_IsOK(ecode2)) {
43544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43545 }
43546 arg2 = static_cast< int >(val2);
43547 {
43548 PyThreadState* __tstate = wxPyBeginAllowThreads();
43549 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43550 wxPyEndAllowThreads(__tstate);
43551 if (PyErr_Occurred()) SWIG_fail;
43552 }
43553 {
43554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43555 }
43556 return resultobj;
43557 fail:
43558 return NULL;
43559 }
43560
43561
43562 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43563 PyObject *resultobj = 0;
43564 wxMenu *arg1 = (wxMenu *) 0 ;
43565 int arg2 ;
43566 bool arg3 ;
43567 void *argp1 = 0 ;
43568 int res1 = 0 ;
43569 int val2 ;
43570 int ecode2 = 0 ;
43571 bool val3 ;
43572 int ecode3 = 0 ;
43573 PyObject * obj0 = 0 ;
43574 PyObject * obj1 = 0 ;
43575 PyObject * obj2 = 0 ;
43576 char * kwnames[] = {
43577 (char *) "self",(char *) "id",(char *) "check", NULL
43578 };
43579
43580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43582 if (!SWIG_IsOK(res1)) {
43583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43584 }
43585 arg1 = reinterpret_cast< wxMenu * >(argp1);
43586 ecode2 = SWIG_AsVal_int(obj1, &val2);
43587 if (!SWIG_IsOK(ecode2)) {
43588 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43589 }
43590 arg2 = static_cast< int >(val2);
43591 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43592 if (!SWIG_IsOK(ecode3)) {
43593 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43594 }
43595 arg3 = static_cast< bool >(val3);
43596 {
43597 PyThreadState* __tstate = wxPyBeginAllowThreads();
43598 (arg1)->Check(arg2,arg3);
43599 wxPyEndAllowThreads(__tstate);
43600 if (PyErr_Occurred()) SWIG_fail;
43601 }
43602 resultobj = SWIG_Py_Void();
43603 return resultobj;
43604 fail:
43605 return NULL;
43606 }
43607
43608
43609 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43610 PyObject *resultobj = 0;
43611 wxMenu *arg1 = (wxMenu *) 0 ;
43612 int arg2 ;
43613 bool result;
43614 void *argp1 = 0 ;
43615 int res1 = 0 ;
43616 int val2 ;
43617 int ecode2 = 0 ;
43618 PyObject * obj0 = 0 ;
43619 PyObject * obj1 = 0 ;
43620 char * kwnames[] = {
43621 (char *) "self",(char *) "id", NULL
43622 };
43623
43624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43626 if (!SWIG_IsOK(res1)) {
43627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43628 }
43629 arg1 = reinterpret_cast< wxMenu * >(argp1);
43630 ecode2 = SWIG_AsVal_int(obj1, &val2);
43631 if (!SWIG_IsOK(ecode2)) {
43632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43633 }
43634 arg2 = static_cast< int >(val2);
43635 {
43636 PyThreadState* __tstate = wxPyBeginAllowThreads();
43637 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43638 wxPyEndAllowThreads(__tstate);
43639 if (PyErr_Occurred()) SWIG_fail;
43640 }
43641 {
43642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43643 }
43644 return resultobj;
43645 fail:
43646 return NULL;
43647 }
43648
43649
43650 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43651 PyObject *resultobj = 0;
43652 wxMenu *arg1 = (wxMenu *) 0 ;
43653 int arg2 ;
43654 wxString *arg3 = 0 ;
43655 void *argp1 = 0 ;
43656 int res1 = 0 ;
43657 int val2 ;
43658 int ecode2 = 0 ;
43659 bool temp3 = false ;
43660 PyObject * obj0 = 0 ;
43661 PyObject * obj1 = 0 ;
43662 PyObject * obj2 = 0 ;
43663 char * kwnames[] = {
43664 (char *) "self",(char *) "id",(char *) "label", NULL
43665 };
43666
43667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43669 if (!SWIG_IsOK(res1)) {
43670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43671 }
43672 arg1 = reinterpret_cast< wxMenu * >(argp1);
43673 ecode2 = SWIG_AsVal_int(obj1, &val2);
43674 if (!SWIG_IsOK(ecode2)) {
43675 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43676 }
43677 arg2 = static_cast< int >(val2);
43678 {
43679 arg3 = wxString_in_helper(obj2);
43680 if (arg3 == NULL) SWIG_fail;
43681 temp3 = true;
43682 }
43683 {
43684 PyThreadState* __tstate = wxPyBeginAllowThreads();
43685 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43686 wxPyEndAllowThreads(__tstate);
43687 if (PyErr_Occurred()) SWIG_fail;
43688 }
43689 resultobj = SWIG_Py_Void();
43690 {
43691 if (temp3)
43692 delete arg3;
43693 }
43694 return resultobj;
43695 fail:
43696 {
43697 if (temp3)
43698 delete arg3;
43699 }
43700 return NULL;
43701 }
43702
43703
43704 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43705 PyObject *resultobj = 0;
43706 wxMenu *arg1 = (wxMenu *) 0 ;
43707 int arg2 ;
43708 wxString result;
43709 void *argp1 = 0 ;
43710 int res1 = 0 ;
43711 int val2 ;
43712 int ecode2 = 0 ;
43713 PyObject * obj0 = 0 ;
43714 PyObject * obj1 = 0 ;
43715 char * kwnames[] = {
43716 (char *) "self",(char *) "id", NULL
43717 };
43718
43719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43721 if (!SWIG_IsOK(res1)) {
43722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43723 }
43724 arg1 = reinterpret_cast< wxMenu * >(argp1);
43725 ecode2 = SWIG_AsVal_int(obj1, &val2);
43726 if (!SWIG_IsOK(ecode2)) {
43727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43728 }
43729 arg2 = static_cast< int >(val2);
43730 {
43731 PyThreadState* __tstate = wxPyBeginAllowThreads();
43732 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43733 wxPyEndAllowThreads(__tstate);
43734 if (PyErr_Occurred()) SWIG_fail;
43735 }
43736 {
43737 #if wxUSE_UNICODE
43738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43739 #else
43740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43741 #endif
43742 }
43743 return resultobj;
43744 fail:
43745 return NULL;
43746 }
43747
43748
43749 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43750 PyObject *resultobj = 0;
43751 wxMenu *arg1 = (wxMenu *) 0 ;
43752 int arg2 ;
43753 wxString *arg3 = 0 ;
43754 void *argp1 = 0 ;
43755 int res1 = 0 ;
43756 int val2 ;
43757 int ecode2 = 0 ;
43758 bool temp3 = false ;
43759 PyObject * obj0 = 0 ;
43760 PyObject * obj1 = 0 ;
43761 PyObject * obj2 = 0 ;
43762 char * kwnames[] = {
43763 (char *) "self",(char *) "id",(char *) "helpString", NULL
43764 };
43765
43766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43768 if (!SWIG_IsOK(res1)) {
43769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43770 }
43771 arg1 = reinterpret_cast< wxMenu * >(argp1);
43772 ecode2 = SWIG_AsVal_int(obj1, &val2);
43773 if (!SWIG_IsOK(ecode2)) {
43774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43775 }
43776 arg2 = static_cast< int >(val2);
43777 {
43778 arg3 = wxString_in_helper(obj2);
43779 if (arg3 == NULL) SWIG_fail;
43780 temp3 = true;
43781 }
43782 {
43783 PyThreadState* __tstate = wxPyBeginAllowThreads();
43784 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43785 wxPyEndAllowThreads(__tstate);
43786 if (PyErr_Occurred()) SWIG_fail;
43787 }
43788 resultobj = SWIG_Py_Void();
43789 {
43790 if (temp3)
43791 delete arg3;
43792 }
43793 return resultobj;
43794 fail:
43795 {
43796 if (temp3)
43797 delete arg3;
43798 }
43799 return NULL;
43800 }
43801
43802
43803 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43804 PyObject *resultobj = 0;
43805 wxMenu *arg1 = (wxMenu *) 0 ;
43806 int arg2 ;
43807 wxString result;
43808 void *argp1 = 0 ;
43809 int res1 = 0 ;
43810 int val2 ;
43811 int ecode2 = 0 ;
43812 PyObject * obj0 = 0 ;
43813 PyObject * obj1 = 0 ;
43814 char * kwnames[] = {
43815 (char *) "self",(char *) "id", NULL
43816 };
43817
43818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
43819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43820 if (!SWIG_IsOK(res1)) {
43821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
43822 }
43823 arg1 = reinterpret_cast< wxMenu * >(argp1);
43824 ecode2 = SWIG_AsVal_int(obj1, &val2);
43825 if (!SWIG_IsOK(ecode2)) {
43826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
43827 }
43828 arg2 = static_cast< int >(val2);
43829 {
43830 PyThreadState* __tstate = wxPyBeginAllowThreads();
43831 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
43832 wxPyEndAllowThreads(__tstate);
43833 if (PyErr_Occurred()) SWIG_fail;
43834 }
43835 {
43836 #if wxUSE_UNICODE
43837 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43838 #else
43839 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43840 #endif
43841 }
43842 return resultobj;
43843 fail:
43844 return NULL;
43845 }
43846
43847
43848 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43849 PyObject *resultobj = 0;
43850 wxMenu *arg1 = (wxMenu *) 0 ;
43851 wxString *arg2 = 0 ;
43852 void *argp1 = 0 ;
43853 int res1 = 0 ;
43854 bool temp2 = false ;
43855 PyObject * obj0 = 0 ;
43856 PyObject * obj1 = 0 ;
43857 char * kwnames[] = {
43858 (char *) "self",(char *) "title", NULL
43859 };
43860
43861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
43862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43863 if (!SWIG_IsOK(res1)) {
43864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
43865 }
43866 arg1 = reinterpret_cast< wxMenu * >(argp1);
43867 {
43868 arg2 = wxString_in_helper(obj1);
43869 if (arg2 == NULL) SWIG_fail;
43870 temp2 = true;
43871 }
43872 {
43873 PyThreadState* __tstate = wxPyBeginAllowThreads();
43874 (arg1)->SetTitle((wxString const &)*arg2);
43875 wxPyEndAllowThreads(__tstate);
43876 if (PyErr_Occurred()) SWIG_fail;
43877 }
43878 resultobj = SWIG_Py_Void();
43879 {
43880 if (temp2)
43881 delete arg2;
43882 }
43883 return resultobj;
43884 fail:
43885 {
43886 if (temp2)
43887 delete arg2;
43888 }
43889 return NULL;
43890 }
43891
43892
43893 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43894 PyObject *resultobj = 0;
43895 wxMenu *arg1 = (wxMenu *) 0 ;
43896 wxString result;
43897 void *argp1 = 0 ;
43898 int res1 = 0 ;
43899 PyObject *swig_obj[1] ;
43900
43901 if (!args) SWIG_fail;
43902 swig_obj[0] = args;
43903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43904 if (!SWIG_IsOK(res1)) {
43905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
43906 }
43907 arg1 = reinterpret_cast< wxMenu * >(argp1);
43908 {
43909 PyThreadState* __tstate = wxPyBeginAllowThreads();
43910 result = ((wxMenu const *)arg1)->GetTitle();
43911 wxPyEndAllowThreads(__tstate);
43912 if (PyErr_Occurred()) SWIG_fail;
43913 }
43914 {
43915 #if wxUSE_UNICODE
43916 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43917 #else
43918 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43919 #endif
43920 }
43921 return resultobj;
43922 fail:
43923 return NULL;
43924 }
43925
43926
43927 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43928 PyObject *resultobj = 0;
43929 wxMenu *arg1 = (wxMenu *) 0 ;
43930 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
43931 void *argp1 = 0 ;
43932 int res1 = 0 ;
43933 void *argp2 = 0 ;
43934 int res2 = 0 ;
43935 PyObject * obj0 = 0 ;
43936 PyObject * obj1 = 0 ;
43937 char * kwnames[] = {
43938 (char *) "self",(char *) "handler", NULL
43939 };
43940
43941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
43942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43943 if (!SWIG_IsOK(res1)) {
43944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
43945 }
43946 arg1 = reinterpret_cast< wxMenu * >(argp1);
43947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
43948 if (!SWIG_IsOK(res2)) {
43949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
43950 }
43951 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
43952 {
43953 PyThreadState* __tstate = wxPyBeginAllowThreads();
43954 (arg1)->SetEventHandler(arg2);
43955 wxPyEndAllowThreads(__tstate);
43956 if (PyErr_Occurred()) SWIG_fail;
43957 }
43958 resultobj = SWIG_Py_Void();
43959 return resultobj;
43960 fail:
43961 return NULL;
43962 }
43963
43964
43965 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43966 PyObject *resultobj = 0;
43967 wxMenu *arg1 = (wxMenu *) 0 ;
43968 wxEvtHandler *result = 0 ;
43969 void *argp1 = 0 ;
43970 int res1 = 0 ;
43971 PyObject *swig_obj[1] ;
43972
43973 if (!args) SWIG_fail;
43974 swig_obj[0] = args;
43975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43976 if (!SWIG_IsOK(res1)) {
43977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
43978 }
43979 arg1 = reinterpret_cast< wxMenu * >(argp1);
43980 {
43981 PyThreadState* __tstate = wxPyBeginAllowThreads();
43982 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
43983 wxPyEndAllowThreads(__tstate);
43984 if (PyErr_Occurred()) SWIG_fail;
43985 }
43986 {
43987 resultobj = wxPyMake_wxObject(result, 0);
43988 }
43989 return resultobj;
43990 fail:
43991 return NULL;
43992 }
43993
43994
43995 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43996 PyObject *resultobj = 0;
43997 wxMenu *arg1 = (wxMenu *) 0 ;
43998 wxWindow *arg2 = (wxWindow *) 0 ;
43999 void *argp1 = 0 ;
44000 int res1 = 0 ;
44001 void *argp2 = 0 ;
44002 int res2 = 0 ;
44003 PyObject * obj0 = 0 ;
44004 PyObject * obj1 = 0 ;
44005 char * kwnames[] = {
44006 (char *) "self",(char *) "win", NULL
44007 };
44008
44009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44011 if (!SWIG_IsOK(res1)) {
44012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44013 }
44014 arg1 = reinterpret_cast< wxMenu * >(argp1);
44015 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44016 if (!SWIG_IsOK(res2)) {
44017 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44018 }
44019 arg2 = reinterpret_cast< wxWindow * >(argp2);
44020 {
44021 PyThreadState* __tstate = wxPyBeginAllowThreads();
44022 (arg1)->SetInvokingWindow(arg2);
44023 wxPyEndAllowThreads(__tstate);
44024 if (PyErr_Occurred()) SWIG_fail;
44025 }
44026 resultobj = SWIG_Py_Void();
44027 return resultobj;
44028 fail:
44029 return NULL;
44030 }
44031
44032
44033 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44034 PyObject *resultobj = 0;
44035 wxMenu *arg1 = (wxMenu *) 0 ;
44036 wxWindow *result = 0 ;
44037 void *argp1 = 0 ;
44038 int res1 = 0 ;
44039 PyObject *swig_obj[1] ;
44040
44041 if (!args) SWIG_fail;
44042 swig_obj[0] = args;
44043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44044 if (!SWIG_IsOK(res1)) {
44045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44046 }
44047 arg1 = reinterpret_cast< wxMenu * >(argp1);
44048 {
44049 PyThreadState* __tstate = wxPyBeginAllowThreads();
44050 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44051 wxPyEndAllowThreads(__tstate);
44052 if (PyErr_Occurred()) SWIG_fail;
44053 }
44054 {
44055 resultobj = wxPyMake_wxObject(result, 0);
44056 }
44057 return resultobj;
44058 fail:
44059 return NULL;
44060 }
44061
44062
44063 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44064 PyObject *resultobj = 0;
44065 wxMenu *arg1 = (wxMenu *) 0 ;
44066 long result;
44067 void *argp1 = 0 ;
44068 int res1 = 0 ;
44069 PyObject *swig_obj[1] ;
44070
44071 if (!args) SWIG_fail;
44072 swig_obj[0] = args;
44073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44074 if (!SWIG_IsOK(res1)) {
44075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44076 }
44077 arg1 = reinterpret_cast< wxMenu * >(argp1);
44078 {
44079 PyThreadState* __tstate = wxPyBeginAllowThreads();
44080 result = (long)((wxMenu const *)arg1)->GetStyle();
44081 wxPyEndAllowThreads(__tstate);
44082 if (PyErr_Occurred()) SWIG_fail;
44083 }
44084 resultobj = SWIG_From_long(static_cast< long >(result));
44085 return resultobj;
44086 fail:
44087 return NULL;
44088 }
44089
44090
44091 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44092 PyObject *resultobj = 0;
44093 wxMenu *arg1 = (wxMenu *) 0 ;
44094 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44095 void *argp1 = 0 ;
44096 int res1 = 0 ;
44097 void *argp2 = 0 ;
44098 int res2 = 0 ;
44099 PyObject * obj0 = 0 ;
44100 PyObject * obj1 = 0 ;
44101 char * kwnames[] = {
44102 (char *) "self",(char *) "source", NULL
44103 };
44104
44105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44107 if (!SWIG_IsOK(res1)) {
44108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44109 }
44110 arg1 = reinterpret_cast< wxMenu * >(argp1);
44111 if (obj1) {
44112 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44113 if (!SWIG_IsOK(res2)) {
44114 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44115 }
44116 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44117 }
44118 {
44119 PyThreadState* __tstate = wxPyBeginAllowThreads();
44120 (arg1)->UpdateUI(arg2);
44121 wxPyEndAllowThreads(__tstate);
44122 if (PyErr_Occurred()) SWIG_fail;
44123 }
44124 resultobj = SWIG_Py_Void();
44125 return resultobj;
44126 fail:
44127 return NULL;
44128 }
44129
44130
44131 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44132 PyObject *resultobj = 0;
44133 wxMenu *arg1 = (wxMenu *) 0 ;
44134 wxMenuBar *result = 0 ;
44135 void *argp1 = 0 ;
44136 int res1 = 0 ;
44137 PyObject *swig_obj[1] ;
44138
44139 if (!args) SWIG_fail;
44140 swig_obj[0] = args;
44141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44142 if (!SWIG_IsOK(res1)) {
44143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44144 }
44145 arg1 = reinterpret_cast< wxMenu * >(argp1);
44146 {
44147 PyThreadState* __tstate = wxPyBeginAllowThreads();
44148 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44149 wxPyEndAllowThreads(__tstate);
44150 if (PyErr_Occurred()) SWIG_fail;
44151 }
44152 {
44153 resultobj = wxPyMake_wxObject(result, (bool)0);
44154 }
44155 return resultobj;
44156 fail:
44157 return NULL;
44158 }
44159
44160
44161 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44162 PyObject *resultobj = 0;
44163 wxMenu *arg1 = (wxMenu *) 0 ;
44164 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44165 void *argp1 = 0 ;
44166 int res1 = 0 ;
44167 void *argp2 = 0 ;
44168 int res2 = 0 ;
44169 PyObject * obj0 = 0 ;
44170 PyObject * obj1 = 0 ;
44171 char * kwnames[] = {
44172 (char *) "self",(char *) "menubar", NULL
44173 };
44174
44175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44177 if (!SWIG_IsOK(res1)) {
44178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44179 }
44180 arg1 = reinterpret_cast< wxMenu * >(argp1);
44181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44182 if (!SWIG_IsOK(res2)) {
44183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44184 }
44185 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44186 {
44187 PyThreadState* __tstate = wxPyBeginAllowThreads();
44188 (arg1)->Attach(arg2);
44189 wxPyEndAllowThreads(__tstate);
44190 if (PyErr_Occurred()) SWIG_fail;
44191 }
44192 resultobj = SWIG_Py_Void();
44193 return resultobj;
44194 fail:
44195 return NULL;
44196 }
44197
44198
44199 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44200 PyObject *resultobj = 0;
44201 wxMenu *arg1 = (wxMenu *) 0 ;
44202 void *argp1 = 0 ;
44203 int res1 = 0 ;
44204 PyObject *swig_obj[1] ;
44205
44206 if (!args) SWIG_fail;
44207 swig_obj[0] = args;
44208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44209 if (!SWIG_IsOK(res1)) {
44210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44211 }
44212 arg1 = reinterpret_cast< wxMenu * >(argp1);
44213 {
44214 PyThreadState* __tstate = wxPyBeginAllowThreads();
44215 (arg1)->Detach();
44216 wxPyEndAllowThreads(__tstate);
44217 if (PyErr_Occurred()) SWIG_fail;
44218 }
44219 resultobj = SWIG_Py_Void();
44220 return resultobj;
44221 fail:
44222 return NULL;
44223 }
44224
44225
44226 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44227 PyObject *resultobj = 0;
44228 wxMenu *arg1 = (wxMenu *) 0 ;
44229 bool result;
44230 void *argp1 = 0 ;
44231 int res1 = 0 ;
44232 PyObject *swig_obj[1] ;
44233
44234 if (!args) SWIG_fail;
44235 swig_obj[0] = args;
44236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44237 if (!SWIG_IsOK(res1)) {
44238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44239 }
44240 arg1 = reinterpret_cast< wxMenu * >(argp1);
44241 {
44242 PyThreadState* __tstate = wxPyBeginAllowThreads();
44243 result = (bool)((wxMenu const *)arg1)->IsAttached();
44244 wxPyEndAllowThreads(__tstate);
44245 if (PyErr_Occurred()) SWIG_fail;
44246 }
44247 {
44248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44249 }
44250 return resultobj;
44251 fail:
44252 return NULL;
44253 }
44254
44255
44256 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44257 PyObject *resultobj = 0;
44258 wxMenu *arg1 = (wxMenu *) 0 ;
44259 wxMenu *arg2 = (wxMenu *) 0 ;
44260 void *argp1 = 0 ;
44261 int res1 = 0 ;
44262 void *argp2 = 0 ;
44263 int res2 = 0 ;
44264 PyObject * obj0 = 0 ;
44265 PyObject * obj1 = 0 ;
44266 char * kwnames[] = {
44267 (char *) "self",(char *) "parent", NULL
44268 };
44269
44270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44272 if (!SWIG_IsOK(res1)) {
44273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44274 }
44275 arg1 = reinterpret_cast< wxMenu * >(argp1);
44276 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44277 if (!SWIG_IsOK(res2)) {
44278 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44279 }
44280 arg2 = reinterpret_cast< wxMenu * >(argp2);
44281 {
44282 PyThreadState* __tstate = wxPyBeginAllowThreads();
44283 (arg1)->SetParent(arg2);
44284 wxPyEndAllowThreads(__tstate);
44285 if (PyErr_Occurred()) SWIG_fail;
44286 }
44287 resultobj = SWIG_Py_Void();
44288 return resultobj;
44289 fail:
44290 return NULL;
44291 }
44292
44293
44294 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44295 PyObject *resultobj = 0;
44296 wxMenu *arg1 = (wxMenu *) 0 ;
44297 wxMenu *result = 0 ;
44298 void *argp1 = 0 ;
44299 int res1 = 0 ;
44300 PyObject *swig_obj[1] ;
44301
44302 if (!args) SWIG_fail;
44303 swig_obj[0] = args;
44304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44305 if (!SWIG_IsOK(res1)) {
44306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44307 }
44308 arg1 = reinterpret_cast< wxMenu * >(argp1);
44309 {
44310 PyThreadState* __tstate = wxPyBeginAllowThreads();
44311 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44312 wxPyEndAllowThreads(__tstate);
44313 if (PyErr_Occurred()) SWIG_fail;
44314 }
44315 {
44316 resultobj = wxPyMake_wxObject(result, 0);
44317 }
44318 return resultobj;
44319 fail:
44320 return NULL;
44321 }
44322
44323
44324 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44325 PyObject *obj;
44326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44327 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44328 return SWIG_Py_Void();
44329 }
44330
44331 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44332 return SWIG_Python_InitShadowInstance(args);
44333 }
44334
44335 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44336 PyObject *resultobj = 0;
44337 long arg1 = (long) 0 ;
44338 wxMenuBar *result = 0 ;
44339 long val1 ;
44340 int ecode1 = 0 ;
44341 PyObject * obj0 = 0 ;
44342 char * kwnames[] = {
44343 (char *) "style", NULL
44344 };
44345
44346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44347 if (obj0) {
44348 ecode1 = SWIG_AsVal_long(obj0, &val1);
44349 if (!SWIG_IsOK(ecode1)) {
44350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44351 }
44352 arg1 = static_cast< long >(val1);
44353 }
44354 {
44355 if (!wxPyCheckForApp()) SWIG_fail;
44356 PyThreadState* __tstate = wxPyBeginAllowThreads();
44357 result = (wxMenuBar *)new wxMenuBar(arg1);
44358 wxPyEndAllowThreads(__tstate);
44359 if (PyErr_Occurred()) SWIG_fail;
44360 }
44361 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44362 return resultobj;
44363 fail:
44364 return NULL;
44365 }
44366
44367
44368 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44369 PyObject *resultobj = 0;
44370 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44371 wxMenu *arg2 = (wxMenu *) 0 ;
44372 wxString *arg3 = 0 ;
44373 bool result;
44374 void *argp1 = 0 ;
44375 int res1 = 0 ;
44376 void *argp2 = 0 ;
44377 int res2 = 0 ;
44378 bool temp3 = false ;
44379 PyObject * obj0 = 0 ;
44380 PyObject * obj1 = 0 ;
44381 PyObject * obj2 = 0 ;
44382 char * kwnames[] = {
44383 (char *) "self",(char *) "menu",(char *) "title", NULL
44384 };
44385
44386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44388 if (!SWIG_IsOK(res1)) {
44389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44390 }
44391 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44393 if (!SWIG_IsOK(res2)) {
44394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44395 }
44396 arg2 = reinterpret_cast< wxMenu * >(argp2);
44397 {
44398 arg3 = wxString_in_helper(obj2);
44399 if (arg3 == NULL) SWIG_fail;
44400 temp3 = true;
44401 }
44402 {
44403 PyThreadState* __tstate = wxPyBeginAllowThreads();
44404 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44405 wxPyEndAllowThreads(__tstate);
44406 if (PyErr_Occurred()) SWIG_fail;
44407 }
44408 {
44409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44410 }
44411 {
44412 if (temp3)
44413 delete arg3;
44414 }
44415 return resultobj;
44416 fail:
44417 {
44418 if (temp3)
44419 delete arg3;
44420 }
44421 return NULL;
44422 }
44423
44424
44425 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44426 PyObject *resultobj = 0;
44427 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44428 size_t arg2 ;
44429 wxMenu *arg3 = (wxMenu *) 0 ;
44430 wxString *arg4 = 0 ;
44431 bool result;
44432 void *argp1 = 0 ;
44433 int res1 = 0 ;
44434 size_t val2 ;
44435 int ecode2 = 0 ;
44436 void *argp3 = 0 ;
44437 int res3 = 0 ;
44438 bool temp4 = false ;
44439 PyObject * obj0 = 0 ;
44440 PyObject * obj1 = 0 ;
44441 PyObject * obj2 = 0 ;
44442 PyObject * obj3 = 0 ;
44443 char * kwnames[] = {
44444 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44445 };
44446
44447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44449 if (!SWIG_IsOK(res1)) {
44450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44451 }
44452 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44453 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44454 if (!SWIG_IsOK(ecode2)) {
44455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44456 }
44457 arg2 = static_cast< size_t >(val2);
44458 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44459 if (!SWIG_IsOK(res3)) {
44460 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44461 }
44462 arg3 = reinterpret_cast< wxMenu * >(argp3);
44463 {
44464 arg4 = wxString_in_helper(obj3);
44465 if (arg4 == NULL) SWIG_fail;
44466 temp4 = true;
44467 }
44468 {
44469 PyThreadState* __tstate = wxPyBeginAllowThreads();
44470 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44471 wxPyEndAllowThreads(__tstate);
44472 if (PyErr_Occurred()) SWIG_fail;
44473 }
44474 {
44475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44476 }
44477 {
44478 if (temp4)
44479 delete arg4;
44480 }
44481 return resultobj;
44482 fail:
44483 {
44484 if (temp4)
44485 delete arg4;
44486 }
44487 return NULL;
44488 }
44489
44490
44491 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44492 PyObject *resultobj = 0;
44493 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44494 size_t result;
44495 void *argp1 = 0 ;
44496 int res1 = 0 ;
44497 PyObject *swig_obj[1] ;
44498
44499 if (!args) SWIG_fail;
44500 swig_obj[0] = args;
44501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44502 if (!SWIG_IsOK(res1)) {
44503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44504 }
44505 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44506 {
44507 PyThreadState* __tstate = wxPyBeginAllowThreads();
44508 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44509 wxPyEndAllowThreads(__tstate);
44510 if (PyErr_Occurred()) SWIG_fail;
44511 }
44512 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44513 return resultobj;
44514 fail:
44515 return NULL;
44516 }
44517
44518
44519 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44520 PyObject *resultobj = 0;
44521 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44522 size_t arg2 ;
44523 wxMenu *result = 0 ;
44524 void *argp1 = 0 ;
44525 int res1 = 0 ;
44526 size_t val2 ;
44527 int ecode2 = 0 ;
44528 PyObject * obj0 = 0 ;
44529 PyObject * obj1 = 0 ;
44530 char * kwnames[] = {
44531 (char *) "self",(char *) "pos", NULL
44532 };
44533
44534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44536 if (!SWIG_IsOK(res1)) {
44537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44538 }
44539 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44540 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44541 if (!SWIG_IsOK(ecode2)) {
44542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44543 }
44544 arg2 = static_cast< size_t >(val2);
44545 {
44546 PyThreadState* __tstate = wxPyBeginAllowThreads();
44547 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44548 wxPyEndAllowThreads(__tstate);
44549 if (PyErr_Occurred()) SWIG_fail;
44550 }
44551 {
44552 resultobj = wxPyMake_wxObject(result, 0);
44553 }
44554 return resultobj;
44555 fail:
44556 return NULL;
44557 }
44558
44559
44560 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44561 PyObject *resultobj = 0;
44562 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44563 size_t arg2 ;
44564 wxMenu *arg3 = (wxMenu *) 0 ;
44565 wxString *arg4 = 0 ;
44566 wxMenu *result = 0 ;
44567 void *argp1 = 0 ;
44568 int res1 = 0 ;
44569 size_t val2 ;
44570 int ecode2 = 0 ;
44571 void *argp3 = 0 ;
44572 int res3 = 0 ;
44573 bool temp4 = false ;
44574 PyObject * obj0 = 0 ;
44575 PyObject * obj1 = 0 ;
44576 PyObject * obj2 = 0 ;
44577 PyObject * obj3 = 0 ;
44578 char * kwnames[] = {
44579 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44580 };
44581
44582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44584 if (!SWIG_IsOK(res1)) {
44585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44586 }
44587 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44588 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44589 if (!SWIG_IsOK(ecode2)) {
44590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44591 }
44592 arg2 = static_cast< size_t >(val2);
44593 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44594 if (!SWIG_IsOK(res3)) {
44595 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44596 }
44597 arg3 = reinterpret_cast< wxMenu * >(argp3);
44598 {
44599 arg4 = wxString_in_helper(obj3);
44600 if (arg4 == NULL) SWIG_fail;
44601 temp4 = true;
44602 }
44603 {
44604 PyThreadState* __tstate = wxPyBeginAllowThreads();
44605 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44606 wxPyEndAllowThreads(__tstate);
44607 if (PyErr_Occurred()) SWIG_fail;
44608 }
44609 {
44610 resultobj = wxPyMake_wxObject(result, 0);
44611 }
44612 {
44613 if (temp4)
44614 delete arg4;
44615 }
44616 return resultobj;
44617 fail:
44618 {
44619 if (temp4)
44620 delete arg4;
44621 }
44622 return NULL;
44623 }
44624
44625
44626 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44627 PyObject *resultobj = 0;
44628 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44629 size_t arg2 ;
44630 wxMenu *result = 0 ;
44631 void *argp1 = 0 ;
44632 int res1 = 0 ;
44633 size_t val2 ;
44634 int ecode2 = 0 ;
44635 PyObject * obj0 = 0 ;
44636 PyObject * obj1 = 0 ;
44637 char * kwnames[] = {
44638 (char *) "self",(char *) "pos", NULL
44639 };
44640
44641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44643 if (!SWIG_IsOK(res1)) {
44644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44645 }
44646 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44647 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44648 if (!SWIG_IsOK(ecode2)) {
44649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44650 }
44651 arg2 = static_cast< size_t >(val2);
44652 {
44653 PyThreadState* __tstate = wxPyBeginAllowThreads();
44654 result = (wxMenu *)(arg1)->Remove(arg2);
44655 wxPyEndAllowThreads(__tstate);
44656 if (PyErr_Occurred()) SWIG_fail;
44657 }
44658 {
44659 resultobj = wxPyMake_wxObject(result, 0);
44660 }
44661 return resultobj;
44662 fail:
44663 return NULL;
44664 }
44665
44666
44667 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44668 PyObject *resultobj = 0;
44669 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44670 size_t arg2 ;
44671 bool arg3 ;
44672 void *argp1 = 0 ;
44673 int res1 = 0 ;
44674 size_t val2 ;
44675 int ecode2 = 0 ;
44676 bool val3 ;
44677 int ecode3 = 0 ;
44678 PyObject * obj0 = 0 ;
44679 PyObject * obj1 = 0 ;
44680 PyObject * obj2 = 0 ;
44681 char * kwnames[] = {
44682 (char *) "self",(char *) "pos",(char *) "enable", NULL
44683 };
44684
44685 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44686 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44687 if (!SWIG_IsOK(res1)) {
44688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44689 }
44690 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44691 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44692 if (!SWIG_IsOK(ecode2)) {
44693 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44694 }
44695 arg2 = static_cast< size_t >(val2);
44696 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44697 if (!SWIG_IsOK(ecode3)) {
44698 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44699 }
44700 arg3 = static_cast< bool >(val3);
44701 {
44702 PyThreadState* __tstate = wxPyBeginAllowThreads();
44703 (arg1)->EnableTop(arg2,arg3);
44704 wxPyEndAllowThreads(__tstate);
44705 if (PyErr_Occurred()) SWIG_fail;
44706 }
44707 resultobj = SWIG_Py_Void();
44708 return resultobj;
44709 fail:
44710 return NULL;
44711 }
44712
44713
44714 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44715 PyObject *resultobj = 0;
44716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44717 size_t arg2 ;
44718 bool result;
44719 void *argp1 = 0 ;
44720 int res1 = 0 ;
44721 size_t val2 ;
44722 int ecode2 = 0 ;
44723 PyObject * obj0 = 0 ;
44724 PyObject * obj1 = 0 ;
44725 char * kwnames[] = {
44726 (char *) "self",(char *) "pos", NULL
44727 };
44728
44729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44731 if (!SWIG_IsOK(res1)) {
44732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44733 }
44734 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44735 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44736 if (!SWIG_IsOK(ecode2)) {
44737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44738 }
44739 arg2 = static_cast< size_t >(val2);
44740 {
44741 PyThreadState* __tstate = wxPyBeginAllowThreads();
44742 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44743 wxPyEndAllowThreads(__tstate);
44744 if (PyErr_Occurred()) SWIG_fail;
44745 }
44746 {
44747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44748 }
44749 return resultobj;
44750 fail:
44751 return NULL;
44752 }
44753
44754
44755 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44756 PyObject *resultobj = 0;
44757 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44758 size_t arg2 ;
44759 wxString *arg3 = 0 ;
44760 void *argp1 = 0 ;
44761 int res1 = 0 ;
44762 size_t val2 ;
44763 int ecode2 = 0 ;
44764 bool temp3 = false ;
44765 PyObject * obj0 = 0 ;
44766 PyObject * obj1 = 0 ;
44767 PyObject * obj2 = 0 ;
44768 char * kwnames[] = {
44769 (char *) "self",(char *) "pos",(char *) "label", NULL
44770 };
44771
44772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44774 if (!SWIG_IsOK(res1)) {
44775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44776 }
44777 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44778 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44779 if (!SWIG_IsOK(ecode2)) {
44780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44781 }
44782 arg2 = static_cast< size_t >(val2);
44783 {
44784 arg3 = wxString_in_helper(obj2);
44785 if (arg3 == NULL) SWIG_fail;
44786 temp3 = true;
44787 }
44788 {
44789 PyThreadState* __tstate = wxPyBeginAllowThreads();
44790 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44791 wxPyEndAllowThreads(__tstate);
44792 if (PyErr_Occurred()) SWIG_fail;
44793 }
44794 resultobj = SWIG_Py_Void();
44795 {
44796 if (temp3)
44797 delete arg3;
44798 }
44799 return resultobj;
44800 fail:
44801 {
44802 if (temp3)
44803 delete arg3;
44804 }
44805 return NULL;
44806 }
44807
44808
44809 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44810 PyObject *resultobj = 0;
44811 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44812 size_t arg2 ;
44813 wxString result;
44814 void *argp1 = 0 ;
44815 int res1 = 0 ;
44816 size_t val2 ;
44817 int ecode2 = 0 ;
44818 PyObject * obj0 = 0 ;
44819 PyObject * obj1 = 0 ;
44820 char * kwnames[] = {
44821 (char *) "self",(char *) "pos", NULL
44822 };
44823
44824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
44825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44826 if (!SWIG_IsOK(res1)) {
44827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44828 }
44829 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44830 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44831 if (!SWIG_IsOK(ecode2)) {
44832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44833 }
44834 arg2 = static_cast< size_t >(val2);
44835 {
44836 PyThreadState* __tstate = wxPyBeginAllowThreads();
44837 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
44838 wxPyEndAllowThreads(__tstate);
44839 if (PyErr_Occurred()) SWIG_fail;
44840 }
44841 {
44842 #if wxUSE_UNICODE
44843 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44844 #else
44845 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44846 #endif
44847 }
44848 return resultobj;
44849 fail:
44850 return NULL;
44851 }
44852
44853
44854 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44855 PyObject *resultobj = 0;
44856 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44857 wxString *arg2 = 0 ;
44858 wxString *arg3 = 0 ;
44859 int result;
44860 void *argp1 = 0 ;
44861 int res1 = 0 ;
44862 bool temp2 = false ;
44863 bool temp3 = false ;
44864 PyObject * obj0 = 0 ;
44865 PyObject * obj1 = 0 ;
44866 PyObject * obj2 = 0 ;
44867 char * kwnames[] = {
44868 (char *) "self",(char *) "menu",(char *) "item", NULL
44869 };
44870
44871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44873 if (!SWIG_IsOK(res1)) {
44874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44875 }
44876 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44877 {
44878 arg2 = wxString_in_helper(obj1);
44879 if (arg2 == NULL) SWIG_fail;
44880 temp2 = true;
44881 }
44882 {
44883 arg3 = wxString_in_helper(obj2);
44884 if (arg3 == NULL) SWIG_fail;
44885 temp3 = true;
44886 }
44887 {
44888 PyThreadState* __tstate = wxPyBeginAllowThreads();
44889 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
44890 wxPyEndAllowThreads(__tstate);
44891 if (PyErr_Occurred()) SWIG_fail;
44892 }
44893 resultobj = SWIG_From_int(static_cast< int >(result));
44894 {
44895 if (temp2)
44896 delete arg2;
44897 }
44898 {
44899 if (temp3)
44900 delete arg3;
44901 }
44902 return resultobj;
44903 fail:
44904 {
44905 if (temp2)
44906 delete arg2;
44907 }
44908 {
44909 if (temp3)
44910 delete arg3;
44911 }
44912 return NULL;
44913 }
44914
44915
44916 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44917 PyObject *resultobj = 0;
44918 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44919 int arg2 ;
44920 wxMenuItem *result = 0 ;
44921 void *argp1 = 0 ;
44922 int res1 = 0 ;
44923 int val2 ;
44924 int ecode2 = 0 ;
44925 PyObject * obj0 = 0 ;
44926 PyObject * obj1 = 0 ;
44927 char * kwnames[] = {
44928 (char *) "self",(char *) "id", NULL
44929 };
44930
44931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
44932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44933 if (!SWIG_IsOK(res1)) {
44934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44935 }
44936 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44937 ecode2 = SWIG_AsVal_int(obj1, &val2);
44938 if (!SWIG_IsOK(ecode2)) {
44939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
44940 }
44941 arg2 = static_cast< int >(val2);
44942 {
44943 PyThreadState* __tstate = wxPyBeginAllowThreads();
44944 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
44945 wxPyEndAllowThreads(__tstate);
44946 if (PyErr_Occurred()) SWIG_fail;
44947 }
44948 {
44949 resultobj = wxPyMake_wxObject(result, (bool)0);
44950 }
44951 return resultobj;
44952 fail:
44953 return NULL;
44954 }
44955
44956
44957 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44958 PyObject *resultobj = 0;
44959 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44960 wxString *arg2 = 0 ;
44961 int result;
44962 void *argp1 = 0 ;
44963 int res1 = 0 ;
44964 bool temp2 = false ;
44965 PyObject * obj0 = 0 ;
44966 PyObject * obj1 = 0 ;
44967 char * kwnames[] = {
44968 (char *) "self",(char *) "title", NULL
44969 };
44970
44971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) 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_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
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 PyThreadState* __tstate = wxPyBeginAllowThreads();
44984 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
44985 wxPyEndAllowThreads(__tstate);
44986 if (PyErr_Occurred()) SWIG_fail;
44987 }
44988 resultobj = SWIG_From_int(static_cast< int >(result));
44989 {
44990 if (temp2)
44991 delete arg2;
44992 }
44993 return resultobj;
44994 fail:
44995 {
44996 if (temp2)
44997 delete arg2;
44998 }
44999 return NULL;
45000 }
45001
45002
45003 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45004 PyObject *resultobj = 0;
45005 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45006 int arg2 ;
45007 bool arg3 ;
45008 void *argp1 = 0 ;
45009 int res1 = 0 ;
45010 int val2 ;
45011 int ecode2 = 0 ;
45012 bool val3 ;
45013 int ecode3 = 0 ;
45014 PyObject * obj0 = 0 ;
45015 PyObject * obj1 = 0 ;
45016 PyObject * obj2 = 0 ;
45017 char * kwnames[] = {
45018 (char *) "self",(char *) "id",(char *) "enable", NULL
45019 };
45020
45021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45023 if (!SWIG_IsOK(res1)) {
45024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45025 }
45026 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45027 ecode2 = SWIG_AsVal_int(obj1, &val2);
45028 if (!SWIG_IsOK(ecode2)) {
45029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45030 }
45031 arg2 = static_cast< int >(val2);
45032 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45033 if (!SWIG_IsOK(ecode3)) {
45034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45035 }
45036 arg3 = static_cast< bool >(val3);
45037 {
45038 PyThreadState* __tstate = wxPyBeginAllowThreads();
45039 (arg1)->Enable(arg2,arg3);
45040 wxPyEndAllowThreads(__tstate);
45041 if (PyErr_Occurred()) SWIG_fail;
45042 }
45043 resultobj = SWIG_Py_Void();
45044 return resultobj;
45045 fail:
45046 return NULL;
45047 }
45048
45049
45050 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45051 PyObject *resultobj = 0;
45052 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45053 int arg2 ;
45054 bool arg3 ;
45055 void *argp1 = 0 ;
45056 int res1 = 0 ;
45057 int val2 ;
45058 int ecode2 = 0 ;
45059 bool val3 ;
45060 int ecode3 = 0 ;
45061 PyObject * obj0 = 0 ;
45062 PyObject * obj1 = 0 ;
45063 PyObject * obj2 = 0 ;
45064 char * kwnames[] = {
45065 (char *) "self",(char *) "id",(char *) "check", NULL
45066 };
45067
45068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45070 if (!SWIG_IsOK(res1)) {
45071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45072 }
45073 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45074 ecode2 = SWIG_AsVal_int(obj1, &val2);
45075 if (!SWIG_IsOK(ecode2)) {
45076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45077 }
45078 arg2 = static_cast< int >(val2);
45079 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45080 if (!SWIG_IsOK(ecode3)) {
45081 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45082 }
45083 arg3 = static_cast< bool >(val3);
45084 {
45085 PyThreadState* __tstate = wxPyBeginAllowThreads();
45086 (arg1)->Check(arg2,arg3);
45087 wxPyEndAllowThreads(__tstate);
45088 if (PyErr_Occurred()) SWIG_fail;
45089 }
45090 resultobj = SWIG_Py_Void();
45091 return resultobj;
45092 fail:
45093 return NULL;
45094 }
45095
45096
45097 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45098 PyObject *resultobj = 0;
45099 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45100 int arg2 ;
45101 bool result;
45102 void *argp1 = 0 ;
45103 int res1 = 0 ;
45104 int val2 ;
45105 int ecode2 = 0 ;
45106 PyObject * obj0 = 0 ;
45107 PyObject * obj1 = 0 ;
45108 char * kwnames[] = {
45109 (char *) "self",(char *) "id", NULL
45110 };
45111
45112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45113 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45114 if (!SWIG_IsOK(res1)) {
45115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45116 }
45117 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45118 ecode2 = SWIG_AsVal_int(obj1, &val2);
45119 if (!SWIG_IsOK(ecode2)) {
45120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45121 }
45122 arg2 = static_cast< int >(val2);
45123 {
45124 PyThreadState* __tstate = wxPyBeginAllowThreads();
45125 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45126 wxPyEndAllowThreads(__tstate);
45127 if (PyErr_Occurred()) SWIG_fail;
45128 }
45129 {
45130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45131 }
45132 return resultobj;
45133 fail:
45134 return NULL;
45135 }
45136
45137
45138 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45139 PyObject *resultobj = 0;
45140 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45141 int arg2 ;
45142 bool result;
45143 void *argp1 = 0 ;
45144 int res1 = 0 ;
45145 int val2 ;
45146 int ecode2 = 0 ;
45147 PyObject * obj0 = 0 ;
45148 PyObject * obj1 = 0 ;
45149 char * kwnames[] = {
45150 (char *) "self",(char *) "id", NULL
45151 };
45152
45153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45155 if (!SWIG_IsOK(res1)) {
45156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45157 }
45158 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45159 ecode2 = SWIG_AsVal_int(obj1, &val2);
45160 if (!SWIG_IsOK(ecode2)) {
45161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45162 }
45163 arg2 = static_cast< int >(val2);
45164 {
45165 PyThreadState* __tstate = wxPyBeginAllowThreads();
45166 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45167 wxPyEndAllowThreads(__tstate);
45168 if (PyErr_Occurred()) SWIG_fail;
45169 }
45170 {
45171 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45172 }
45173 return resultobj;
45174 fail:
45175 return NULL;
45176 }
45177
45178
45179 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45180 PyObject *resultobj = 0;
45181 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45182 int arg2 ;
45183 wxString *arg3 = 0 ;
45184 void *argp1 = 0 ;
45185 int res1 = 0 ;
45186 int val2 ;
45187 int ecode2 = 0 ;
45188 bool temp3 = false ;
45189 PyObject * obj0 = 0 ;
45190 PyObject * obj1 = 0 ;
45191 PyObject * obj2 = 0 ;
45192 char * kwnames[] = {
45193 (char *) "self",(char *) "id",(char *) "label", NULL
45194 };
45195
45196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45198 if (!SWIG_IsOK(res1)) {
45199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45200 }
45201 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45202 ecode2 = SWIG_AsVal_int(obj1, &val2);
45203 if (!SWIG_IsOK(ecode2)) {
45204 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45205 }
45206 arg2 = static_cast< int >(val2);
45207 {
45208 arg3 = wxString_in_helper(obj2);
45209 if (arg3 == NULL) SWIG_fail;
45210 temp3 = true;
45211 }
45212 {
45213 PyThreadState* __tstate = wxPyBeginAllowThreads();
45214 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45215 wxPyEndAllowThreads(__tstate);
45216 if (PyErr_Occurred()) SWIG_fail;
45217 }
45218 resultobj = SWIG_Py_Void();
45219 {
45220 if (temp3)
45221 delete arg3;
45222 }
45223 return resultobj;
45224 fail:
45225 {
45226 if (temp3)
45227 delete arg3;
45228 }
45229 return NULL;
45230 }
45231
45232
45233 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45234 PyObject *resultobj = 0;
45235 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45236 int arg2 ;
45237 wxString result;
45238 void *argp1 = 0 ;
45239 int res1 = 0 ;
45240 int val2 ;
45241 int ecode2 = 0 ;
45242 PyObject * obj0 = 0 ;
45243 PyObject * obj1 = 0 ;
45244 char * kwnames[] = {
45245 (char *) "self",(char *) "id", NULL
45246 };
45247
45248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45250 if (!SWIG_IsOK(res1)) {
45251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45252 }
45253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45254 ecode2 = SWIG_AsVal_int(obj1, &val2);
45255 if (!SWIG_IsOK(ecode2)) {
45256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45257 }
45258 arg2 = static_cast< int >(val2);
45259 {
45260 PyThreadState* __tstate = wxPyBeginAllowThreads();
45261 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45262 wxPyEndAllowThreads(__tstate);
45263 if (PyErr_Occurred()) SWIG_fail;
45264 }
45265 {
45266 #if wxUSE_UNICODE
45267 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45268 #else
45269 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45270 #endif
45271 }
45272 return resultobj;
45273 fail:
45274 return NULL;
45275 }
45276
45277
45278 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45279 PyObject *resultobj = 0;
45280 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45281 int arg2 ;
45282 wxString *arg3 = 0 ;
45283 void *argp1 = 0 ;
45284 int res1 = 0 ;
45285 int val2 ;
45286 int ecode2 = 0 ;
45287 bool temp3 = false ;
45288 PyObject * obj0 = 0 ;
45289 PyObject * obj1 = 0 ;
45290 PyObject * obj2 = 0 ;
45291 char * kwnames[] = {
45292 (char *) "self",(char *) "id",(char *) "helpString", NULL
45293 };
45294
45295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45297 if (!SWIG_IsOK(res1)) {
45298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45299 }
45300 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45301 ecode2 = SWIG_AsVal_int(obj1, &val2);
45302 if (!SWIG_IsOK(ecode2)) {
45303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45304 }
45305 arg2 = static_cast< int >(val2);
45306 {
45307 arg3 = wxString_in_helper(obj2);
45308 if (arg3 == NULL) SWIG_fail;
45309 temp3 = true;
45310 }
45311 {
45312 PyThreadState* __tstate = wxPyBeginAllowThreads();
45313 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45314 wxPyEndAllowThreads(__tstate);
45315 if (PyErr_Occurred()) SWIG_fail;
45316 }
45317 resultobj = SWIG_Py_Void();
45318 {
45319 if (temp3)
45320 delete arg3;
45321 }
45322 return resultobj;
45323 fail:
45324 {
45325 if (temp3)
45326 delete arg3;
45327 }
45328 return NULL;
45329 }
45330
45331
45332 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45333 PyObject *resultobj = 0;
45334 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45335 int arg2 ;
45336 wxString result;
45337 void *argp1 = 0 ;
45338 int res1 = 0 ;
45339 int val2 ;
45340 int ecode2 = 0 ;
45341 PyObject * obj0 = 0 ;
45342 PyObject * obj1 = 0 ;
45343 char * kwnames[] = {
45344 (char *) "self",(char *) "id", NULL
45345 };
45346
45347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45349 if (!SWIG_IsOK(res1)) {
45350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45351 }
45352 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45353 ecode2 = SWIG_AsVal_int(obj1, &val2);
45354 if (!SWIG_IsOK(ecode2)) {
45355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45356 }
45357 arg2 = static_cast< int >(val2);
45358 {
45359 PyThreadState* __tstate = wxPyBeginAllowThreads();
45360 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45361 wxPyEndAllowThreads(__tstate);
45362 if (PyErr_Occurred()) SWIG_fail;
45363 }
45364 {
45365 #if wxUSE_UNICODE
45366 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45367 #else
45368 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45369 #endif
45370 }
45371 return resultobj;
45372 fail:
45373 return NULL;
45374 }
45375
45376
45377 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45378 PyObject *resultobj = 0;
45379 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45380 wxFrame *result = 0 ;
45381 void *argp1 = 0 ;
45382 int res1 = 0 ;
45383 PyObject *swig_obj[1] ;
45384
45385 if (!args) SWIG_fail;
45386 swig_obj[0] = args;
45387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45388 if (!SWIG_IsOK(res1)) {
45389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45390 }
45391 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45392 {
45393 PyThreadState* __tstate = wxPyBeginAllowThreads();
45394 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45395 wxPyEndAllowThreads(__tstate);
45396 if (PyErr_Occurred()) SWIG_fail;
45397 }
45398 {
45399 resultobj = wxPyMake_wxObject(result, (bool)0);
45400 }
45401 return resultobj;
45402 fail:
45403 return NULL;
45404 }
45405
45406
45407 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45408 PyObject *resultobj = 0;
45409 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45410 bool result;
45411 void *argp1 = 0 ;
45412 int res1 = 0 ;
45413 PyObject *swig_obj[1] ;
45414
45415 if (!args) SWIG_fail;
45416 swig_obj[0] = args;
45417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45418 if (!SWIG_IsOK(res1)) {
45419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45420 }
45421 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45422 {
45423 PyThreadState* __tstate = wxPyBeginAllowThreads();
45424 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45425 wxPyEndAllowThreads(__tstate);
45426 if (PyErr_Occurred()) SWIG_fail;
45427 }
45428 {
45429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45430 }
45431 return resultobj;
45432 fail:
45433 return NULL;
45434 }
45435
45436
45437 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45438 PyObject *resultobj = 0;
45439 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45440 wxFrame *arg2 = (wxFrame *) 0 ;
45441 void *argp1 = 0 ;
45442 int res1 = 0 ;
45443 void *argp2 = 0 ;
45444 int res2 = 0 ;
45445 PyObject * obj0 = 0 ;
45446 PyObject * obj1 = 0 ;
45447 char * kwnames[] = {
45448 (char *) "self",(char *) "frame", NULL
45449 };
45450
45451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45453 if (!SWIG_IsOK(res1)) {
45454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45455 }
45456 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45457 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45458 if (!SWIG_IsOK(res2)) {
45459 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45460 }
45461 arg2 = reinterpret_cast< wxFrame * >(argp2);
45462 {
45463 PyThreadState* __tstate = wxPyBeginAllowThreads();
45464 (arg1)->Attach(arg2);
45465 wxPyEndAllowThreads(__tstate);
45466 if (PyErr_Occurred()) SWIG_fail;
45467 }
45468 resultobj = SWIG_Py_Void();
45469 return resultobj;
45470 fail:
45471 return NULL;
45472 }
45473
45474
45475 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45476 PyObject *resultobj = 0;
45477 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45478 void *argp1 = 0 ;
45479 int res1 = 0 ;
45480 PyObject *swig_obj[1] ;
45481
45482 if (!args) SWIG_fail;
45483 swig_obj[0] = args;
45484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45485 if (!SWIG_IsOK(res1)) {
45486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45487 }
45488 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45489 {
45490 PyThreadState* __tstate = wxPyBeginAllowThreads();
45491 (arg1)->Detach();
45492 wxPyEndAllowThreads(__tstate);
45493 if (PyErr_Occurred()) SWIG_fail;
45494 }
45495 resultobj = SWIG_Py_Void();
45496 return resultobj;
45497 fail:
45498 return NULL;
45499 }
45500
45501
45502 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45503 PyObject *resultobj = 0;
45504 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45505 void *argp1 = 0 ;
45506 int res1 = 0 ;
45507 PyObject *swig_obj[1] ;
45508
45509 if (!args) SWIG_fail;
45510 swig_obj[0] = args;
45511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45512 if (!SWIG_IsOK(res1)) {
45513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45514 }
45515 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45516 {
45517 PyThreadState* __tstate = wxPyBeginAllowThreads();
45518 (arg1)->UpdateMenus();
45519 wxPyEndAllowThreads(__tstate);
45520 if (PyErr_Occurred()) SWIG_fail;
45521 }
45522 resultobj = SWIG_Py_Void();
45523 return resultobj;
45524 fail:
45525 return NULL;
45526 }
45527
45528
45529 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45530 PyObject *resultobj = 0;
45531 bool arg1 ;
45532 bool val1 ;
45533 int ecode1 = 0 ;
45534 PyObject * obj0 = 0 ;
45535 char * kwnames[] = {
45536 (char *) "enable", NULL
45537 };
45538
45539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45540 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45541 if (!SWIG_IsOK(ecode1)) {
45542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45543 }
45544 arg1 = static_cast< bool >(val1);
45545 {
45546 PyThreadState* __tstate = wxPyBeginAllowThreads();
45547 wxMenuBar_SetAutoWindowMenu(arg1);
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 resultobj = SWIG_Py_Void();
45552 return resultobj;
45553 fail:
45554 return NULL;
45555 }
45556
45557
45558 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45559 PyObject *resultobj = 0;
45560 bool result;
45561
45562 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45563 {
45564 PyThreadState* __tstate = wxPyBeginAllowThreads();
45565 result = (bool)wxMenuBar_GetAutoWindowMenu();
45566 wxPyEndAllowThreads(__tstate);
45567 if (PyErr_Occurred()) SWIG_fail;
45568 }
45569 {
45570 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45571 }
45572 return resultobj;
45573 fail:
45574 return NULL;
45575 }
45576
45577
45578 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45579 PyObject *obj;
45580 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45581 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45582 return SWIG_Py_Void();
45583 }
45584
45585 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45586 return SWIG_Python_InitShadowInstance(args);
45587 }
45588
45589 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45590 PyObject *resultobj = 0;
45591 wxMenu *arg1 = (wxMenu *) NULL ;
45592 int arg2 = (int) wxID_ANY ;
45593 wxString const &arg3_defvalue = wxPyEmptyString ;
45594 wxString *arg3 = (wxString *) &arg3_defvalue ;
45595 wxString const &arg4_defvalue = wxPyEmptyString ;
45596 wxString *arg4 = (wxString *) &arg4_defvalue ;
45597 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45598 wxMenu *arg6 = (wxMenu *) NULL ;
45599 wxMenuItem *result = 0 ;
45600 void *argp1 = 0 ;
45601 int res1 = 0 ;
45602 int val2 ;
45603 int ecode2 = 0 ;
45604 bool temp3 = false ;
45605 bool temp4 = false ;
45606 int val5 ;
45607 int ecode5 = 0 ;
45608 void *argp6 = 0 ;
45609 int res6 = 0 ;
45610 PyObject * obj0 = 0 ;
45611 PyObject * obj1 = 0 ;
45612 PyObject * obj2 = 0 ;
45613 PyObject * obj3 = 0 ;
45614 PyObject * obj4 = 0 ;
45615 PyObject * obj5 = 0 ;
45616 char * kwnames[] = {
45617 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45618 };
45619
45620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45621 if (obj0) {
45622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45623 if (!SWIG_IsOK(res1)) {
45624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45625 }
45626 arg1 = reinterpret_cast< wxMenu * >(argp1);
45627 }
45628 if (obj1) {
45629 ecode2 = SWIG_AsVal_int(obj1, &val2);
45630 if (!SWIG_IsOK(ecode2)) {
45631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45632 }
45633 arg2 = static_cast< int >(val2);
45634 }
45635 if (obj2) {
45636 {
45637 arg3 = wxString_in_helper(obj2);
45638 if (arg3 == NULL) SWIG_fail;
45639 temp3 = true;
45640 }
45641 }
45642 if (obj3) {
45643 {
45644 arg4 = wxString_in_helper(obj3);
45645 if (arg4 == NULL) SWIG_fail;
45646 temp4 = true;
45647 }
45648 }
45649 if (obj4) {
45650 ecode5 = SWIG_AsVal_int(obj4, &val5);
45651 if (!SWIG_IsOK(ecode5)) {
45652 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45653 }
45654 arg5 = static_cast< wxItemKind >(val5);
45655 }
45656 if (obj5) {
45657 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45658 if (!SWIG_IsOK(res6)) {
45659 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45660 }
45661 arg6 = reinterpret_cast< wxMenu * >(argp6);
45662 }
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45670 {
45671 if (temp3)
45672 delete arg3;
45673 }
45674 {
45675 if (temp4)
45676 delete arg4;
45677 }
45678 return resultobj;
45679 fail:
45680 {
45681 if (temp3)
45682 delete arg3;
45683 }
45684 {
45685 if (temp4)
45686 delete arg4;
45687 }
45688 return NULL;
45689 }
45690
45691
45692 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45693 PyObject *resultobj = 0;
45694 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45695 void *argp1 = 0 ;
45696 int res1 = 0 ;
45697 PyObject *swig_obj[1] ;
45698
45699 if (!args) SWIG_fail;
45700 swig_obj[0] = args;
45701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45702 if (!SWIG_IsOK(res1)) {
45703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45704 }
45705 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45706 {
45707 PyThreadState* __tstate = wxPyBeginAllowThreads();
45708 delete arg1;
45709
45710 wxPyEndAllowThreads(__tstate);
45711 if (PyErr_Occurred()) SWIG_fail;
45712 }
45713 resultobj = SWIG_Py_Void();
45714 return resultobj;
45715 fail:
45716 return NULL;
45717 }
45718
45719
45720 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45721 PyObject *resultobj = 0;
45722 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45723 wxMenu *result = 0 ;
45724 void *argp1 = 0 ;
45725 int res1 = 0 ;
45726 PyObject *swig_obj[1] ;
45727
45728 if (!args) SWIG_fail;
45729 swig_obj[0] = args;
45730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45731 if (!SWIG_IsOK(res1)) {
45732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45733 }
45734 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45735 {
45736 PyThreadState* __tstate = wxPyBeginAllowThreads();
45737 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45738 wxPyEndAllowThreads(__tstate);
45739 if (PyErr_Occurred()) SWIG_fail;
45740 }
45741 {
45742 resultobj = wxPyMake_wxObject(result, 0);
45743 }
45744 return resultobj;
45745 fail:
45746 return NULL;
45747 }
45748
45749
45750 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45751 PyObject *resultobj = 0;
45752 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45753 wxMenu *arg2 = (wxMenu *) 0 ;
45754 void *argp1 = 0 ;
45755 int res1 = 0 ;
45756 void *argp2 = 0 ;
45757 int res2 = 0 ;
45758 PyObject * obj0 = 0 ;
45759 PyObject * obj1 = 0 ;
45760 char * kwnames[] = {
45761 (char *) "self",(char *) "menu", NULL
45762 };
45763
45764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45766 if (!SWIG_IsOK(res1)) {
45767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45768 }
45769 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45770 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45771 if (!SWIG_IsOK(res2)) {
45772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45773 }
45774 arg2 = reinterpret_cast< wxMenu * >(argp2);
45775 {
45776 PyThreadState* __tstate = wxPyBeginAllowThreads();
45777 (arg1)->SetMenu(arg2);
45778 wxPyEndAllowThreads(__tstate);
45779 if (PyErr_Occurred()) SWIG_fail;
45780 }
45781 resultobj = SWIG_Py_Void();
45782 return resultobj;
45783 fail:
45784 return NULL;
45785 }
45786
45787
45788 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45789 PyObject *resultobj = 0;
45790 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45791 int arg2 ;
45792 void *argp1 = 0 ;
45793 int res1 = 0 ;
45794 int val2 ;
45795 int ecode2 = 0 ;
45796 PyObject * obj0 = 0 ;
45797 PyObject * obj1 = 0 ;
45798 char * kwnames[] = {
45799 (char *) "self",(char *) "id", NULL
45800 };
45801
45802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
45803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45804 if (!SWIG_IsOK(res1)) {
45805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45806 }
45807 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45808 ecode2 = SWIG_AsVal_int(obj1, &val2);
45809 if (!SWIG_IsOK(ecode2)) {
45810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
45811 }
45812 arg2 = static_cast< int >(val2);
45813 {
45814 PyThreadState* __tstate = wxPyBeginAllowThreads();
45815 (arg1)->SetId(arg2);
45816 wxPyEndAllowThreads(__tstate);
45817 if (PyErr_Occurred()) SWIG_fail;
45818 }
45819 resultobj = SWIG_Py_Void();
45820 return resultobj;
45821 fail:
45822 return NULL;
45823 }
45824
45825
45826 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45827 PyObject *resultobj = 0;
45828 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45829 int result;
45830 void *argp1 = 0 ;
45831 int res1 = 0 ;
45832 PyObject *swig_obj[1] ;
45833
45834 if (!args) SWIG_fail;
45835 swig_obj[0] = args;
45836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45837 if (!SWIG_IsOK(res1)) {
45838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45839 }
45840 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45841 {
45842 PyThreadState* __tstate = wxPyBeginAllowThreads();
45843 result = (int)((wxMenuItem const *)arg1)->GetId();
45844 wxPyEndAllowThreads(__tstate);
45845 if (PyErr_Occurred()) SWIG_fail;
45846 }
45847 resultobj = SWIG_From_int(static_cast< int >(result));
45848 return resultobj;
45849 fail:
45850 return NULL;
45851 }
45852
45853
45854 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45855 PyObject *resultobj = 0;
45856 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45857 bool result;
45858 void *argp1 = 0 ;
45859 int res1 = 0 ;
45860 PyObject *swig_obj[1] ;
45861
45862 if (!args) SWIG_fail;
45863 swig_obj[0] = args;
45864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45865 if (!SWIG_IsOK(res1)) {
45866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45867 }
45868 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45869 {
45870 PyThreadState* __tstate = wxPyBeginAllowThreads();
45871 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
45872 wxPyEndAllowThreads(__tstate);
45873 if (PyErr_Occurred()) SWIG_fail;
45874 }
45875 {
45876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45877 }
45878 return resultobj;
45879 fail:
45880 return NULL;
45881 }
45882
45883
45884 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45885 PyObject *resultobj = 0;
45886 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45887 wxString *arg2 = 0 ;
45888 void *argp1 = 0 ;
45889 int res1 = 0 ;
45890 bool temp2 = false ;
45891 PyObject * obj0 = 0 ;
45892 PyObject * obj1 = 0 ;
45893 char * kwnames[] = {
45894 (char *) "self",(char *) "str", NULL
45895 };
45896
45897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
45898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45899 if (!SWIG_IsOK(res1)) {
45900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45901 }
45902 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45903 {
45904 arg2 = wxString_in_helper(obj1);
45905 if (arg2 == NULL) SWIG_fail;
45906 temp2 = true;
45907 }
45908 {
45909 PyThreadState* __tstate = wxPyBeginAllowThreads();
45910 (arg1)->SetText((wxString const &)*arg2);
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 resultobj = SWIG_Py_Void();
45915 {
45916 if (temp2)
45917 delete arg2;
45918 }
45919 return resultobj;
45920 fail:
45921 {
45922 if (temp2)
45923 delete arg2;
45924 }
45925 return NULL;
45926 }
45927
45928
45929 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45930 PyObject *resultobj = 0;
45931 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45932 wxString result;
45933 void *argp1 = 0 ;
45934 int res1 = 0 ;
45935 PyObject *swig_obj[1] ;
45936
45937 if (!args) SWIG_fail;
45938 swig_obj[0] = args;
45939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45940 if (!SWIG_IsOK(res1)) {
45941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45942 }
45943 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45944 {
45945 PyThreadState* __tstate = wxPyBeginAllowThreads();
45946 result = ((wxMenuItem const *)arg1)->GetLabel();
45947 wxPyEndAllowThreads(__tstate);
45948 if (PyErr_Occurred()) SWIG_fail;
45949 }
45950 {
45951 #if wxUSE_UNICODE
45952 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45953 #else
45954 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45955 #endif
45956 }
45957 return resultobj;
45958 fail:
45959 return NULL;
45960 }
45961
45962
45963 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45964 PyObject *resultobj = 0;
45965 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45966 wxString *result = 0 ;
45967 void *argp1 = 0 ;
45968 int res1 = 0 ;
45969 PyObject *swig_obj[1] ;
45970
45971 if (!args) SWIG_fail;
45972 swig_obj[0] = args;
45973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45974 if (!SWIG_IsOK(res1)) {
45975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45976 }
45977 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45978 {
45979 PyThreadState* __tstate = wxPyBeginAllowThreads();
45980 {
45981 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
45982 result = (wxString *) &_result_ref;
45983 }
45984 wxPyEndAllowThreads(__tstate);
45985 if (PyErr_Occurred()) SWIG_fail;
45986 }
45987 {
45988 #if wxUSE_UNICODE
45989 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
45990 #else
45991 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
45992 #endif
45993 }
45994 return resultobj;
45995 fail:
45996 return NULL;
45997 }
45998
45999
46000 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46001 PyObject *resultobj = 0;
46002 wxString *arg1 = 0 ;
46003 wxString result;
46004 bool temp1 = false ;
46005 PyObject * obj0 = 0 ;
46006 char * kwnames[] = {
46007 (char *) "text", NULL
46008 };
46009
46010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46011 {
46012 arg1 = wxString_in_helper(obj0);
46013 if (arg1 == NULL) SWIG_fail;
46014 temp1 = true;
46015 }
46016 {
46017 PyThreadState* __tstate = wxPyBeginAllowThreads();
46018 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46019 wxPyEndAllowThreads(__tstate);
46020 if (PyErr_Occurred()) SWIG_fail;
46021 }
46022 {
46023 #if wxUSE_UNICODE
46024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46025 #else
46026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46027 #endif
46028 }
46029 {
46030 if (temp1)
46031 delete arg1;
46032 }
46033 return resultobj;
46034 fail:
46035 {
46036 if (temp1)
46037 delete arg1;
46038 }
46039 return NULL;
46040 }
46041
46042
46043 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46044 PyObject *resultobj = 0;
46045 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46046 wxItemKind result;
46047 void *argp1 = 0 ;
46048 int res1 = 0 ;
46049 PyObject *swig_obj[1] ;
46050
46051 if (!args) SWIG_fail;
46052 swig_obj[0] = args;
46053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46054 if (!SWIG_IsOK(res1)) {
46055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46056 }
46057 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46058 {
46059 PyThreadState* __tstate = wxPyBeginAllowThreads();
46060 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46061 wxPyEndAllowThreads(__tstate);
46062 if (PyErr_Occurred()) SWIG_fail;
46063 }
46064 resultobj = SWIG_From_int(static_cast< int >(result));
46065 return resultobj;
46066 fail:
46067 return NULL;
46068 }
46069
46070
46071 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46072 PyObject *resultobj = 0;
46073 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46074 wxItemKind arg2 ;
46075 void *argp1 = 0 ;
46076 int res1 = 0 ;
46077 int val2 ;
46078 int ecode2 = 0 ;
46079 PyObject * obj0 = 0 ;
46080 PyObject * obj1 = 0 ;
46081 char * kwnames[] = {
46082 (char *) "self",(char *) "kind", NULL
46083 };
46084
46085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46087 if (!SWIG_IsOK(res1)) {
46088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46089 }
46090 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46091 ecode2 = SWIG_AsVal_int(obj1, &val2);
46092 if (!SWIG_IsOK(ecode2)) {
46093 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46094 }
46095 arg2 = static_cast< wxItemKind >(val2);
46096 {
46097 PyThreadState* __tstate = wxPyBeginAllowThreads();
46098 (arg1)->SetKind(arg2);
46099 wxPyEndAllowThreads(__tstate);
46100 if (PyErr_Occurred()) SWIG_fail;
46101 }
46102 resultobj = SWIG_Py_Void();
46103 return resultobj;
46104 fail:
46105 return NULL;
46106 }
46107
46108
46109 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46110 PyObject *resultobj = 0;
46111 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46112 bool arg2 ;
46113 void *argp1 = 0 ;
46114 int res1 = 0 ;
46115 bool val2 ;
46116 int ecode2 = 0 ;
46117 PyObject * obj0 = 0 ;
46118 PyObject * obj1 = 0 ;
46119 char * kwnames[] = {
46120 (char *) "self",(char *) "checkable", NULL
46121 };
46122
46123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46125 if (!SWIG_IsOK(res1)) {
46126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46127 }
46128 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46129 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46130 if (!SWIG_IsOK(ecode2)) {
46131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46132 }
46133 arg2 = static_cast< bool >(val2);
46134 {
46135 PyThreadState* __tstate = wxPyBeginAllowThreads();
46136 (arg1)->SetCheckable(arg2);
46137 wxPyEndAllowThreads(__tstate);
46138 if (PyErr_Occurred()) SWIG_fail;
46139 }
46140 resultobj = SWIG_Py_Void();
46141 return resultobj;
46142 fail:
46143 return NULL;
46144 }
46145
46146
46147 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46148 PyObject *resultobj = 0;
46149 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46150 bool result;
46151 void *argp1 = 0 ;
46152 int res1 = 0 ;
46153 PyObject *swig_obj[1] ;
46154
46155 if (!args) SWIG_fail;
46156 swig_obj[0] = args;
46157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46158 if (!SWIG_IsOK(res1)) {
46159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46160 }
46161 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46162 {
46163 PyThreadState* __tstate = wxPyBeginAllowThreads();
46164 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46165 wxPyEndAllowThreads(__tstate);
46166 if (PyErr_Occurred()) SWIG_fail;
46167 }
46168 {
46169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46170 }
46171 return resultobj;
46172 fail:
46173 return NULL;
46174 }
46175
46176
46177 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46178 PyObject *resultobj = 0;
46179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46180 bool result;
46181 void *argp1 = 0 ;
46182 int res1 = 0 ;
46183 PyObject *swig_obj[1] ;
46184
46185 if (!args) SWIG_fail;
46186 swig_obj[0] = args;
46187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46188 if (!SWIG_IsOK(res1)) {
46189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46190 }
46191 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46192 {
46193 PyThreadState* __tstate = wxPyBeginAllowThreads();
46194 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46195 wxPyEndAllowThreads(__tstate);
46196 if (PyErr_Occurred()) SWIG_fail;
46197 }
46198 {
46199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46200 }
46201 return resultobj;
46202 fail:
46203 return NULL;
46204 }
46205
46206
46207 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46208 PyObject *resultobj = 0;
46209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46210 wxMenu *arg2 = (wxMenu *) 0 ;
46211 void *argp1 = 0 ;
46212 int res1 = 0 ;
46213 void *argp2 = 0 ;
46214 int res2 = 0 ;
46215 PyObject * obj0 = 0 ;
46216 PyObject * obj1 = 0 ;
46217 char * kwnames[] = {
46218 (char *) "self",(char *) "menu", NULL
46219 };
46220
46221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46223 if (!SWIG_IsOK(res1)) {
46224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46225 }
46226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46227 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46228 if (!SWIG_IsOK(res2)) {
46229 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46230 }
46231 arg2 = reinterpret_cast< wxMenu * >(argp2);
46232 {
46233 PyThreadState* __tstate = wxPyBeginAllowThreads();
46234 (arg1)->SetSubMenu(arg2);
46235 wxPyEndAllowThreads(__tstate);
46236 if (PyErr_Occurred()) SWIG_fail;
46237 }
46238 resultobj = SWIG_Py_Void();
46239 return resultobj;
46240 fail:
46241 return NULL;
46242 }
46243
46244
46245 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46246 PyObject *resultobj = 0;
46247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46248 wxMenu *result = 0 ;
46249 void *argp1 = 0 ;
46250 int res1 = 0 ;
46251 PyObject *swig_obj[1] ;
46252
46253 if (!args) SWIG_fail;
46254 swig_obj[0] = args;
46255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46256 if (!SWIG_IsOK(res1)) {
46257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46258 }
46259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46260 {
46261 PyThreadState* __tstate = wxPyBeginAllowThreads();
46262 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46263 wxPyEndAllowThreads(__tstate);
46264 if (PyErr_Occurred()) SWIG_fail;
46265 }
46266 {
46267 resultobj = wxPyMake_wxObject(result, 0);
46268 }
46269 return resultobj;
46270 fail:
46271 return NULL;
46272 }
46273
46274
46275 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46276 PyObject *resultobj = 0;
46277 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46278 bool arg2 = (bool) true ;
46279 void *argp1 = 0 ;
46280 int res1 = 0 ;
46281 bool val2 ;
46282 int ecode2 = 0 ;
46283 PyObject * obj0 = 0 ;
46284 PyObject * obj1 = 0 ;
46285 char * kwnames[] = {
46286 (char *) "self",(char *) "enable", NULL
46287 };
46288
46289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46291 if (!SWIG_IsOK(res1)) {
46292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46293 }
46294 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46295 if (obj1) {
46296 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46297 if (!SWIG_IsOK(ecode2)) {
46298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46299 }
46300 arg2 = static_cast< bool >(val2);
46301 }
46302 {
46303 PyThreadState* __tstate = wxPyBeginAllowThreads();
46304 (arg1)->Enable(arg2);
46305 wxPyEndAllowThreads(__tstate);
46306 if (PyErr_Occurred()) SWIG_fail;
46307 }
46308 resultobj = SWIG_Py_Void();
46309 return resultobj;
46310 fail:
46311 return NULL;
46312 }
46313
46314
46315 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46316 PyObject *resultobj = 0;
46317 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46318 bool result;
46319 void *argp1 = 0 ;
46320 int res1 = 0 ;
46321 PyObject *swig_obj[1] ;
46322
46323 if (!args) SWIG_fail;
46324 swig_obj[0] = args;
46325 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46326 if (!SWIG_IsOK(res1)) {
46327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46328 }
46329 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46330 {
46331 PyThreadState* __tstate = wxPyBeginAllowThreads();
46332 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46333 wxPyEndAllowThreads(__tstate);
46334 if (PyErr_Occurred()) SWIG_fail;
46335 }
46336 {
46337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46338 }
46339 return resultobj;
46340 fail:
46341 return NULL;
46342 }
46343
46344
46345 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46346 PyObject *resultobj = 0;
46347 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46348 bool arg2 = (bool) true ;
46349 void *argp1 = 0 ;
46350 int res1 = 0 ;
46351 bool val2 ;
46352 int ecode2 = 0 ;
46353 PyObject * obj0 = 0 ;
46354 PyObject * obj1 = 0 ;
46355 char * kwnames[] = {
46356 (char *) "self",(char *) "check", NULL
46357 };
46358
46359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46361 if (!SWIG_IsOK(res1)) {
46362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46363 }
46364 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46365 if (obj1) {
46366 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46367 if (!SWIG_IsOK(ecode2)) {
46368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46369 }
46370 arg2 = static_cast< bool >(val2);
46371 }
46372 {
46373 PyThreadState* __tstate = wxPyBeginAllowThreads();
46374 (arg1)->Check(arg2);
46375 wxPyEndAllowThreads(__tstate);
46376 if (PyErr_Occurred()) SWIG_fail;
46377 }
46378 resultobj = SWIG_Py_Void();
46379 return resultobj;
46380 fail:
46381 return NULL;
46382 }
46383
46384
46385 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46386 PyObject *resultobj = 0;
46387 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46388 bool result;
46389 void *argp1 = 0 ;
46390 int res1 = 0 ;
46391 PyObject *swig_obj[1] ;
46392
46393 if (!args) SWIG_fail;
46394 swig_obj[0] = args;
46395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46396 if (!SWIG_IsOK(res1)) {
46397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46398 }
46399 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46400 {
46401 PyThreadState* __tstate = wxPyBeginAllowThreads();
46402 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46403 wxPyEndAllowThreads(__tstate);
46404 if (PyErr_Occurred()) SWIG_fail;
46405 }
46406 {
46407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46408 }
46409 return resultobj;
46410 fail:
46411 return NULL;
46412 }
46413
46414
46415 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46416 PyObject *resultobj = 0;
46417 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46418 void *argp1 = 0 ;
46419 int res1 = 0 ;
46420 PyObject *swig_obj[1] ;
46421
46422 if (!args) SWIG_fail;
46423 swig_obj[0] = args;
46424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46425 if (!SWIG_IsOK(res1)) {
46426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46427 }
46428 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46429 {
46430 PyThreadState* __tstate = wxPyBeginAllowThreads();
46431 (arg1)->Toggle();
46432 wxPyEndAllowThreads(__tstate);
46433 if (PyErr_Occurred()) SWIG_fail;
46434 }
46435 resultobj = SWIG_Py_Void();
46436 return resultobj;
46437 fail:
46438 return NULL;
46439 }
46440
46441
46442 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46443 PyObject *resultobj = 0;
46444 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46445 wxString *arg2 = 0 ;
46446 void *argp1 = 0 ;
46447 int res1 = 0 ;
46448 bool temp2 = false ;
46449 PyObject * obj0 = 0 ;
46450 PyObject * obj1 = 0 ;
46451 char * kwnames[] = {
46452 (char *) "self",(char *) "str", NULL
46453 };
46454
46455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46457 if (!SWIG_IsOK(res1)) {
46458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46459 }
46460 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46461 {
46462 arg2 = wxString_in_helper(obj1);
46463 if (arg2 == NULL) SWIG_fail;
46464 temp2 = true;
46465 }
46466 {
46467 PyThreadState* __tstate = wxPyBeginAllowThreads();
46468 (arg1)->SetHelp((wxString const &)*arg2);
46469 wxPyEndAllowThreads(__tstate);
46470 if (PyErr_Occurred()) SWIG_fail;
46471 }
46472 resultobj = SWIG_Py_Void();
46473 {
46474 if (temp2)
46475 delete arg2;
46476 }
46477 return resultobj;
46478 fail:
46479 {
46480 if (temp2)
46481 delete arg2;
46482 }
46483 return NULL;
46484 }
46485
46486
46487 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46488 PyObject *resultobj = 0;
46489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46490 wxString *result = 0 ;
46491 void *argp1 = 0 ;
46492 int res1 = 0 ;
46493 PyObject *swig_obj[1] ;
46494
46495 if (!args) SWIG_fail;
46496 swig_obj[0] = args;
46497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46498 if (!SWIG_IsOK(res1)) {
46499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46500 }
46501 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46502 {
46503 PyThreadState* __tstate = wxPyBeginAllowThreads();
46504 {
46505 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46506 result = (wxString *) &_result_ref;
46507 }
46508 wxPyEndAllowThreads(__tstate);
46509 if (PyErr_Occurred()) SWIG_fail;
46510 }
46511 {
46512 #if wxUSE_UNICODE
46513 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46514 #else
46515 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46516 #endif
46517 }
46518 return resultobj;
46519 fail:
46520 return NULL;
46521 }
46522
46523
46524 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46525 PyObject *resultobj = 0;
46526 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46527 wxAcceleratorEntry *result = 0 ;
46528 void *argp1 = 0 ;
46529 int res1 = 0 ;
46530 PyObject *swig_obj[1] ;
46531
46532 if (!args) SWIG_fail;
46533 swig_obj[0] = args;
46534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46535 if (!SWIG_IsOK(res1)) {
46536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46537 }
46538 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46539 {
46540 PyThreadState* __tstate = wxPyBeginAllowThreads();
46541 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46542 wxPyEndAllowThreads(__tstate);
46543 if (PyErr_Occurred()) SWIG_fail;
46544 }
46545 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46546 return resultobj;
46547 fail:
46548 return NULL;
46549 }
46550
46551
46552 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46553 PyObject *resultobj = 0;
46554 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46555 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46556 void *argp1 = 0 ;
46557 int res1 = 0 ;
46558 void *argp2 = 0 ;
46559 int res2 = 0 ;
46560 PyObject * obj0 = 0 ;
46561 PyObject * obj1 = 0 ;
46562 char * kwnames[] = {
46563 (char *) "self",(char *) "accel", NULL
46564 };
46565
46566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46568 if (!SWIG_IsOK(res1)) {
46569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46570 }
46571 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46573 if (!SWIG_IsOK(res2)) {
46574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46575 }
46576 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46577 {
46578 PyThreadState* __tstate = wxPyBeginAllowThreads();
46579 (arg1)->SetAccel(arg2);
46580 wxPyEndAllowThreads(__tstate);
46581 if (PyErr_Occurred()) SWIG_fail;
46582 }
46583 resultobj = SWIG_Py_Void();
46584 return resultobj;
46585 fail:
46586 return NULL;
46587 }
46588
46589
46590 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46591 PyObject *resultobj = 0;
46592 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46593 wxBitmap *arg2 = 0 ;
46594 void *argp1 = 0 ;
46595 int res1 = 0 ;
46596 void *argp2 = 0 ;
46597 int res2 = 0 ;
46598 PyObject * obj0 = 0 ;
46599 PyObject * obj1 = 0 ;
46600 char * kwnames[] = {
46601 (char *) "self",(char *) "bitmap", NULL
46602 };
46603
46604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46606 if (!SWIG_IsOK(res1)) {
46607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46608 }
46609 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46610 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46611 if (!SWIG_IsOK(res2)) {
46612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46613 }
46614 if (!argp2) {
46615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46616 }
46617 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46618 {
46619 PyThreadState* __tstate = wxPyBeginAllowThreads();
46620 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46621 wxPyEndAllowThreads(__tstate);
46622 if (PyErr_Occurred()) SWIG_fail;
46623 }
46624 resultobj = SWIG_Py_Void();
46625 return resultobj;
46626 fail:
46627 return NULL;
46628 }
46629
46630
46631 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46632 PyObject *resultobj = 0;
46633 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46634 wxBitmap *result = 0 ;
46635 void *argp1 = 0 ;
46636 int res1 = 0 ;
46637 PyObject *swig_obj[1] ;
46638
46639 if (!args) SWIG_fail;
46640 swig_obj[0] = args;
46641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46642 if (!SWIG_IsOK(res1)) {
46643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46644 }
46645 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46646 {
46647 PyThreadState* __tstate = wxPyBeginAllowThreads();
46648 {
46649 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46650 result = (wxBitmap *) &_result_ref;
46651 }
46652 wxPyEndAllowThreads(__tstate);
46653 if (PyErr_Occurred()) SWIG_fail;
46654 }
46655 {
46656 wxBitmap* resultptr = new wxBitmap(*result);
46657 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46658 }
46659 return resultobj;
46660 fail:
46661 return NULL;
46662 }
46663
46664
46665 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46666 PyObject *resultobj = 0;
46667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46668 wxFont *arg2 = 0 ;
46669 void *argp1 = 0 ;
46670 int res1 = 0 ;
46671 void *argp2 = 0 ;
46672 int res2 = 0 ;
46673 PyObject * obj0 = 0 ;
46674 PyObject * obj1 = 0 ;
46675 char * kwnames[] = {
46676 (char *) "self",(char *) "font", NULL
46677 };
46678
46679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46681 if (!SWIG_IsOK(res1)) {
46682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46683 }
46684 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46685 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46686 if (!SWIG_IsOK(res2)) {
46687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46688 }
46689 if (!argp2) {
46690 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46691 }
46692 arg2 = reinterpret_cast< wxFont * >(argp2);
46693 {
46694 PyThreadState* __tstate = wxPyBeginAllowThreads();
46695 (arg1)->SetFont((wxFont const &)*arg2);
46696 wxPyEndAllowThreads(__tstate);
46697 if (PyErr_Occurred()) SWIG_fail;
46698 }
46699 resultobj = SWIG_Py_Void();
46700 return resultobj;
46701 fail:
46702 return NULL;
46703 }
46704
46705
46706 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46707 PyObject *resultobj = 0;
46708 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46709 wxFont result;
46710 void *argp1 = 0 ;
46711 int res1 = 0 ;
46712 PyObject *swig_obj[1] ;
46713
46714 if (!args) SWIG_fail;
46715 swig_obj[0] = args;
46716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46717 if (!SWIG_IsOK(res1)) {
46718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46719 }
46720 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46721 {
46722 PyThreadState* __tstate = wxPyBeginAllowThreads();
46723 result = (arg1)->GetFont();
46724 wxPyEndAllowThreads(__tstate);
46725 if (PyErr_Occurred()) SWIG_fail;
46726 }
46727 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46728 return resultobj;
46729 fail:
46730 return NULL;
46731 }
46732
46733
46734 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46735 PyObject *resultobj = 0;
46736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46737 wxColour *arg2 = 0 ;
46738 void *argp1 = 0 ;
46739 int res1 = 0 ;
46740 wxColour temp2 ;
46741 PyObject * obj0 = 0 ;
46742 PyObject * obj1 = 0 ;
46743 char * kwnames[] = {
46744 (char *) "self",(char *) "colText", NULL
46745 };
46746
46747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46749 if (!SWIG_IsOK(res1)) {
46750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46751 }
46752 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46753 {
46754 arg2 = &temp2;
46755 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46756 }
46757 {
46758 PyThreadState* __tstate = wxPyBeginAllowThreads();
46759 (arg1)->SetTextColour((wxColour const &)*arg2);
46760 wxPyEndAllowThreads(__tstate);
46761 if (PyErr_Occurred()) SWIG_fail;
46762 }
46763 resultobj = SWIG_Py_Void();
46764 return resultobj;
46765 fail:
46766 return NULL;
46767 }
46768
46769
46770 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46771 PyObject *resultobj = 0;
46772 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46773 wxColour result;
46774 void *argp1 = 0 ;
46775 int res1 = 0 ;
46776 PyObject *swig_obj[1] ;
46777
46778 if (!args) SWIG_fail;
46779 swig_obj[0] = args;
46780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46781 if (!SWIG_IsOK(res1)) {
46782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46783 }
46784 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46785 {
46786 PyThreadState* __tstate = wxPyBeginAllowThreads();
46787 result = (arg1)->GetTextColour();
46788 wxPyEndAllowThreads(__tstate);
46789 if (PyErr_Occurred()) SWIG_fail;
46790 }
46791 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46792 return resultobj;
46793 fail:
46794 return NULL;
46795 }
46796
46797
46798 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46799 PyObject *resultobj = 0;
46800 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46801 wxColour *arg2 = 0 ;
46802 void *argp1 = 0 ;
46803 int res1 = 0 ;
46804 wxColour temp2 ;
46805 PyObject * obj0 = 0 ;
46806 PyObject * obj1 = 0 ;
46807 char * kwnames[] = {
46808 (char *) "self",(char *) "colBack", NULL
46809 };
46810
46811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
46812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46813 if (!SWIG_IsOK(res1)) {
46814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46815 }
46816 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46817 {
46818 arg2 = &temp2;
46819 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46820 }
46821 {
46822 PyThreadState* __tstate = wxPyBeginAllowThreads();
46823 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
46824 wxPyEndAllowThreads(__tstate);
46825 if (PyErr_Occurred()) SWIG_fail;
46826 }
46827 resultobj = SWIG_Py_Void();
46828 return resultobj;
46829 fail:
46830 return NULL;
46831 }
46832
46833
46834 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46835 PyObject *resultobj = 0;
46836 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46837 wxColour result;
46838 void *argp1 = 0 ;
46839 int res1 = 0 ;
46840 PyObject *swig_obj[1] ;
46841
46842 if (!args) SWIG_fail;
46843 swig_obj[0] = args;
46844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46845 if (!SWIG_IsOK(res1)) {
46846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46847 }
46848 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46849 {
46850 PyThreadState* __tstate = wxPyBeginAllowThreads();
46851 result = (arg1)->GetBackgroundColour();
46852 wxPyEndAllowThreads(__tstate);
46853 if (PyErr_Occurred()) SWIG_fail;
46854 }
46855 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46856 return resultobj;
46857 fail:
46858 return NULL;
46859 }
46860
46861
46862 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46863 PyObject *resultobj = 0;
46864 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46865 wxBitmap *arg2 = 0 ;
46866 wxBitmap const &arg3_defvalue = wxNullBitmap ;
46867 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
46868 void *argp1 = 0 ;
46869 int res1 = 0 ;
46870 void *argp2 = 0 ;
46871 int res2 = 0 ;
46872 void *argp3 = 0 ;
46873 int res3 = 0 ;
46874 PyObject * obj0 = 0 ;
46875 PyObject * obj1 = 0 ;
46876 PyObject * obj2 = 0 ;
46877 char * kwnames[] = {
46878 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
46879 };
46880
46881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46883 if (!SWIG_IsOK(res1)) {
46884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46885 }
46886 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46887 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46888 if (!SWIG_IsOK(res2)) {
46889 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46890 }
46891 if (!argp2) {
46892 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46893 }
46894 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46895 if (obj2) {
46896 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
46897 if (!SWIG_IsOK(res3)) {
46898 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46899 }
46900 if (!argp3) {
46901 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
46902 }
46903 arg3 = reinterpret_cast< wxBitmap * >(argp3);
46904 }
46905 {
46906 PyThreadState* __tstate = wxPyBeginAllowThreads();
46907 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
46908 wxPyEndAllowThreads(__tstate);
46909 if (PyErr_Occurred()) SWIG_fail;
46910 }
46911 resultobj = SWIG_Py_Void();
46912 return resultobj;
46913 fail:
46914 return NULL;
46915 }
46916
46917
46918 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46919 PyObject *resultobj = 0;
46920 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46921 wxBitmap *arg2 = 0 ;
46922 void *argp1 = 0 ;
46923 int res1 = 0 ;
46924 void *argp2 = 0 ;
46925 int res2 = 0 ;
46926 PyObject * obj0 = 0 ;
46927 PyObject * obj1 = 0 ;
46928 char * kwnames[] = {
46929 (char *) "self",(char *) "bmpDisabled", NULL
46930 };
46931
46932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46934 if (!SWIG_IsOK(res1)) {
46935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46936 }
46937 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46938 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46939 if (!SWIG_IsOK(res2)) {
46940 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46941 }
46942 if (!argp2) {
46943 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46944 }
46945 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46946 {
46947 PyThreadState* __tstate = wxPyBeginAllowThreads();
46948 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
46949 wxPyEndAllowThreads(__tstate);
46950 if (PyErr_Occurred()) SWIG_fail;
46951 }
46952 resultobj = SWIG_Py_Void();
46953 return resultobj;
46954 fail:
46955 return NULL;
46956 }
46957
46958
46959 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46960 PyObject *resultobj = 0;
46961 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46962 wxBitmap *result = 0 ;
46963 void *argp1 = 0 ;
46964 int res1 = 0 ;
46965 PyObject *swig_obj[1] ;
46966
46967 if (!args) SWIG_fail;
46968 swig_obj[0] = args;
46969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46970 if (!SWIG_IsOK(res1)) {
46971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46972 }
46973 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46974 {
46975 PyThreadState* __tstate = wxPyBeginAllowThreads();
46976 {
46977 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
46978 result = (wxBitmap *) &_result_ref;
46979 }
46980 wxPyEndAllowThreads(__tstate);
46981 if (PyErr_Occurred()) SWIG_fail;
46982 }
46983 {
46984 wxBitmap* resultptr = new wxBitmap(*result);
46985 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46986 }
46987 return resultobj;
46988 fail:
46989 return NULL;
46990 }
46991
46992
46993 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46994 PyObject *resultobj = 0;
46995 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46996 int arg2 ;
46997 void *argp1 = 0 ;
46998 int res1 = 0 ;
46999 int val2 ;
47000 int ecode2 = 0 ;
47001 PyObject * obj0 = 0 ;
47002 PyObject * obj1 = 0 ;
47003 char * kwnames[] = {
47004 (char *) "self",(char *) "nWidth", NULL
47005 };
47006
47007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47009 if (!SWIG_IsOK(res1)) {
47010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47011 }
47012 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47013 ecode2 = SWIG_AsVal_int(obj1, &val2);
47014 if (!SWIG_IsOK(ecode2)) {
47015 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47016 }
47017 arg2 = static_cast< int >(val2);
47018 {
47019 PyThreadState* __tstate = wxPyBeginAllowThreads();
47020 (arg1)->SetMarginWidth(arg2);
47021 wxPyEndAllowThreads(__tstate);
47022 if (PyErr_Occurred()) SWIG_fail;
47023 }
47024 resultobj = SWIG_Py_Void();
47025 return resultobj;
47026 fail:
47027 return NULL;
47028 }
47029
47030
47031 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47032 PyObject *resultobj = 0;
47033 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47034 int result;
47035 void *argp1 = 0 ;
47036 int res1 = 0 ;
47037 PyObject *swig_obj[1] ;
47038
47039 if (!args) SWIG_fail;
47040 swig_obj[0] = args;
47041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47042 if (!SWIG_IsOK(res1)) {
47043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47044 }
47045 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47046 {
47047 PyThreadState* __tstate = wxPyBeginAllowThreads();
47048 result = (int)(arg1)->GetMarginWidth();
47049 wxPyEndAllowThreads(__tstate);
47050 if (PyErr_Occurred()) SWIG_fail;
47051 }
47052 resultobj = SWIG_From_int(static_cast< int >(result));
47053 return resultobj;
47054 fail:
47055 return NULL;
47056 }
47057
47058
47059 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47060 PyObject *resultobj = 0;
47061 int result;
47062
47063 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47064 {
47065 PyThreadState* __tstate = wxPyBeginAllowThreads();
47066 result = (int)wxMenuItem::GetDefaultMarginWidth();
47067 wxPyEndAllowThreads(__tstate);
47068 if (PyErr_Occurred()) SWIG_fail;
47069 }
47070 resultobj = SWIG_From_int(static_cast< int >(result));
47071 return resultobj;
47072 fail:
47073 return NULL;
47074 }
47075
47076
47077 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47078 PyObject *resultobj = 0;
47079 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47080 bool result;
47081 void *argp1 = 0 ;
47082 int res1 = 0 ;
47083 PyObject *swig_obj[1] ;
47084
47085 if (!args) SWIG_fail;
47086 swig_obj[0] = args;
47087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47088 if (!SWIG_IsOK(res1)) {
47089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47090 }
47091 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47092 {
47093 PyThreadState* __tstate = wxPyBeginAllowThreads();
47094 result = (bool)(arg1)->IsOwnerDrawn();
47095 wxPyEndAllowThreads(__tstate);
47096 if (PyErr_Occurred()) SWIG_fail;
47097 }
47098 {
47099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47100 }
47101 return resultobj;
47102 fail:
47103 return NULL;
47104 }
47105
47106
47107 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47108 PyObject *resultobj = 0;
47109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47110 bool arg2 = (bool) true ;
47111 void *argp1 = 0 ;
47112 int res1 = 0 ;
47113 bool val2 ;
47114 int ecode2 = 0 ;
47115 PyObject * obj0 = 0 ;
47116 PyObject * obj1 = 0 ;
47117 char * kwnames[] = {
47118 (char *) "self",(char *) "ownerDrawn", NULL
47119 };
47120
47121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47123 if (!SWIG_IsOK(res1)) {
47124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47125 }
47126 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47127 if (obj1) {
47128 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47129 if (!SWIG_IsOK(ecode2)) {
47130 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47131 }
47132 arg2 = static_cast< bool >(val2);
47133 }
47134 {
47135 PyThreadState* __tstate = wxPyBeginAllowThreads();
47136 (arg1)->SetOwnerDrawn(arg2);
47137 wxPyEndAllowThreads(__tstate);
47138 if (PyErr_Occurred()) SWIG_fail;
47139 }
47140 resultobj = SWIG_Py_Void();
47141 return resultobj;
47142 fail:
47143 return NULL;
47144 }
47145
47146
47147 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47148 PyObject *resultobj = 0;
47149 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47150 void *argp1 = 0 ;
47151 int res1 = 0 ;
47152 PyObject *swig_obj[1] ;
47153
47154 if (!args) SWIG_fail;
47155 swig_obj[0] = args;
47156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47157 if (!SWIG_IsOK(res1)) {
47158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47159 }
47160 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47161 {
47162 PyThreadState* __tstate = wxPyBeginAllowThreads();
47163 (arg1)->ResetOwnerDrawn();
47164 wxPyEndAllowThreads(__tstate);
47165 if (PyErr_Occurred()) SWIG_fail;
47166 }
47167 resultobj = SWIG_Py_Void();
47168 return resultobj;
47169 fail:
47170 return NULL;
47171 }
47172
47173
47174 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47175 PyObject *obj;
47176 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47177 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47178 return SWIG_Py_Void();
47179 }
47180
47181 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47182 return SWIG_Python_InitShadowInstance(args);
47183 }
47184
47185 SWIGINTERN int ControlNameStr_set(PyObject *) {
47186 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47187 return 1;
47188 }
47189
47190
47191 SWIGINTERN PyObject *ControlNameStr_get(void) {
47192 PyObject *pyobj = 0;
47193
47194 {
47195 #if wxUSE_UNICODE
47196 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47197 #else
47198 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47199 #endif
47200 }
47201 return pyobj;
47202 }
47203
47204
47205 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47206 PyObject *resultobj = 0;
47207 wxWindow *arg1 = (wxWindow *) 0 ;
47208 int arg2 = (int) -1 ;
47209 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47210 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47211 wxSize const &arg4_defvalue = wxDefaultSize ;
47212 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47213 long arg5 = (long) 0 ;
47214 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47215 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47216 wxString const &arg7_defvalue = wxPyControlNameStr ;
47217 wxString *arg7 = (wxString *) &arg7_defvalue ;
47218 wxControl *result = 0 ;
47219 void *argp1 = 0 ;
47220 int res1 = 0 ;
47221 int val2 ;
47222 int ecode2 = 0 ;
47223 wxPoint temp3 ;
47224 wxSize temp4 ;
47225 long val5 ;
47226 int ecode5 = 0 ;
47227 void *argp6 = 0 ;
47228 int res6 = 0 ;
47229 bool temp7 = false ;
47230 PyObject * obj0 = 0 ;
47231 PyObject * obj1 = 0 ;
47232 PyObject * obj2 = 0 ;
47233 PyObject * obj3 = 0 ;
47234 PyObject * obj4 = 0 ;
47235 PyObject * obj5 = 0 ;
47236 PyObject * obj6 = 0 ;
47237 char * kwnames[] = {
47238 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47239 };
47240
47241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47243 if (!SWIG_IsOK(res1)) {
47244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47245 }
47246 arg1 = reinterpret_cast< wxWindow * >(argp1);
47247 if (obj1) {
47248 ecode2 = SWIG_AsVal_int(obj1, &val2);
47249 if (!SWIG_IsOK(ecode2)) {
47250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47251 }
47252 arg2 = static_cast< int >(val2);
47253 }
47254 if (obj2) {
47255 {
47256 arg3 = &temp3;
47257 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47258 }
47259 }
47260 if (obj3) {
47261 {
47262 arg4 = &temp4;
47263 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47264 }
47265 }
47266 if (obj4) {
47267 ecode5 = SWIG_AsVal_long(obj4, &val5);
47268 if (!SWIG_IsOK(ecode5)) {
47269 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47270 }
47271 arg5 = static_cast< long >(val5);
47272 }
47273 if (obj5) {
47274 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47275 if (!SWIG_IsOK(res6)) {
47276 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47277 }
47278 if (!argp6) {
47279 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47280 }
47281 arg6 = reinterpret_cast< wxValidator * >(argp6);
47282 }
47283 if (obj6) {
47284 {
47285 arg7 = wxString_in_helper(obj6);
47286 if (arg7 == NULL) SWIG_fail;
47287 temp7 = true;
47288 }
47289 }
47290 {
47291 if (!wxPyCheckForApp()) SWIG_fail;
47292 PyThreadState* __tstate = wxPyBeginAllowThreads();
47293 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47294 wxPyEndAllowThreads(__tstate);
47295 if (PyErr_Occurred()) SWIG_fail;
47296 }
47297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47298 {
47299 if (temp7)
47300 delete arg7;
47301 }
47302 return resultobj;
47303 fail:
47304 {
47305 if (temp7)
47306 delete arg7;
47307 }
47308 return NULL;
47309 }
47310
47311
47312 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47313 PyObject *resultobj = 0;
47314 wxControl *result = 0 ;
47315
47316 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47317 {
47318 if (!wxPyCheckForApp()) SWIG_fail;
47319 PyThreadState* __tstate = wxPyBeginAllowThreads();
47320 result = (wxControl *)new wxControl();
47321 wxPyEndAllowThreads(__tstate);
47322 if (PyErr_Occurred()) SWIG_fail;
47323 }
47324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47325 return resultobj;
47326 fail:
47327 return NULL;
47328 }
47329
47330
47331 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47332 PyObject *resultobj = 0;
47333 wxControl *arg1 = (wxControl *) 0 ;
47334 wxWindow *arg2 = (wxWindow *) 0 ;
47335 int arg3 = (int) -1 ;
47336 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47337 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47338 wxSize const &arg5_defvalue = wxDefaultSize ;
47339 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47340 long arg6 = (long) 0 ;
47341 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47342 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47343 wxString const &arg8_defvalue = wxPyControlNameStr ;
47344 wxString *arg8 = (wxString *) &arg8_defvalue ;
47345 bool result;
47346 void *argp1 = 0 ;
47347 int res1 = 0 ;
47348 void *argp2 = 0 ;
47349 int res2 = 0 ;
47350 int val3 ;
47351 int ecode3 = 0 ;
47352 wxPoint temp4 ;
47353 wxSize temp5 ;
47354 long val6 ;
47355 int ecode6 = 0 ;
47356 void *argp7 = 0 ;
47357 int res7 = 0 ;
47358 bool temp8 = false ;
47359 PyObject * obj0 = 0 ;
47360 PyObject * obj1 = 0 ;
47361 PyObject * obj2 = 0 ;
47362 PyObject * obj3 = 0 ;
47363 PyObject * obj4 = 0 ;
47364 PyObject * obj5 = 0 ;
47365 PyObject * obj6 = 0 ;
47366 PyObject * obj7 = 0 ;
47367 char * kwnames[] = {
47368 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47369 };
47370
47371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47373 if (!SWIG_IsOK(res1)) {
47374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47375 }
47376 arg1 = reinterpret_cast< wxControl * >(argp1);
47377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47378 if (!SWIG_IsOK(res2)) {
47379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47380 }
47381 arg2 = reinterpret_cast< wxWindow * >(argp2);
47382 if (obj2) {
47383 ecode3 = SWIG_AsVal_int(obj2, &val3);
47384 if (!SWIG_IsOK(ecode3)) {
47385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47386 }
47387 arg3 = static_cast< int >(val3);
47388 }
47389 if (obj3) {
47390 {
47391 arg4 = &temp4;
47392 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47393 }
47394 }
47395 if (obj4) {
47396 {
47397 arg5 = &temp5;
47398 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47399 }
47400 }
47401 if (obj5) {
47402 ecode6 = SWIG_AsVal_long(obj5, &val6);
47403 if (!SWIG_IsOK(ecode6)) {
47404 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47405 }
47406 arg6 = static_cast< long >(val6);
47407 }
47408 if (obj6) {
47409 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47410 if (!SWIG_IsOK(res7)) {
47411 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47412 }
47413 if (!argp7) {
47414 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47415 }
47416 arg7 = reinterpret_cast< wxValidator * >(argp7);
47417 }
47418 if (obj7) {
47419 {
47420 arg8 = wxString_in_helper(obj7);
47421 if (arg8 == NULL) SWIG_fail;
47422 temp8 = true;
47423 }
47424 }
47425 {
47426 PyThreadState* __tstate = wxPyBeginAllowThreads();
47427 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47428 wxPyEndAllowThreads(__tstate);
47429 if (PyErr_Occurred()) SWIG_fail;
47430 }
47431 {
47432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47433 }
47434 {
47435 if (temp8)
47436 delete arg8;
47437 }
47438 return resultobj;
47439 fail:
47440 {
47441 if (temp8)
47442 delete arg8;
47443 }
47444 return NULL;
47445 }
47446
47447
47448 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47449 PyObject *resultobj = 0;
47450 wxControl *arg1 = (wxControl *) 0 ;
47451 int result;
47452 void *argp1 = 0 ;
47453 int res1 = 0 ;
47454 PyObject *swig_obj[1] ;
47455
47456 if (!args) SWIG_fail;
47457 swig_obj[0] = args;
47458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47459 if (!SWIG_IsOK(res1)) {
47460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47461 }
47462 arg1 = reinterpret_cast< wxControl * >(argp1);
47463 {
47464 PyThreadState* __tstate = wxPyBeginAllowThreads();
47465 result = (int)((wxControl const *)arg1)->GetAlignment();
47466 wxPyEndAllowThreads(__tstate);
47467 if (PyErr_Occurred()) SWIG_fail;
47468 }
47469 resultobj = SWIG_From_int(static_cast< int >(result));
47470 return resultobj;
47471 fail:
47472 return NULL;
47473 }
47474
47475
47476 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47477 PyObject *resultobj = 0;
47478 wxControl *arg1 = (wxControl *) 0 ;
47479 wxString result;
47480 void *argp1 = 0 ;
47481 int res1 = 0 ;
47482 PyObject *swig_obj[1] ;
47483
47484 if (!args) SWIG_fail;
47485 swig_obj[0] = args;
47486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47487 if (!SWIG_IsOK(res1)) {
47488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47489 }
47490 arg1 = reinterpret_cast< wxControl * >(argp1);
47491 {
47492 PyThreadState* __tstate = wxPyBeginAllowThreads();
47493 result = ((wxControl const *)arg1)->GetLabelText();
47494 wxPyEndAllowThreads(__tstate);
47495 if (PyErr_Occurred()) SWIG_fail;
47496 }
47497 {
47498 #if wxUSE_UNICODE
47499 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47500 #else
47501 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47502 #endif
47503 }
47504 return resultobj;
47505 fail:
47506 return NULL;
47507 }
47508
47509
47510 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47511 PyObject *resultobj = 0;
47512 wxControl *arg1 = (wxControl *) 0 ;
47513 wxCommandEvent *arg2 = 0 ;
47514 void *argp1 = 0 ;
47515 int res1 = 0 ;
47516 void *argp2 = 0 ;
47517 int res2 = 0 ;
47518 PyObject * obj0 = 0 ;
47519 PyObject * obj1 = 0 ;
47520 char * kwnames[] = {
47521 (char *) "self",(char *) "event", NULL
47522 };
47523
47524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47526 if (!SWIG_IsOK(res1)) {
47527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47528 }
47529 arg1 = reinterpret_cast< wxControl * >(argp1);
47530 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47531 if (!SWIG_IsOK(res2)) {
47532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47533 }
47534 if (!argp2) {
47535 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47536 }
47537 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47538 {
47539 PyThreadState* __tstate = wxPyBeginAllowThreads();
47540 (arg1)->Command(*arg2);
47541 wxPyEndAllowThreads(__tstate);
47542 if (PyErr_Occurred()) SWIG_fail;
47543 }
47544 resultobj = SWIG_Py_Void();
47545 return resultobj;
47546 fail:
47547 return NULL;
47548 }
47549
47550
47551 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47552 PyObject *resultobj = 0;
47553 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47554 SwigValueWrapper<wxVisualAttributes > result;
47555 int val1 ;
47556 int ecode1 = 0 ;
47557 PyObject * obj0 = 0 ;
47558 char * kwnames[] = {
47559 (char *) "variant", NULL
47560 };
47561
47562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47563 if (obj0) {
47564 ecode1 = SWIG_AsVal_int(obj0, &val1);
47565 if (!SWIG_IsOK(ecode1)) {
47566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47567 }
47568 arg1 = static_cast< wxWindowVariant >(val1);
47569 }
47570 {
47571 if (!wxPyCheckForApp()) SWIG_fail;
47572 PyThreadState* __tstate = wxPyBeginAllowThreads();
47573 result = wxControl::GetClassDefaultAttributes(arg1);
47574 wxPyEndAllowThreads(__tstate);
47575 if (PyErr_Occurred()) SWIG_fail;
47576 }
47577 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47578 return resultobj;
47579 fail:
47580 return NULL;
47581 }
47582
47583
47584 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47585 PyObject *obj;
47586 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47587 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47588 return SWIG_Py_Void();
47589 }
47590
47591 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47592 return SWIG_Python_InitShadowInstance(args);
47593 }
47594
47595 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47596 PyObject *resultobj = 0;
47597 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47598 wxString *arg2 = 0 ;
47599 PyObject *arg3 = (PyObject *) NULL ;
47600 int result;
47601 void *argp1 = 0 ;
47602 int res1 = 0 ;
47603 bool temp2 = false ;
47604 PyObject * obj0 = 0 ;
47605 PyObject * obj1 = 0 ;
47606 PyObject * obj2 = 0 ;
47607 char * kwnames[] = {
47608 (char *) "self",(char *) "item",(char *) "clientData", NULL
47609 };
47610
47611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47613 if (!SWIG_IsOK(res1)) {
47614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47615 }
47616 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47617 {
47618 arg2 = wxString_in_helper(obj1);
47619 if (arg2 == NULL) SWIG_fail;
47620 temp2 = true;
47621 }
47622 if (obj2) {
47623 arg3 = obj2;
47624 }
47625 {
47626 PyThreadState* __tstate = wxPyBeginAllowThreads();
47627 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47628 wxPyEndAllowThreads(__tstate);
47629 if (PyErr_Occurred()) SWIG_fail;
47630 }
47631 resultobj = SWIG_From_int(static_cast< int >(result));
47632 {
47633 if (temp2)
47634 delete arg2;
47635 }
47636 return resultobj;
47637 fail:
47638 {
47639 if (temp2)
47640 delete arg2;
47641 }
47642 return NULL;
47643 }
47644
47645
47646 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47647 PyObject *resultobj = 0;
47648 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47649 wxArrayString *arg2 = 0 ;
47650 void *argp1 = 0 ;
47651 int res1 = 0 ;
47652 bool temp2 = false ;
47653 PyObject * obj0 = 0 ;
47654 PyObject * obj1 = 0 ;
47655 char * kwnames[] = {
47656 (char *) "self",(char *) "strings", NULL
47657 };
47658
47659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47661 if (!SWIG_IsOK(res1)) {
47662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47663 }
47664 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47665 {
47666 if (! PySequence_Check(obj1)) {
47667 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47668 SWIG_fail;
47669 }
47670 arg2 = new wxArrayString;
47671 temp2 = true;
47672 int i, len=PySequence_Length(obj1);
47673 for (i=0; i<len; i++) {
47674 PyObject* item = PySequence_GetItem(obj1, i);
47675 wxString* s = wxString_in_helper(item);
47676 if (PyErr_Occurred()) SWIG_fail;
47677 arg2->Add(*s);
47678 delete s;
47679 Py_DECREF(item);
47680 }
47681 }
47682 {
47683 PyThreadState* __tstate = wxPyBeginAllowThreads();
47684 (arg1)->Append((wxArrayString const &)*arg2);
47685 wxPyEndAllowThreads(__tstate);
47686 if (PyErr_Occurred()) SWIG_fail;
47687 }
47688 resultobj = SWIG_Py_Void();
47689 {
47690 if (temp2) delete arg2;
47691 }
47692 return resultobj;
47693 fail:
47694 {
47695 if (temp2) delete arg2;
47696 }
47697 return NULL;
47698 }
47699
47700
47701 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47702 PyObject *resultobj = 0;
47703 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47704 wxString *arg2 = 0 ;
47705 unsigned int arg3 ;
47706 PyObject *arg4 = (PyObject *) NULL ;
47707 int result;
47708 void *argp1 = 0 ;
47709 int res1 = 0 ;
47710 bool temp2 = false ;
47711 unsigned int val3 ;
47712 int ecode3 = 0 ;
47713 PyObject * obj0 = 0 ;
47714 PyObject * obj1 = 0 ;
47715 PyObject * obj2 = 0 ;
47716 PyObject * obj3 = 0 ;
47717 char * kwnames[] = {
47718 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47719 };
47720
47721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47723 if (!SWIG_IsOK(res1)) {
47724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47725 }
47726 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47727 {
47728 arg2 = wxString_in_helper(obj1);
47729 if (arg2 == NULL) SWIG_fail;
47730 temp2 = true;
47731 }
47732 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
47733 if (!SWIG_IsOK(ecode3)) {
47734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
47735 }
47736 arg3 = static_cast< unsigned int >(val3);
47737 if (obj3) {
47738 arg4 = obj3;
47739 }
47740 {
47741 PyThreadState* __tstate = wxPyBeginAllowThreads();
47742 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47743 wxPyEndAllowThreads(__tstate);
47744 if (PyErr_Occurred()) SWIG_fail;
47745 }
47746 resultobj = SWIG_From_int(static_cast< int >(result));
47747 {
47748 if (temp2)
47749 delete arg2;
47750 }
47751 return resultobj;
47752 fail:
47753 {
47754 if (temp2)
47755 delete arg2;
47756 }
47757 return NULL;
47758 }
47759
47760
47761 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47762 PyObject *resultobj = 0;
47763 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47764 void *argp1 = 0 ;
47765 int res1 = 0 ;
47766 PyObject *swig_obj[1] ;
47767
47768 if (!args) SWIG_fail;
47769 swig_obj[0] = args;
47770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47771 if (!SWIG_IsOK(res1)) {
47772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47773 }
47774 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47775 {
47776 PyThreadState* __tstate = wxPyBeginAllowThreads();
47777 (arg1)->Clear();
47778 wxPyEndAllowThreads(__tstate);
47779 if (PyErr_Occurred()) SWIG_fail;
47780 }
47781 resultobj = SWIG_Py_Void();
47782 return resultobj;
47783 fail:
47784 return NULL;
47785 }
47786
47787
47788 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47789 PyObject *resultobj = 0;
47790 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47791 unsigned int arg2 ;
47792 void *argp1 = 0 ;
47793 int res1 = 0 ;
47794 unsigned int val2 ;
47795 int ecode2 = 0 ;
47796 PyObject * obj0 = 0 ;
47797 PyObject * obj1 = 0 ;
47798 char * kwnames[] = {
47799 (char *) "self",(char *) "n", NULL
47800 };
47801
47802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
47803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47804 if (!SWIG_IsOK(res1)) {
47805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47806 }
47807 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47808 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47809 if (!SWIG_IsOK(ecode2)) {
47810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
47811 }
47812 arg2 = static_cast< unsigned int >(val2);
47813 {
47814 PyThreadState* __tstate = wxPyBeginAllowThreads();
47815 (arg1)->Delete(arg2);
47816 wxPyEndAllowThreads(__tstate);
47817 if (PyErr_Occurred()) SWIG_fail;
47818 }
47819 resultobj = SWIG_Py_Void();
47820 return resultobj;
47821 fail:
47822 return NULL;
47823 }
47824
47825
47826 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47827 PyObject *resultobj = 0;
47828 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47829 unsigned int arg2 ;
47830 PyObject *result = 0 ;
47831 void *argp1 = 0 ;
47832 int res1 = 0 ;
47833 unsigned int val2 ;
47834 int ecode2 = 0 ;
47835 PyObject * obj0 = 0 ;
47836 PyObject * obj1 = 0 ;
47837 char * kwnames[] = {
47838 (char *) "self",(char *) "n", NULL
47839 };
47840
47841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
47842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47843 if (!SWIG_IsOK(res1)) {
47844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47845 }
47846 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47847 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47848 if (!SWIG_IsOK(ecode2)) {
47849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47850 }
47851 arg2 = static_cast< unsigned int >(val2);
47852 {
47853 PyThreadState* __tstate = wxPyBeginAllowThreads();
47854 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
47855 wxPyEndAllowThreads(__tstate);
47856 if (PyErr_Occurred()) SWIG_fail;
47857 }
47858 resultobj = result;
47859 return resultobj;
47860 fail:
47861 return NULL;
47862 }
47863
47864
47865 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47866 PyObject *resultobj = 0;
47867 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47868 unsigned int arg2 ;
47869 PyObject *arg3 = (PyObject *) 0 ;
47870 void *argp1 = 0 ;
47871 int res1 = 0 ;
47872 unsigned int val2 ;
47873 int ecode2 = 0 ;
47874 PyObject * obj0 = 0 ;
47875 PyObject * obj1 = 0 ;
47876 PyObject * obj2 = 0 ;
47877 char * kwnames[] = {
47878 (char *) "self",(char *) "n",(char *) "clientData", NULL
47879 };
47880
47881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47883 if (!SWIG_IsOK(res1)) {
47884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47885 }
47886 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47887 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47888 if (!SWIG_IsOK(ecode2)) {
47889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
47890 }
47891 arg2 = static_cast< unsigned int >(val2);
47892 arg3 = obj2;
47893 {
47894 PyThreadState* __tstate = wxPyBeginAllowThreads();
47895 wxItemContainer_SetClientData(arg1,arg2,arg3);
47896 wxPyEndAllowThreads(__tstate);
47897 if (PyErr_Occurred()) SWIG_fail;
47898 }
47899 resultobj = SWIG_Py_Void();
47900 return resultobj;
47901 fail:
47902 return NULL;
47903 }
47904
47905
47906 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47907 PyObject *resultobj = 0;
47908 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47909 unsigned int result;
47910 void *argp1 = 0 ;
47911 int res1 = 0 ;
47912 PyObject *swig_obj[1] ;
47913
47914 if (!args) SWIG_fail;
47915 swig_obj[0] = args;
47916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47917 if (!SWIG_IsOK(res1)) {
47918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47919 }
47920 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47921 {
47922 PyThreadState* __tstate = wxPyBeginAllowThreads();
47923 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
47924 wxPyEndAllowThreads(__tstate);
47925 if (PyErr_Occurred()) SWIG_fail;
47926 }
47927 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
47928 return resultobj;
47929 fail:
47930 return NULL;
47931 }
47932
47933
47934 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47935 PyObject *resultobj = 0;
47936 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47937 bool result;
47938 void *argp1 = 0 ;
47939 int res1 = 0 ;
47940 PyObject *swig_obj[1] ;
47941
47942 if (!args) SWIG_fail;
47943 swig_obj[0] = args;
47944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47945 if (!SWIG_IsOK(res1)) {
47946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47947 }
47948 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47949 {
47950 PyThreadState* __tstate = wxPyBeginAllowThreads();
47951 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
47952 wxPyEndAllowThreads(__tstate);
47953 if (PyErr_Occurred()) SWIG_fail;
47954 }
47955 {
47956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47957 }
47958 return resultobj;
47959 fail:
47960 return NULL;
47961 }
47962
47963
47964 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47965 PyObject *resultobj = 0;
47966 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47967 unsigned int arg2 ;
47968 wxString result;
47969 void *argp1 = 0 ;
47970 int res1 = 0 ;
47971 unsigned int val2 ;
47972 int ecode2 = 0 ;
47973 PyObject * obj0 = 0 ;
47974 PyObject * obj1 = 0 ;
47975 char * kwnames[] = {
47976 (char *) "self",(char *) "n", NULL
47977 };
47978
47979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
47980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47981 if (!SWIG_IsOK(res1)) {
47982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
47983 }
47984 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47985 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
47986 if (!SWIG_IsOK(ecode2)) {
47987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
47988 }
47989 arg2 = static_cast< unsigned int >(val2);
47990 {
47991 PyThreadState* __tstate = wxPyBeginAllowThreads();
47992 result = ((wxItemContainer const *)arg1)->GetString(arg2);
47993 wxPyEndAllowThreads(__tstate);
47994 if (PyErr_Occurred()) SWIG_fail;
47995 }
47996 {
47997 #if wxUSE_UNICODE
47998 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47999 #else
48000 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48001 #endif
48002 }
48003 return resultobj;
48004 fail:
48005 return NULL;
48006 }
48007
48008
48009 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48010 PyObject *resultobj = 0;
48011 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48012 wxArrayString result;
48013 void *argp1 = 0 ;
48014 int res1 = 0 ;
48015 PyObject *swig_obj[1] ;
48016
48017 if (!args) SWIG_fail;
48018 swig_obj[0] = args;
48019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48020 if (!SWIG_IsOK(res1)) {
48021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48022 }
48023 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48024 {
48025 PyThreadState* __tstate = wxPyBeginAllowThreads();
48026 result = ((wxItemContainer const *)arg1)->GetStrings();
48027 wxPyEndAllowThreads(__tstate);
48028 if (PyErr_Occurred()) SWIG_fail;
48029 }
48030 {
48031 resultobj = wxArrayString2PyList_helper(result);
48032 }
48033 return resultobj;
48034 fail:
48035 return NULL;
48036 }
48037
48038
48039 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48040 PyObject *resultobj = 0;
48041 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48042 unsigned int arg2 ;
48043 wxString *arg3 = 0 ;
48044 void *argp1 = 0 ;
48045 int res1 = 0 ;
48046 unsigned int val2 ;
48047 int ecode2 = 0 ;
48048 bool temp3 = false ;
48049 PyObject * obj0 = 0 ;
48050 PyObject * obj1 = 0 ;
48051 PyObject * obj2 = 0 ;
48052 char * kwnames[] = {
48053 (char *) "self",(char *) "n",(char *) "s", NULL
48054 };
48055
48056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48058 if (!SWIG_IsOK(res1)) {
48059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48060 }
48061 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48062 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
48063 if (!SWIG_IsOK(ecode2)) {
48064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
48065 }
48066 arg2 = static_cast< unsigned int >(val2);
48067 {
48068 arg3 = wxString_in_helper(obj2);
48069 if (arg3 == NULL) SWIG_fail;
48070 temp3 = true;
48071 }
48072 {
48073 PyThreadState* __tstate = wxPyBeginAllowThreads();
48074 (arg1)->SetString(arg2,(wxString const &)*arg3);
48075 wxPyEndAllowThreads(__tstate);
48076 if (PyErr_Occurred()) SWIG_fail;
48077 }
48078 resultobj = SWIG_Py_Void();
48079 {
48080 if (temp3)
48081 delete arg3;
48082 }
48083 return resultobj;
48084 fail:
48085 {
48086 if (temp3)
48087 delete arg3;
48088 }
48089 return NULL;
48090 }
48091
48092
48093 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48094 PyObject *resultobj = 0;
48095 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48096 wxString *arg2 = 0 ;
48097 int result;
48098 void *argp1 = 0 ;
48099 int res1 = 0 ;
48100 bool temp2 = false ;
48101 PyObject * obj0 = 0 ;
48102 PyObject * obj1 = 0 ;
48103 char * kwnames[] = {
48104 (char *) "self",(char *) "s", NULL
48105 };
48106
48107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48109 if (!SWIG_IsOK(res1)) {
48110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48111 }
48112 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48113 {
48114 arg2 = wxString_in_helper(obj1);
48115 if (arg2 == NULL) SWIG_fail;
48116 temp2 = true;
48117 }
48118 {
48119 PyThreadState* __tstate = wxPyBeginAllowThreads();
48120 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48121 wxPyEndAllowThreads(__tstate);
48122 if (PyErr_Occurred()) SWIG_fail;
48123 }
48124 resultobj = SWIG_From_int(static_cast< int >(result));
48125 {
48126 if (temp2)
48127 delete arg2;
48128 }
48129 return resultobj;
48130 fail:
48131 {
48132 if (temp2)
48133 delete arg2;
48134 }
48135 return NULL;
48136 }
48137
48138
48139 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48140 PyObject *resultobj = 0;
48141 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48142 int arg2 ;
48143 void *argp1 = 0 ;
48144 int res1 = 0 ;
48145 int val2 ;
48146 int ecode2 = 0 ;
48147 PyObject * obj0 = 0 ;
48148 PyObject * obj1 = 0 ;
48149 char * kwnames[] = {
48150 (char *) "self",(char *) "n", NULL
48151 };
48152
48153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48155 if (!SWIG_IsOK(res1)) {
48156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48157 }
48158 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48159 ecode2 = SWIG_AsVal_int(obj1, &val2);
48160 if (!SWIG_IsOK(ecode2)) {
48161 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48162 }
48163 arg2 = static_cast< int >(val2);
48164 {
48165 PyThreadState* __tstate = wxPyBeginAllowThreads();
48166 (arg1)->SetSelection(arg2);
48167 wxPyEndAllowThreads(__tstate);
48168 if (PyErr_Occurred()) SWIG_fail;
48169 }
48170 resultobj = SWIG_Py_Void();
48171 return resultobj;
48172 fail:
48173 return NULL;
48174 }
48175
48176
48177 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48178 PyObject *resultobj = 0;
48179 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48180 int result;
48181 void *argp1 = 0 ;
48182 int res1 = 0 ;
48183 PyObject *swig_obj[1] ;
48184
48185 if (!args) SWIG_fail;
48186 swig_obj[0] = args;
48187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48188 if (!SWIG_IsOK(res1)) {
48189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48190 }
48191 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48192 {
48193 PyThreadState* __tstate = wxPyBeginAllowThreads();
48194 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48195 wxPyEndAllowThreads(__tstate);
48196 if (PyErr_Occurred()) SWIG_fail;
48197 }
48198 resultobj = SWIG_From_int(static_cast< int >(result));
48199 return resultobj;
48200 fail:
48201 return NULL;
48202 }
48203
48204
48205 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48206 PyObject *resultobj = 0;
48207 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48208 wxString *arg2 = 0 ;
48209 bool result;
48210 void *argp1 = 0 ;
48211 int res1 = 0 ;
48212 bool temp2 = false ;
48213 PyObject * obj0 = 0 ;
48214 PyObject * obj1 = 0 ;
48215 char * kwnames[] = {
48216 (char *) "self",(char *) "s", NULL
48217 };
48218
48219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48221 if (!SWIG_IsOK(res1)) {
48222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48223 }
48224 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48225 {
48226 arg2 = wxString_in_helper(obj1);
48227 if (arg2 == NULL) SWIG_fail;
48228 temp2 = true;
48229 }
48230 {
48231 PyThreadState* __tstate = wxPyBeginAllowThreads();
48232 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48233 wxPyEndAllowThreads(__tstate);
48234 if (PyErr_Occurred()) SWIG_fail;
48235 }
48236 {
48237 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48238 }
48239 {
48240 if (temp2)
48241 delete arg2;
48242 }
48243 return resultobj;
48244 fail:
48245 {
48246 if (temp2)
48247 delete arg2;
48248 }
48249 return NULL;
48250 }
48251
48252
48253 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48254 PyObject *resultobj = 0;
48255 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48256 wxString result;
48257 void *argp1 = 0 ;
48258 int res1 = 0 ;
48259 PyObject *swig_obj[1] ;
48260
48261 if (!args) SWIG_fail;
48262 swig_obj[0] = args;
48263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48264 if (!SWIG_IsOK(res1)) {
48265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48266 }
48267 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48268 {
48269 PyThreadState* __tstate = wxPyBeginAllowThreads();
48270 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48271 wxPyEndAllowThreads(__tstate);
48272 if (PyErr_Occurred()) SWIG_fail;
48273 }
48274 {
48275 #if wxUSE_UNICODE
48276 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48277 #else
48278 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48279 #endif
48280 }
48281 return resultobj;
48282 fail:
48283 return NULL;
48284 }
48285
48286
48287 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48288 PyObject *resultobj = 0;
48289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48290 int arg2 ;
48291 void *argp1 = 0 ;
48292 int res1 = 0 ;
48293 int val2 ;
48294 int ecode2 = 0 ;
48295 PyObject * obj0 = 0 ;
48296 PyObject * obj1 = 0 ;
48297 char * kwnames[] = {
48298 (char *) "self",(char *) "n", NULL
48299 };
48300
48301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48303 if (!SWIG_IsOK(res1)) {
48304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48305 }
48306 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48307 ecode2 = SWIG_AsVal_int(obj1, &val2);
48308 if (!SWIG_IsOK(ecode2)) {
48309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48310 }
48311 arg2 = static_cast< int >(val2);
48312 {
48313 PyThreadState* __tstate = wxPyBeginAllowThreads();
48314 (arg1)->Select(arg2);
48315 wxPyEndAllowThreads(__tstate);
48316 if (PyErr_Occurred()) SWIG_fail;
48317 }
48318 resultobj = SWIG_Py_Void();
48319 return resultobj;
48320 fail:
48321 return NULL;
48322 }
48323
48324
48325 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48326 PyObject *obj;
48327 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48328 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48329 return SWIG_Py_Void();
48330 }
48331
48332 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48333 PyObject *obj;
48334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48335 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48336 return SWIG_Py_Void();
48337 }
48338
48339 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48340 PyObject *resultobj = 0;
48341 wxSizerItem *result = 0 ;
48342
48343 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48344 {
48345 PyThreadState* __tstate = wxPyBeginAllowThreads();
48346 result = (wxSizerItem *)new wxSizerItem();
48347 wxPyEndAllowThreads(__tstate);
48348 if (PyErr_Occurred()) SWIG_fail;
48349 }
48350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48351 return resultobj;
48352 fail:
48353 return NULL;
48354 }
48355
48356
48357 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48358 PyObject *resultobj = 0;
48359 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48360 void *argp1 = 0 ;
48361 int res1 = 0 ;
48362 PyObject *swig_obj[1] ;
48363
48364 if (!args) SWIG_fail;
48365 swig_obj[0] = args;
48366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48367 if (!SWIG_IsOK(res1)) {
48368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48369 }
48370 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48371 {
48372 PyThreadState* __tstate = wxPyBeginAllowThreads();
48373 delete arg1;
48374
48375 wxPyEndAllowThreads(__tstate);
48376 if (PyErr_Occurred()) SWIG_fail;
48377 }
48378 resultobj = SWIG_Py_Void();
48379 return resultobj;
48380 fail:
48381 return NULL;
48382 }
48383
48384
48385 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48386 PyObject *resultobj = 0;
48387 wxWindow *arg1 = (wxWindow *) 0 ;
48388 int arg2 ;
48389 int arg3 ;
48390 int arg4 ;
48391 PyObject *arg5 = (PyObject *) NULL ;
48392 wxSizerItem *result = 0 ;
48393 void *argp1 = 0 ;
48394 int res1 = 0 ;
48395 int val2 ;
48396 int ecode2 = 0 ;
48397 int val3 ;
48398 int ecode3 = 0 ;
48399 int val4 ;
48400 int ecode4 = 0 ;
48401 PyObject * obj0 = 0 ;
48402 PyObject * obj1 = 0 ;
48403 PyObject * obj2 = 0 ;
48404 PyObject * obj3 = 0 ;
48405 PyObject * obj4 = 0 ;
48406 char * kwnames[] = {
48407 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48408 };
48409
48410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48412 if (!SWIG_IsOK(res1)) {
48413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48414 }
48415 arg1 = reinterpret_cast< wxWindow * >(argp1);
48416 ecode2 = SWIG_AsVal_int(obj1, &val2);
48417 if (!SWIG_IsOK(ecode2)) {
48418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48419 }
48420 arg2 = static_cast< int >(val2);
48421 ecode3 = SWIG_AsVal_int(obj2, &val3);
48422 if (!SWIG_IsOK(ecode3)) {
48423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48424 }
48425 arg3 = static_cast< int >(val3);
48426 ecode4 = SWIG_AsVal_int(obj3, &val4);
48427 if (!SWIG_IsOK(ecode4)) {
48428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48429 }
48430 arg4 = static_cast< int >(val4);
48431 if (obj4) {
48432 arg5 = obj4;
48433 }
48434 {
48435 PyThreadState* __tstate = wxPyBeginAllowThreads();
48436 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48437 wxPyEndAllowThreads(__tstate);
48438 if (PyErr_Occurred()) SWIG_fail;
48439 }
48440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48441 return resultobj;
48442 fail:
48443 return NULL;
48444 }
48445
48446
48447 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48448 PyObject *resultobj = 0;
48449 int arg1 ;
48450 int arg2 ;
48451 int arg3 ;
48452 int arg4 ;
48453 int arg5 ;
48454 PyObject *arg6 = (PyObject *) NULL ;
48455 wxSizerItem *result = 0 ;
48456 int val1 ;
48457 int ecode1 = 0 ;
48458 int val2 ;
48459 int ecode2 = 0 ;
48460 int val3 ;
48461 int ecode3 = 0 ;
48462 int val4 ;
48463 int ecode4 = 0 ;
48464 int val5 ;
48465 int ecode5 = 0 ;
48466 PyObject * obj0 = 0 ;
48467 PyObject * obj1 = 0 ;
48468 PyObject * obj2 = 0 ;
48469 PyObject * obj3 = 0 ;
48470 PyObject * obj4 = 0 ;
48471 PyObject * obj5 = 0 ;
48472 char * kwnames[] = {
48473 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48474 };
48475
48476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48477 ecode1 = SWIG_AsVal_int(obj0, &val1);
48478 if (!SWIG_IsOK(ecode1)) {
48479 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48480 }
48481 arg1 = static_cast< int >(val1);
48482 ecode2 = SWIG_AsVal_int(obj1, &val2);
48483 if (!SWIG_IsOK(ecode2)) {
48484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48485 }
48486 arg2 = static_cast< int >(val2);
48487 ecode3 = SWIG_AsVal_int(obj2, &val3);
48488 if (!SWIG_IsOK(ecode3)) {
48489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48490 }
48491 arg3 = static_cast< int >(val3);
48492 ecode4 = SWIG_AsVal_int(obj3, &val4);
48493 if (!SWIG_IsOK(ecode4)) {
48494 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48495 }
48496 arg4 = static_cast< int >(val4);
48497 ecode5 = SWIG_AsVal_int(obj4, &val5);
48498 if (!SWIG_IsOK(ecode5)) {
48499 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48500 }
48501 arg5 = static_cast< int >(val5);
48502 if (obj5) {
48503 arg6 = obj5;
48504 }
48505 {
48506 PyThreadState* __tstate = wxPyBeginAllowThreads();
48507 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48508 wxPyEndAllowThreads(__tstate);
48509 if (PyErr_Occurred()) SWIG_fail;
48510 }
48511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48512 return resultobj;
48513 fail:
48514 return NULL;
48515 }
48516
48517
48518 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48519 PyObject *resultobj = 0;
48520 wxSizer *arg1 = (wxSizer *) 0 ;
48521 int arg2 ;
48522 int arg3 ;
48523 int arg4 ;
48524 PyObject *arg5 = (PyObject *) NULL ;
48525 wxSizerItem *result = 0 ;
48526 int res1 = 0 ;
48527 int val2 ;
48528 int ecode2 = 0 ;
48529 int val3 ;
48530 int ecode3 = 0 ;
48531 int val4 ;
48532 int ecode4 = 0 ;
48533 PyObject * obj0 = 0 ;
48534 PyObject * obj1 = 0 ;
48535 PyObject * obj2 = 0 ;
48536 PyObject * obj3 = 0 ;
48537 PyObject * obj4 = 0 ;
48538 char * kwnames[] = {
48539 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48540 };
48541
48542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48543 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48544 if (!SWIG_IsOK(res1)) {
48545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48546 }
48547 ecode2 = SWIG_AsVal_int(obj1, &val2);
48548 if (!SWIG_IsOK(ecode2)) {
48549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48550 }
48551 arg2 = static_cast< int >(val2);
48552 ecode3 = SWIG_AsVal_int(obj2, &val3);
48553 if (!SWIG_IsOK(ecode3)) {
48554 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48555 }
48556 arg3 = static_cast< int >(val3);
48557 ecode4 = SWIG_AsVal_int(obj3, &val4);
48558 if (!SWIG_IsOK(ecode4)) {
48559 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48560 }
48561 arg4 = static_cast< int >(val4);
48562 if (obj4) {
48563 arg5 = obj4;
48564 }
48565 {
48566 PyThreadState* __tstate = wxPyBeginAllowThreads();
48567 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48568 wxPyEndAllowThreads(__tstate);
48569 if (PyErr_Occurred()) SWIG_fail;
48570 }
48571 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48572 return resultobj;
48573 fail:
48574 return NULL;
48575 }
48576
48577
48578 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48579 PyObject *resultobj = 0;
48580 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48581 void *argp1 = 0 ;
48582 int res1 = 0 ;
48583 PyObject *swig_obj[1] ;
48584
48585 if (!args) SWIG_fail;
48586 swig_obj[0] = args;
48587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48588 if (!SWIG_IsOK(res1)) {
48589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48590 }
48591 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48592 {
48593 PyThreadState* __tstate = wxPyBeginAllowThreads();
48594 (arg1)->DeleteWindows();
48595 wxPyEndAllowThreads(__tstate);
48596 if (PyErr_Occurred()) SWIG_fail;
48597 }
48598 resultobj = SWIG_Py_Void();
48599 return resultobj;
48600 fail:
48601 return NULL;
48602 }
48603
48604
48605 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48606 PyObject *resultobj = 0;
48607 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48608 void *argp1 = 0 ;
48609 int res1 = 0 ;
48610 PyObject *swig_obj[1] ;
48611
48612 if (!args) SWIG_fail;
48613 swig_obj[0] = args;
48614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48615 if (!SWIG_IsOK(res1)) {
48616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48617 }
48618 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48619 {
48620 PyThreadState* __tstate = wxPyBeginAllowThreads();
48621 (arg1)->DetachSizer();
48622 wxPyEndAllowThreads(__tstate);
48623 if (PyErr_Occurred()) SWIG_fail;
48624 }
48625 resultobj = SWIG_Py_Void();
48626 return resultobj;
48627 fail:
48628 return NULL;
48629 }
48630
48631
48632 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48633 PyObject *resultobj = 0;
48634 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48635 wxSize result;
48636 void *argp1 = 0 ;
48637 int res1 = 0 ;
48638 PyObject *swig_obj[1] ;
48639
48640 if (!args) SWIG_fail;
48641 swig_obj[0] = args;
48642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48643 if (!SWIG_IsOK(res1)) {
48644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48645 }
48646 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48647 {
48648 PyThreadState* __tstate = wxPyBeginAllowThreads();
48649 result = (arg1)->GetSize();
48650 wxPyEndAllowThreads(__tstate);
48651 if (PyErr_Occurred()) SWIG_fail;
48652 }
48653 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48654 return resultobj;
48655 fail:
48656 return NULL;
48657 }
48658
48659
48660 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48661 PyObject *resultobj = 0;
48662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48663 wxSize result;
48664 void *argp1 = 0 ;
48665 int res1 = 0 ;
48666 PyObject *swig_obj[1] ;
48667
48668 if (!args) SWIG_fail;
48669 swig_obj[0] = args;
48670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48671 if (!SWIG_IsOK(res1)) {
48672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48673 }
48674 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48675 {
48676 PyThreadState* __tstate = wxPyBeginAllowThreads();
48677 result = (arg1)->CalcMin();
48678 wxPyEndAllowThreads(__tstate);
48679 if (PyErr_Occurred()) SWIG_fail;
48680 }
48681 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48682 return resultobj;
48683 fail:
48684 return NULL;
48685 }
48686
48687
48688 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48689 PyObject *resultobj = 0;
48690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48691 wxPoint *arg2 = 0 ;
48692 wxSize *arg3 = 0 ;
48693 void *argp1 = 0 ;
48694 int res1 = 0 ;
48695 wxPoint temp2 ;
48696 wxSize temp3 ;
48697 PyObject * obj0 = 0 ;
48698 PyObject * obj1 = 0 ;
48699 PyObject * obj2 = 0 ;
48700 char * kwnames[] = {
48701 (char *) "self",(char *) "pos",(char *) "size", NULL
48702 };
48703
48704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48706 if (!SWIG_IsOK(res1)) {
48707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48708 }
48709 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48710 {
48711 arg2 = &temp2;
48712 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48713 }
48714 {
48715 arg3 = &temp3;
48716 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48717 }
48718 {
48719 PyThreadState* __tstate = wxPyBeginAllowThreads();
48720 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48721 wxPyEndAllowThreads(__tstate);
48722 if (PyErr_Occurred()) SWIG_fail;
48723 }
48724 resultobj = SWIG_Py_Void();
48725 return resultobj;
48726 fail:
48727 return NULL;
48728 }
48729
48730
48731 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48732 PyObject *resultobj = 0;
48733 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48734 wxSize result;
48735 void *argp1 = 0 ;
48736 int res1 = 0 ;
48737 PyObject *swig_obj[1] ;
48738
48739 if (!args) SWIG_fail;
48740 swig_obj[0] = args;
48741 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48742 if (!SWIG_IsOK(res1)) {
48743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48744 }
48745 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48746 {
48747 PyThreadState* __tstate = wxPyBeginAllowThreads();
48748 result = (arg1)->GetMinSize();
48749 wxPyEndAllowThreads(__tstate);
48750 if (PyErr_Occurred()) SWIG_fail;
48751 }
48752 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48753 return resultobj;
48754 fail:
48755 return NULL;
48756 }
48757
48758
48759 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48760 PyObject *resultobj = 0;
48761 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48762 wxSize result;
48763 void *argp1 = 0 ;
48764 int res1 = 0 ;
48765 PyObject *swig_obj[1] ;
48766
48767 if (!args) SWIG_fail;
48768 swig_obj[0] = args;
48769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48770 if (!SWIG_IsOK(res1)) {
48771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48772 }
48773 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48774 {
48775 PyThreadState* __tstate = wxPyBeginAllowThreads();
48776 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48777 wxPyEndAllowThreads(__tstate);
48778 if (PyErr_Occurred()) SWIG_fail;
48779 }
48780 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48781 return resultobj;
48782 fail:
48783 return NULL;
48784 }
48785
48786
48787 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48788 PyObject *resultobj = 0;
48789 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48790 int arg2 ;
48791 int arg3 ;
48792 void *argp1 = 0 ;
48793 int res1 = 0 ;
48794 int val2 ;
48795 int ecode2 = 0 ;
48796 int val3 ;
48797 int ecode3 = 0 ;
48798 PyObject * obj0 = 0 ;
48799 PyObject * obj1 = 0 ;
48800 PyObject * obj2 = 0 ;
48801 char * kwnames[] = {
48802 (char *) "self",(char *) "x",(char *) "y", NULL
48803 };
48804
48805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48807 if (!SWIG_IsOK(res1)) {
48808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48809 }
48810 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48811 ecode2 = SWIG_AsVal_int(obj1, &val2);
48812 if (!SWIG_IsOK(ecode2)) {
48813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
48814 }
48815 arg2 = static_cast< int >(val2);
48816 ecode3 = SWIG_AsVal_int(obj2, &val3);
48817 if (!SWIG_IsOK(ecode3)) {
48818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
48819 }
48820 arg3 = static_cast< int >(val3);
48821 {
48822 PyThreadState* __tstate = wxPyBeginAllowThreads();
48823 (arg1)->SetInitSize(arg2,arg3);
48824 wxPyEndAllowThreads(__tstate);
48825 if (PyErr_Occurred()) SWIG_fail;
48826 }
48827 resultobj = SWIG_Py_Void();
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48835 PyObject *resultobj = 0;
48836 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48837 int arg2 ;
48838 int arg3 ;
48839 void *argp1 = 0 ;
48840 int res1 = 0 ;
48841 int val2 ;
48842 int ecode2 = 0 ;
48843 int val3 ;
48844 int ecode3 = 0 ;
48845 PyObject * obj0 = 0 ;
48846 PyObject * obj1 = 0 ;
48847 PyObject * obj2 = 0 ;
48848 char * kwnames[] = {
48849 (char *) "self",(char *) "width",(char *) "height", NULL
48850 };
48851
48852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48854 if (!SWIG_IsOK(res1)) {
48855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48856 }
48857 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48858 ecode2 = SWIG_AsVal_int(obj1, &val2);
48859 if (!SWIG_IsOK(ecode2)) {
48860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
48861 }
48862 arg2 = static_cast< int >(val2);
48863 ecode3 = SWIG_AsVal_int(obj2, &val3);
48864 if (!SWIG_IsOK(ecode3)) {
48865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
48866 }
48867 arg3 = static_cast< int >(val3);
48868 {
48869 PyThreadState* __tstate = wxPyBeginAllowThreads();
48870 (arg1)->SetRatio(arg2,arg3);
48871 wxPyEndAllowThreads(__tstate);
48872 if (PyErr_Occurred()) SWIG_fail;
48873 }
48874 resultobj = SWIG_Py_Void();
48875 return resultobj;
48876 fail:
48877 return NULL;
48878 }
48879
48880
48881 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48882 PyObject *resultobj = 0;
48883 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48884 wxSize *arg2 = 0 ;
48885 void *argp1 = 0 ;
48886 int res1 = 0 ;
48887 wxSize temp2 ;
48888 PyObject * obj0 = 0 ;
48889 PyObject * obj1 = 0 ;
48890 char * kwnames[] = {
48891 (char *) "self",(char *) "size", NULL
48892 };
48893
48894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
48895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48896 if (!SWIG_IsOK(res1)) {
48897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48898 }
48899 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48900 {
48901 arg2 = &temp2;
48902 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
48903 }
48904 {
48905 PyThreadState* __tstate = wxPyBeginAllowThreads();
48906 (arg1)->SetRatio((wxSize const &)*arg2);
48907 wxPyEndAllowThreads(__tstate);
48908 if (PyErr_Occurred()) SWIG_fail;
48909 }
48910 resultobj = SWIG_Py_Void();
48911 return resultobj;
48912 fail:
48913 return NULL;
48914 }
48915
48916
48917 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48918 PyObject *resultobj = 0;
48919 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48920 float arg2 ;
48921 void *argp1 = 0 ;
48922 int res1 = 0 ;
48923 float val2 ;
48924 int ecode2 = 0 ;
48925 PyObject * obj0 = 0 ;
48926 PyObject * obj1 = 0 ;
48927 char * kwnames[] = {
48928 (char *) "self",(char *) "ratio", NULL
48929 };
48930
48931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
48932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48933 if (!SWIG_IsOK(res1)) {
48934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48935 }
48936 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48937 ecode2 = SWIG_AsVal_float(obj1, &val2);
48938 if (!SWIG_IsOK(ecode2)) {
48939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
48940 }
48941 arg2 = static_cast< float >(val2);
48942 {
48943 PyThreadState* __tstate = wxPyBeginAllowThreads();
48944 (arg1)->SetRatio(arg2);
48945 wxPyEndAllowThreads(__tstate);
48946 if (PyErr_Occurred()) SWIG_fail;
48947 }
48948 resultobj = SWIG_Py_Void();
48949 return resultobj;
48950 fail:
48951 return NULL;
48952 }
48953
48954
48955 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48956 PyObject *resultobj = 0;
48957 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48958 float result;
48959 void *argp1 = 0 ;
48960 int res1 = 0 ;
48961 PyObject *swig_obj[1] ;
48962
48963 if (!args) SWIG_fail;
48964 swig_obj[0] = args;
48965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48966 if (!SWIG_IsOK(res1)) {
48967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48968 }
48969 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48970 {
48971 PyThreadState* __tstate = wxPyBeginAllowThreads();
48972 result = (float)(arg1)->GetRatio();
48973 wxPyEndAllowThreads(__tstate);
48974 if (PyErr_Occurred()) SWIG_fail;
48975 }
48976 resultobj = SWIG_From_float(static_cast< float >(result));
48977 return resultobj;
48978 fail:
48979 return NULL;
48980 }
48981
48982
48983 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48984 PyObject *resultobj = 0;
48985 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48986 wxRect result;
48987 void *argp1 = 0 ;
48988 int res1 = 0 ;
48989 PyObject *swig_obj[1] ;
48990
48991 if (!args) SWIG_fail;
48992 swig_obj[0] = args;
48993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48994 if (!SWIG_IsOK(res1)) {
48995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48996 }
48997 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48998 {
48999 PyThreadState* __tstate = wxPyBeginAllowThreads();
49000 result = (arg1)->GetRect();
49001 wxPyEndAllowThreads(__tstate);
49002 if (PyErr_Occurred()) SWIG_fail;
49003 }
49004 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49005 return resultobj;
49006 fail:
49007 return NULL;
49008 }
49009
49010
49011 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49012 PyObject *resultobj = 0;
49013 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49014 bool result;
49015 void *argp1 = 0 ;
49016 int res1 = 0 ;
49017 PyObject *swig_obj[1] ;
49018
49019 if (!args) SWIG_fail;
49020 swig_obj[0] = args;
49021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49022 if (!SWIG_IsOK(res1)) {
49023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49024 }
49025 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49026 {
49027 PyThreadState* __tstate = wxPyBeginAllowThreads();
49028 result = (bool)(arg1)->IsWindow();
49029 wxPyEndAllowThreads(__tstate);
49030 if (PyErr_Occurred()) SWIG_fail;
49031 }
49032 {
49033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49034 }
49035 return resultobj;
49036 fail:
49037 return NULL;
49038 }
49039
49040
49041 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49042 PyObject *resultobj = 0;
49043 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49044 bool result;
49045 void *argp1 = 0 ;
49046 int res1 = 0 ;
49047 PyObject *swig_obj[1] ;
49048
49049 if (!args) SWIG_fail;
49050 swig_obj[0] = args;
49051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49052 if (!SWIG_IsOK(res1)) {
49053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49054 }
49055 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49056 {
49057 PyThreadState* __tstate = wxPyBeginAllowThreads();
49058 result = (bool)(arg1)->IsSizer();
49059 wxPyEndAllowThreads(__tstate);
49060 if (PyErr_Occurred()) SWIG_fail;
49061 }
49062 {
49063 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49064 }
49065 return resultobj;
49066 fail:
49067 return NULL;
49068 }
49069
49070
49071 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49072 PyObject *resultobj = 0;
49073 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49074 bool result;
49075 void *argp1 = 0 ;
49076 int res1 = 0 ;
49077 PyObject *swig_obj[1] ;
49078
49079 if (!args) SWIG_fail;
49080 swig_obj[0] = args;
49081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49082 if (!SWIG_IsOK(res1)) {
49083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49084 }
49085 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49086 {
49087 PyThreadState* __tstate = wxPyBeginAllowThreads();
49088 result = (bool)(arg1)->IsSpacer();
49089 wxPyEndAllowThreads(__tstate);
49090 if (PyErr_Occurred()) SWIG_fail;
49091 }
49092 {
49093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49094 }
49095 return resultobj;
49096 fail:
49097 return NULL;
49098 }
49099
49100
49101 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49102 PyObject *resultobj = 0;
49103 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49104 int arg2 ;
49105 void *argp1 = 0 ;
49106 int res1 = 0 ;
49107 int val2 ;
49108 int ecode2 = 0 ;
49109 PyObject * obj0 = 0 ;
49110 PyObject * obj1 = 0 ;
49111 char * kwnames[] = {
49112 (char *) "self",(char *) "proportion", NULL
49113 };
49114
49115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49117 if (!SWIG_IsOK(res1)) {
49118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49119 }
49120 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49121 ecode2 = SWIG_AsVal_int(obj1, &val2);
49122 if (!SWIG_IsOK(ecode2)) {
49123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49124 }
49125 arg2 = static_cast< int >(val2);
49126 {
49127 PyThreadState* __tstate = wxPyBeginAllowThreads();
49128 (arg1)->SetProportion(arg2);
49129 wxPyEndAllowThreads(__tstate);
49130 if (PyErr_Occurred()) SWIG_fail;
49131 }
49132 resultobj = SWIG_Py_Void();
49133 return resultobj;
49134 fail:
49135 return NULL;
49136 }
49137
49138
49139 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49140 PyObject *resultobj = 0;
49141 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49142 int result;
49143 void *argp1 = 0 ;
49144 int res1 = 0 ;
49145 PyObject *swig_obj[1] ;
49146
49147 if (!args) SWIG_fail;
49148 swig_obj[0] = args;
49149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49150 if (!SWIG_IsOK(res1)) {
49151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49152 }
49153 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49154 {
49155 PyThreadState* __tstate = wxPyBeginAllowThreads();
49156 result = (int)(arg1)->GetProportion();
49157 wxPyEndAllowThreads(__tstate);
49158 if (PyErr_Occurred()) SWIG_fail;
49159 }
49160 resultobj = SWIG_From_int(static_cast< int >(result));
49161 return resultobj;
49162 fail:
49163 return NULL;
49164 }
49165
49166
49167 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49168 PyObject *resultobj = 0;
49169 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49170 int arg2 ;
49171 void *argp1 = 0 ;
49172 int res1 = 0 ;
49173 int val2 ;
49174 int ecode2 = 0 ;
49175 PyObject * obj0 = 0 ;
49176 PyObject * obj1 = 0 ;
49177 char * kwnames[] = {
49178 (char *) "self",(char *) "flag", NULL
49179 };
49180
49181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49183 if (!SWIG_IsOK(res1)) {
49184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49185 }
49186 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49187 ecode2 = SWIG_AsVal_int(obj1, &val2);
49188 if (!SWIG_IsOK(ecode2)) {
49189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49190 }
49191 arg2 = static_cast< int >(val2);
49192 {
49193 PyThreadState* __tstate = wxPyBeginAllowThreads();
49194 (arg1)->SetFlag(arg2);
49195 wxPyEndAllowThreads(__tstate);
49196 if (PyErr_Occurred()) SWIG_fail;
49197 }
49198 resultobj = SWIG_Py_Void();
49199 return resultobj;
49200 fail:
49201 return NULL;
49202 }
49203
49204
49205 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49206 PyObject *resultobj = 0;
49207 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49208 int result;
49209 void *argp1 = 0 ;
49210 int res1 = 0 ;
49211 PyObject *swig_obj[1] ;
49212
49213 if (!args) SWIG_fail;
49214 swig_obj[0] = args;
49215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49216 if (!SWIG_IsOK(res1)) {
49217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49218 }
49219 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49220 {
49221 PyThreadState* __tstate = wxPyBeginAllowThreads();
49222 result = (int)(arg1)->GetFlag();
49223 wxPyEndAllowThreads(__tstate);
49224 if (PyErr_Occurred()) SWIG_fail;
49225 }
49226 resultobj = SWIG_From_int(static_cast< int >(result));
49227 return resultobj;
49228 fail:
49229 return NULL;
49230 }
49231
49232
49233 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49234 PyObject *resultobj = 0;
49235 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49236 int arg2 ;
49237 void *argp1 = 0 ;
49238 int res1 = 0 ;
49239 int val2 ;
49240 int ecode2 = 0 ;
49241 PyObject * obj0 = 0 ;
49242 PyObject * obj1 = 0 ;
49243 char * kwnames[] = {
49244 (char *) "self",(char *) "border", NULL
49245 };
49246
49247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49249 if (!SWIG_IsOK(res1)) {
49250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49251 }
49252 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49253 ecode2 = SWIG_AsVal_int(obj1, &val2);
49254 if (!SWIG_IsOK(ecode2)) {
49255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49256 }
49257 arg2 = static_cast< int >(val2);
49258 {
49259 PyThreadState* __tstate = wxPyBeginAllowThreads();
49260 (arg1)->SetBorder(arg2);
49261 wxPyEndAllowThreads(__tstate);
49262 if (PyErr_Occurred()) SWIG_fail;
49263 }
49264 resultobj = SWIG_Py_Void();
49265 return resultobj;
49266 fail:
49267 return NULL;
49268 }
49269
49270
49271 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49272 PyObject *resultobj = 0;
49273 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49274 int result;
49275 void *argp1 = 0 ;
49276 int res1 = 0 ;
49277 PyObject *swig_obj[1] ;
49278
49279 if (!args) SWIG_fail;
49280 swig_obj[0] = args;
49281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49282 if (!SWIG_IsOK(res1)) {
49283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49284 }
49285 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49286 {
49287 PyThreadState* __tstate = wxPyBeginAllowThreads();
49288 result = (int)(arg1)->GetBorder();
49289 wxPyEndAllowThreads(__tstate);
49290 if (PyErr_Occurred()) SWIG_fail;
49291 }
49292 resultobj = SWIG_From_int(static_cast< int >(result));
49293 return resultobj;
49294 fail:
49295 return NULL;
49296 }
49297
49298
49299 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49300 PyObject *resultobj = 0;
49301 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49302 wxWindow *result = 0 ;
49303 void *argp1 = 0 ;
49304 int res1 = 0 ;
49305 PyObject *swig_obj[1] ;
49306
49307 if (!args) SWIG_fail;
49308 swig_obj[0] = args;
49309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49310 if (!SWIG_IsOK(res1)) {
49311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49312 }
49313 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49314 {
49315 PyThreadState* __tstate = wxPyBeginAllowThreads();
49316 result = (wxWindow *)(arg1)->GetWindow();
49317 wxPyEndAllowThreads(__tstate);
49318 if (PyErr_Occurred()) SWIG_fail;
49319 }
49320 {
49321 resultobj = wxPyMake_wxObject(result, 0);
49322 }
49323 return resultobj;
49324 fail:
49325 return NULL;
49326 }
49327
49328
49329 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49330 PyObject *resultobj = 0;
49331 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49332 wxWindow *arg2 = (wxWindow *) 0 ;
49333 void *argp1 = 0 ;
49334 int res1 = 0 ;
49335 void *argp2 = 0 ;
49336 int res2 = 0 ;
49337 PyObject * obj0 = 0 ;
49338 PyObject * obj1 = 0 ;
49339 char * kwnames[] = {
49340 (char *) "self",(char *) "window", NULL
49341 };
49342
49343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49345 if (!SWIG_IsOK(res1)) {
49346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49347 }
49348 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49349 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49350 if (!SWIG_IsOK(res2)) {
49351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49352 }
49353 arg2 = reinterpret_cast< wxWindow * >(argp2);
49354 {
49355 PyThreadState* __tstate = wxPyBeginAllowThreads();
49356 (arg1)->SetWindow(arg2);
49357 wxPyEndAllowThreads(__tstate);
49358 if (PyErr_Occurred()) SWIG_fail;
49359 }
49360 resultobj = SWIG_Py_Void();
49361 return resultobj;
49362 fail:
49363 return NULL;
49364 }
49365
49366
49367 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49368 PyObject *resultobj = 0;
49369 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49370 wxSizer *result = 0 ;
49371 void *argp1 = 0 ;
49372 int res1 = 0 ;
49373 PyObject *swig_obj[1] ;
49374
49375 if (!args) SWIG_fail;
49376 swig_obj[0] = args;
49377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49378 if (!SWIG_IsOK(res1)) {
49379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49380 }
49381 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49382 {
49383 PyThreadState* __tstate = wxPyBeginAllowThreads();
49384 result = (wxSizer *)(arg1)->GetSizer();
49385 wxPyEndAllowThreads(__tstate);
49386 if (PyErr_Occurred()) SWIG_fail;
49387 }
49388 {
49389 resultobj = wxPyMake_wxObject(result, (bool)0);
49390 }
49391 return resultobj;
49392 fail:
49393 return NULL;
49394 }
49395
49396
49397 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49398 PyObject *resultobj = 0;
49399 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49400 wxSizer *arg2 = (wxSizer *) 0 ;
49401 void *argp1 = 0 ;
49402 int res1 = 0 ;
49403 int res2 = 0 ;
49404 PyObject * obj0 = 0 ;
49405 PyObject * obj1 = 0 ;
49406 char * kwnames[] = {
49407 (char *) "self",(char *) "sizer", NULL
49408 };
49409
49410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49412 if (!SWIG_IsOK(res1)) {
49413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49414 }
49415 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49416 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49417 if (!SWIG_IsOK(res2)) {
49418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49419 }
49420 {
49421 PyThreadState* __tstate = wxPyBeginAllowThreads();
49422 (arg1)->SetSizer(arg2);
49423 wxPyEndAllowThreads(__tstate);
49424 if (PyErr_Occurred()) SWIG_fail;
49425 }
49426 resultobj = SWIG_Py_Void();
49427 return resultobj;
49428 fail:
49429 return NULL;
49430 }
49431
49432
49433 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49434 PyObject *resultobj = 0;
49435 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49436 wxSize result;
49437 void *argp1 = 0 ;
49438 int res1 = 0 ;
49439 PyObject *swig_obj[1] ;
49440
49441 if (!args) SWIG_fail;
49442 swig_obj[0] = args;
49443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49444 if (!SWIG_IsOK(res1)) {
49445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49446 }
49447 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49448 {
49449 PyThreadState* __tstate = wxPyBeginAllowThreads();
49450 result = (arg1)->GetSpacer();
49451 wxPyEndAllowThreads(__tstate);
49452 if (PyErr_Occurred()) SWIG_fail;
49453 }
49454 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49455 return resultobj;
49456 fail:
49457 return NULL;
49458 }
49459
49460
49461 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49462 PyObject *resultobj = 0;
49463 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49464 wxSize *arg2 = 0 ;
49465 void *argp1 = 0 ;
49466 int res1 = 0 ;
49467 wxSize temp2 ;
49468 PyObject * obj0 = 0 ;
49469 PyObject * obj1 = 0 ;
49470 char * kwnames[] = {
49471 (char *) "self",(char *) "size", NULL
49472 };
49473
49474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49476 if (!SWIG_IsOK(res1)) {
49477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49478 }
49479 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49480 {
49481 arg2 = &temp2;
49482 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49483 }
49484 {
49485 PyThreadState* __tstate = wxPyBeginAllowThreads();
49486 (arg1)->SetSpacer((wxSize const &)*arg2);
49487 wxPyEndAllowThreads(__tstate);
49488 if (PyErr_Occurred()) SWIG_fail;
49489 }
49490 resultobj = SWIG_Py_Void();
49491 return resultobj;
49492 fail:
49493 return NULL;
49494 }
49495
49496
49497 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49498 PyObject *resultobj = 0;
49499 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49500 bool arg2 ;
49501 void *argp1 = 0 ;
49502 int res1 = 0 ;
49503 bool val2 ;
49504 int ecode2 = 0 ;
49505 PyObject * obj0 = 0 ;
49506 PyObject * obj1 = 0 ;
49507 char * kwnames[] = {
49508 (char *) "self",(char *) "show", NULL
49509 };
49510
49511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49513 if (!SWIG_IsOK(res1)) {
49514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49515 }
49516 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49517 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49518 if (!SWIG_IsOK(ecode2)) {
49519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49520 }
49521 arg2 = static_cast< bool >(val2);
49522 {
49523 PyThreadState* __tstate = wxPyBeginAllowThreads();
49524 (arg1)->Show(arg2);
49525 wxPyEndAllowThreads(__tstate);
49526 if (PyErr_Occurred()) SWIG_fail;
49527 }
49528 resultobj = SWIG_Py_Void();
49529 return resultobj;
49530 fail:
49531 return NULL;
49532 }
49533
49534
49535 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49536 PyObject *resultobj = 0;
49537 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49538 bool result;
49539 void *argp1 = 0 ;
49540 int res1 = 0 ;
49541 PyObject *swig_obj[1] ;
49542
49543 if (!args) SWIG_fail;
49544 swig_obj[0] = args;
49545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49546 if (!SWIG_IsOK(res1)) {
49547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49548 }
49549 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49550 {
49551 PyThreadState* __tstate = wxPyBeginAllowThreads();
49552 result = (bool)(arg1)->IsShown();
49553 wxPyEndAllowThreads(__tstate);
49554 if (PyErr_Occurred()) SWIG_fail;
49555 }
49556 {
49557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49558 }
49559 return resultobj;
49560 fail:
49561 return NULL;
49562 }
49563
49564
49565 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49566 PyObject *resultobj = 0;
49567 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49568 wxPoint result;
49569 void *argp1 = 0 ;
49570 int res1 = 0 ;
49571 PyObject *swig_obj[1] ;
49572
49573 if (!args) SWIG_fail;
49574 swig_obj[0] = args;
49575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49576 if (!SWIG_IsOK(res1)) {
49577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49578 }
49579 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49580 {
49581 PyThreadState* __tstate = wxPyBeginAllowThreads();
49582 result = (arg1)->GetPosition();
49583 wxPyEndAllowThreads(__tstate);
49584 if (PyErr_Occurred()) SWIG_fail;
49585 }
49586 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49587 return resultobj;
49588 fail:
49589 return NULL;
49590 }
49591
49592
49593 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49594 PyObject *resultobj = 0;
49595 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49596 PyObject *result = 0 ;
49597 void *argp1 = 0 ;
49598 int res1 = 0 ;
49599 PyObject *swig_obj[1] ;
49600
49601 if (!args) SWIG_fail;
49602 swig_obj[0] = args;
49603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49604 if (!SWIG_IsOK(res1)) {
49605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49606 }
49607 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49608 {
49609 PyThreadState* __tstate = wxPyBeginAllowThreads();
49610 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49611 wxPyEndAllowThreads(__tstate);
49612 if (PyErr_Occurred()) SWIG_fail;
49613 }
49614 resultobj = result;
49615 return resultobj;
49616 fail:
49617 return NULL;
49618 }
49619
49620
49621 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49622 PyObject *resultobj = 0;
49623 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49624 PyObject *arg2 = (PyObject *) 0 ;
49625 void *argp1 = 0 ;
49626 int res1 = 0 ;
49627 PyObject * obj0 = 0 ;
49628 PyObject * obj1 = 0 ;
49629 char * kwnames[] = {
49630 (char *) "self",(char *) "userData", NULL
49631 };
49632
49633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49635 if (!SWIG_IsOK(res1)) {
49636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49637 }
49638 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49639 arg2 = obj1;
49640 {
49641 PyThreadState* __tstate = wxPyBeginAllowThreads();
49642 wxSizerItem_SetUserData(arg1,arg2);
49643 wxPyEndAllowThreads(__tstate);
49644 if (PyErr_Occurred()) SWIG_fail;
49645 }
49646 resultobj = SWIG_Py_Void();
49647 return resultobj;
49648 fail:
49649 return NULL;
49650 }
49651
49652
49653 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49654 PyObject *obj;
49655 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49656 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49657 return SWIG_Py_Void();
49658 }
49659
49660 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49661 return SWIG_Python_InitShadowInstance(args);
49662 }
49663
49664 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49665 PyObject *resultobj = 0;
49666 wxSizer *arg1 = (wxSizer *) 0 ;
49667 void *argp1 = 0 ;
49668 int res1 = 0 ;
49669 PyObject *swig_obj[1] ;
49670
49671 if (!args) SWIG_fail;
49672 swig_obj[0] = args;
49673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49674 if (!SWIG_IsOK(res1)) {
49675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49676 }
49677 arg1 = reinterpret_cast< wxSizer * >(argp1);
49678 {
49679 PyThreadState* __tstate = wxPyBeginAllowThreads();
49680 delete arg1;
49681
49682 wxPyEndAllowThreads(__tstate);
49683 if (PyErr_Occurred()) SWIG_fail;
49684 }
49685 resultobj = SWIG_Py_Void();
49686 return resultobj;
49687 fail:
49688 return NULL;
49689 }
49690
49691
49692 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49693 PyObject *resultobj = 0;
49694 wxSizer *arg1 = (wxSizer *) 0 ;
49695 PyObject *arg2 = (PyObject *) 0 ;
49696 void *argp1 = 0 ;
49697 int res1 = 0 ;
49698 PyObject * obj0 = 0 ;
49699 PyObject * obj1 = 0 ;
49700 char * kwnames[] = {
49701 (char *) "self",(char *) "_self", NULL
49702 };
49703
49704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49706 if (!SWIG_IsOK(res1)) {
49707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49708 }
49709 arg1 = reinterpret_cast< wxSizer * >(argp1);
49710 arg2 = obj1;
49711 {
49712 PyThreadState* __tstate = wxPyBeginAllowThreads();
49713 wxSizer__setOORInfo(arg1,arg2);
49714 wxPyEndAllowThreads(__tstate);
49715 if (PyErr_Occurred()) SWIG_fail;
49716 }
49717 resultobj = SWIG_Py_Void();
49718 return resultobj;
49719 fail:
49720 return NULL;
49721 }
49722
49723
49724 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49725 PyObject *resultobj = 0;
49726 wxSizer *arg1 = (wxSizer *) 0 ;
49727 PyObject *arg2 = (PyObject *) 0 ;
49728 int arg3 = (int) 0 ;
49729 int arg4 = (int) 0 ;
49730 int arg5 = (int) 0 ;
49731 PyObject *arg6 = (PyObject *) NULL ;
49732 wxSizerItem *result = 0 ;
49733 void *argp1 = 0 ;
49734 int res1 = 0 ;
49735 int val3 ;
49736 int ecode3 = 0 ;
49737 int val4 ;
49738 int ecode4 = 0 ;
49739 int val5 ;
49740 int ecode5 = 0 ;
49741 PyObject * obj0 = 0 ;
49742 PyObject * obj1 = 0 ;
49743 PyObject * obj2 = 0 ;
49744 PyObject * obj3 = 0 ;
49745 PyObject * obj4 = 0 ;
49746 PyObject * obj5 = 0 ;
49747 char * kwnames[] = {
49748 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49749 };
49750
49751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49753 if (!SWIG_IsOK(res1)) {
49754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49755 }
49756 arg1 = reinterpret_cast< wxSizer * >(argp1);
49757 arg2 = obj1;
49758 if (obj2) {
49759 ecode3 = SWIG_AsVal_int(obj2, &val3);
49760 if (!SWIG_IsOK(ecode3)) {
49761 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49762 }
49763 arg3 = static_cast< int >(val3);
49764 }
49765 if (obj3) {
49766 ecode4 = SWIG_AsVal_int(obj3, &val4);
49767 if (!SWIG_IsOK(ecode4)) {
49768 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49769 }
49770 arg4 = static_cast< int >(val4);
49771 }
49772 if (obj4) {
49773 ecode5 = SWIG_AsVal_int(obj4, &val5);
49774 if (!SWIG_IsOK(ecode5)) {
49775 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49776 }
49777 arg5 = static_cast< int >(val5);
49778 }
49779 if (obj5) {
49780 arg6 = obj5;
49781 }
49782 {
49783 PyThreadState* __tstate = wxPyBeginAllowThreads();
49784 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49785 wxPyEndAllowThreads(__tstate);
49786 if (PyErr_Occurred()) SWIG_fail;
49787 }
49788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49789 return resultobj;
49790 fail:
49791 return NULL;
49792 }
49793
49794
49795 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49796 PyObject *resultobj = 0;
49797 wxSizer *arg1 = (wxSizer *) 0 ;
49798 int arg2 ;
49799 PyObject *arg3 = (PyObject *) 0 ;
49800 int arg4 = (int) 0 ;
49801 int arg5 = (int) 0 ;
49802 int arg6 = (int) 0 ;
49803 PyObject *arg7 = (PyObject *) NULL ;
49804 wxSizerItem *result = 0 ;
49805 void *argp1 = 0 ;
49806 int res1 = 0 ;
49807 int val2 ;
49808 int ecode2 = 0 ;
49809 int val4 ;
49810 int ecode4 = 0 ;
49811 int val5 ;
49812 int ecode5 = 0 ;
49813 int val6 ;
49814 int ecode6 = 0 ;
49815 PyObject * obj0 = 0 ;
49816 PyObject * obj1 = 0 ;
49817 PyObject * obj2 = 0 ;
49818 PyObject * obj3 = 0 ;
49819 PyObject * obj4 = 0 ;
49820 PyObject * obj5 = 0 ;
49821 PyObject * obj6 = 0 ;
49822 char * kwnames[] = {
49823 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49824 };
49825
49826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49828 if (!SWIG_IsOK(res1)) {
49829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
49830 }
49831 arg1 = reinterpret_cast< wxSizer * >(argp1);
49832 ecode2 = SWIG_AsVal_int(obj1, &val2);
49833 if (!SWIG_IsOK(ecode2)) {
49834 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
49835 }
49836 arg2 = static_cast< int >(val2);
49837 arg3 = obj2;
49838 if (obj3) {
49839 ecode4 = SWIG_AsVal_int(obj3, &val4);
49840 if (!SWIG_IsOK(ecode4)) {
49841 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
49842 }
49843 arg4 = static_cast< int >(val4);
49844 }
49845 if (obj4) {
49846 ecode5 = SWIG_AsVal_int(obj4, &val5);
49847 if (!SWIG_IsOK(ecode5)) {
49848 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
49849 }
49850 arg5 = static_cast< int >(val5);
49851 }
49852 if (obj5) {
49853 ecode6 = SWIG_AsVal_int(obj5, &val6);
49854 if (!SWIG_IsOK(ecode6)) {
49855 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
49856 }
49857 arg6 = static_cast< int >(val6);
49858 }
49859 if (obj6) {
49860 arg7 = obj6;
49861 }
49862 {
49863 PyThreadState* __tstate = wxPyBeginAllowThreads();
49864 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
49865 wxPyEndAllowThreads(__tstate);
49866 if (PyErr_Occurred()) SWIG_fail;
49867 }
49868 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49869 return resultobj;
49870 fail:
49871 return NULL;
49872 }
49873
49874
49875 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49876 PyObject *resultobj = 0;
49877 wxSizer *arg1 = (wxSizer *) 0 ;
49878 PyObject *arg2 = (PyObject *) 0 ;
49879 int arg3 = (int) 0 ;
49880 int arg4 = (int) 0 ;
49881 int arg5 = (int) 0 ;
49882 PyObject *arg6 = (PyObject *) NULL ;
49883 wxSizerItem *result = 0 ;
49884 void *argp1 = 0 ;
49885 int res1 = 0 ;
49886 int val3 ;
49887 int ecode3 = 0 ;
49888 int val4 ;
49889 int ecode4 = 0 ;
49890 int val5 ;
49891 int ecode5 = 0 ;
49892 PyObject * obj0 = 0 ;
49893 PyObject * obj1 = 0 ;
49894 PyObject * obj2 = 0 ;
49895 PyObject * obj3 = 0 ;
49896 PyObject * obj4 = 0 ;
49897 PyObject * obj5 = 0 ;
49898 char * kwnames[] = {
49899 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49900 };
49901
49902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49904 if (!SWIG_IsOK(res1)) {
49905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
49906 }
49907 arg1 = reinterpret_cast< wxSizer * >(argp1);
49908 arg2 = obj1;
49909 if (obj2) {
49910 ecode3 = SWIG_AsVal_int(obj2, &val3);
49911 if (!SWIG_IsOK(ecode3)) {
49912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
49913 }
49914 arg3 = static_cast< int >(val3);
49915 }
49916 if (obj3) {
49917 ecode4 = SWIG_AsVal_int(obj3, &val4);
49918 if (!SWIG_IsOK(ecode4)) {
49919 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
49920 }
49921 arg4 = static_cast< int >(val4);
49922 }
49923 if (obj4) {
49924 ecode5 = SWIG_AsVal_int(obj4, &val5);
49925 if (!SWIG_IsOK(ecode5)) {
49926 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
49927 }
49928 arg5 = static_cast< int >(val5);
49929 }
49930 if (obj5) {
49931 arg6 = obj5;
49932 }
49933 {
49934 PyThreadState* __tstate = wxPyBeginAllowThreads();
49935 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
49936 wxPyEndAllowThreads(__tstate);
49937 if (PyErr_Occurred()) SWIG_fail;
49938 }
49939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49940 return resultobj;
49941 fail:
49942 return NULL;
49943 }
49944
49945
49946 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49947 PyObject *resultobj = 0;
49948 wxSizer *arg1 = (wxSizer *) 0 ;
49949 PyObject *arg2 = (PyObject *) 0 ;
49950 bool result;
49951 void *argp1 = 0 ;
49952 int res1 = 0 ;
49953 PyObject * obj0 = 0 ;
49954 PyObject * obj1 = 0 ;
49955 char * kwnames[] = {
49956 (char *) "self",(char *) "item", NULL
49957 };
49958
49959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
49960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49961 if (!SWIG_IsOK(res1)) {
49962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
49963 }
49964 arg1 = reinterpret_cast< wxSizer * >(argp1);
49965 arg2 = obj1;
49966 {
49967 PyThreadState* __tstate = wxPyBeginAllowThreads();
49968 result = (bool)wxSizer_Remove(arg1,arg2);
49969 wxPyEndAllowThreads(__tstate);
49970 if (PyErr_Occurred()) SWIG_fail;
49971 }
49972 {
49973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49974 }
49975 return resultobj;
49976 fail:
49977 return NULL;
49978 }
49979
49980
49981 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49982 PyObject *resultobj = 0;
49983 wxSizer *arg1 = (wxSizer *) 0 ;
49984 PyObject *arg2 = (PyObject *) 0 ;
49985 bool result;
49986 void *argp1 = 0 ;
49987 int res1 = 0 ;
49988 PyObject * obj0 = 0 ;
49989 PyObject * obj1 = 0 ;
49990 char * kwnames[] = {
49991 (char *) "self",(char *) "item", NULL
49992 };
49993
49994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
49995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49996 if (!SWIG_IsOK(res1)) {
49997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
49998 }
49999 arg1 = reinterpret_cast< wxSizer * >(argp1);
50000 arg2 = obj1;
50001 {
50002 PyThreadState* __tstate = wxPyBeginAllowThreads();
50003 result = (bool)wxSizer_Detach(arg1,arg2);
50004 wxPyEndAllowThreads(__tstate);
50005 if (PyErr_Occurred()) SWIG_fail;
50006 }
50007 {
50008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50009 }
50010 return resultobj;
50011 fail:
50012 return NULL;
50013 }
50014
50015
50016 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50017 PyObject *resultobj = 0;
50018 wxSizer *arg1 = (wxSizer *) 0 ;
50019 PyObject *arg2 = (PyObject *) 0 ;
50020 wxSizerItem *result = 0 ;
50021 void *argp1 = 0 ;
50022 int res1 = 0 ;
50023 PyObject * obj0 = 0 ;
50024 PyObject * obj1 = 0 ;
50025 char * kwnames[] = {
50026 (char *) "self",(char *) "item", NULL
50027 };
50028
50029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50031 if (!SWIG_IsOK(res1)) {
50032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50033 }
50034 arg1 = reinterpret_cast< wxSizer * >(argp1);
50035 arg2 = obj1;
50036 {
50037 PyThreadState* __tstate = wxPyBeginAllowThreads();
50038 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50039 wxPyEndAllowThreads(__tstate);
50040 if (PyErr_Occurred()) SWIG_fail;
50041 }
50042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50043 return resultobj;
50044 fail:
50045 return NULL;
50046 }
50047
50048
50049 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50050 PyObject *resultobj = 0;
50051 wxSizer *arg1 = (wxSizer *) 0 ;
50052 PyObject *arg2 = (PyObject *) 0 ;
50053 wxSize *arg3 = 0 ;
50054 void *argp1 = 0 ;
50055 int res1 = 0 ;
50056 wxSize temp3 ;
50057 PyObject * obj0 = 0 ;
50058 PyObject * obj1 = 0 ;
50059 PyObject * obj2 = 0 ;
50060 char * kwnames[] = {
50061 (char *) "self",(char *) "item",(char *) "size", NULL
50062 };
50063
50064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50066 if (!SWIG_IsOK(res1)) {
50067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50068 }
50069 arg1 = reinterpret_cast< wxSizer * >(argp1);
50070 arg2 = obj1;
50071 {
50072 arg3 = &temp3;
50073 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50074 }
50075 {
50076 PyThreadState* __tstate = wxPyBeginAllowThreads();
50077 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50078 wxPyEndAllowThreads(__tstate);
50079 if (PyErr_Occurred()) SWIG_fail;
50080 }
50081 resultobj = SWIG_Py_Void();
50082 return resultobj;
50083 fail:
50084 return NULL;
50085 }
50086
50087
50088 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50089 PyObject *resultobj = 0;
50090 wxSizer *arg1 = (wxSizer *) 0 ;
50091 wxWindow *arg2 = (wxWindow *) 0 ;
50092 wxWindow *arg3 = (wxWindow *) 0 ;
50093 bool arg4 = (bool) false ;
50094 bool result;
50095 void *argp1 = 0 ;
50096 int res1 = 0 ;
50097 void *argp2 = 0 ;
50098 int res2 = 0 ;
50099 void *argp3 = 0 ;
50100 int res3 = 0 ;
50101 bool val4 ;
50102 int ecode4 = 0 ;
50103 PyObject * obj0 = 0 ;
50104 PyObject * obj1 = 0 ;
50105 PyObject * obj2 = 0 ;
50106 PyObject * obj3 = 0 ;
50107 char * kwnames[] = {
50108 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50109 };
50110
50111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50113 if (!SWIG_IsOK(res1)) {
50114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50115 }
50116 arg1 = reinterpret_cast< wxSizer * >(argp1);
50117 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50118 if (!SWIG_IsOK(res2)) {
50119 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50120 }
50121 arg2 = reinterpret_cast< wxWindow * >(argp2);
50122 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50123 if (!SWIG_IsOK(res3)) {
50124 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50125 }
50126 arg3 = reinterpret_cast< wxWindow * >(argp3);
50127 if (obj3) {
50128 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50129 if (!SWIG_IsOK(ecode4)) {
50130 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50131 }
50132 arg4 = static_cast< bool >(val4);
50133 }
50134 {
50135 PyThreadState* __tstate = wxPyBeginAllowThreads();
50136 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50137 wxPyEndAllowThreads(__tstate);
50138 if (PyErr_Occurred()) SWIG_fail;
50139 }
50140 {
50141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50142 }
50143 return resultobj;
50144 fail:
50145 return NULL;
50146 }
50147
50148
50149 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50150 PyObject *resultobj = 0;
50151 wxSizer *arg1 = (wxSizer *) 0 ;
50152 wxSizer *arg2 = (wxSizer *) 0 ;
50153 wxSizer *arg3 = (wxSizer *) 0 ;
50154 bool arg4 = (bool) false ;
50155 bool result;
50156 void *argp1 = 0 ;
50157 int res1 = 0 ;
50158 void *argp2 = 0 ;
50159 int res2 = 0 ;
50160 void *argp3 = 0 ;
50161 int res3 = 0 ;
50162 bool val4 ;
50163 int ecode4 = 0 ;
50164 PyObject * obj0 = 0 ;
50165 PyObject * obj1 = 0 ;
50166 PyObject * obj2 = 0 ;
50167 PyObject * obj3 = 0 ;
50168 char * kwnames[] = {
50169 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50170 };
50171
50172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50174 if (!SWIG_IsOK(res1)) {
50175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50176 }
50177 arg1 = reinterpret_cast< wxSizer * >(argp1);
50178 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50179 if (!SWIG_IsOK(res2)) {
50180 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50181 }
50182 arg2 = reinterpret_cast< wxSizer * >(argp2);
50183 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50184 if (!SWIG_IsOK(res3)) {
50185 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50186 }
50187 arg3 = reinterpret_cast< wxSizer * >(argp3);
50188 if (obj3) {
50189 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50190 if (!SWIG_IsOK(ecode4)) {
50191 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50192 }
50193 arg4 = static_cast< bool >(val4);
50194 }
50195 {
50196 PyThreadState* __tstate = wxPyBeginAllowThreads();
50197 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50198 wxPyEndAllowThreads(__tstate);
50199 if (PyErr_Occurred()) SWIG_fail;
50200 }
50201 {
50202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50203 }
50204 return resultobj;
50205 fail:
50206 return NULL;
50207 }
50208
50209
50210 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50211 PyObject *resultobj = 0;
50212 wxSizer *arg1 = (wxSizer *) 0 ;
50213 size_t arg2 ;
50214 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50215 bool result;
50216 void *argp1 = 0 ;
50217 int res1 = 0 ;
50218 size_t val2 ;
50219 int ecode2 = 0 ;
50220 void *argp3 = 0 ;
50221 int res3 = 0 ;
50222 PyObject * obj0 = 0 ;
50223 PyObject * obj1 = 0 ;
50224 PyObject * obj2 = 0 ;
50225 char * kwnames[] = {
50226 (char *) "self",(char *) "index",(char *) "newitem", NULL
50227 };
50228
50229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50231 if (!SWIG_IsOK(res1)) {
50232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50233 }
50234 arg1 = reinterpret_cast< wxSizer * >(argp1);
50235 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50236 if (!SWIG_IsOK(ecode2)) {
50237 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50238 }
50239 arg2 = static_cast< size_t >(val2);
50240 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50241 if (!SWIG_IsOK(res3)) {
50242 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50243 }
50244 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50245 {
50246 PyThreadState* __tstate = wxPyBeginAllowThreads();
50247 result = (bool)(arg1)->Replace(arg2,arg3);
50248 wxPyEndAllowThreads(__tstate);
50249 if (PyErr_Occurred()) SWIG_fail;
50250 }
50251 {
50252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50253 }
50254 return resultobj;
50255 fail:
50256 return NULL;
50257 }
50258
50259
50260 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50261 PyObject *resultobj = 0;
50262 wxSizer *arg1 = (wxSizer *) 0 ;
50263 wxWindow *arg2 = (wxWindow *) 0 ;
50264 void *argp1 = 0 ;
50265 int res1 = 0 ;
50266 void *argp2 = 0 ;
50267 int res2 = 0 ;
50268 PyObject * obj0 = 0 ;
50269 PyObject * obj1 = 0 ;
50270 char * kwnames[] = {
50271 (char *) "self",(char *) "window", NULL
50272 };
50273
50274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50276 if (!SWIG_IsOK(res1)) {
50277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50278 }
50279 arg1 = reinterpret_cast< wxSizer * >(argp1);
50280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50281 if (!SWIG_IsOK(res2)) {
50282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50283 }
50284 arg2 = reinterpret_cast< wxWindow * >(argp2);
50285 {
50286 PyThreadState* __tstate = wxPyBeginAllowThreads();
50287 (arg1)->SetContainingWindow(arg2);
50288 wxPyEndAllowThreads(__tstate);
50289 if (PyErr_Occurred()) SWIG_fail;
50290 }
50291 resultobj = SWIG_Py_Void();
50292 return resultobj;
50293 fail:
50294 return NULL;
50295 }
50296
50297
50298 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50299 PyObject *resultobj = 0;
50300 wxSizer *arg1 = (wxSizer *) 0 ;
50301 wxWindow *result = 0 ;
50302 void *argp1 = 0 ;
50303 int res1 = 0 ;
50304 PyObject *swig_obj[1] ;
50305
50306 if (!args) SWIG_fail;
50307 swig_obj[0] = args;
50308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50309 if (!SWIG_IsOK(res1)) {
50310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50311 }
50312 arg1 = reinterpret_cast< wxSizer * >(argp1);
50313 {
50314 PyThreadState* __tstate = wxPyBeginAllowThreads();
50315 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50316 wxPyEndAllowThreads(__tstate);
50317 if (PyErr_Occurred()) SWIG_fail;
50318 }
50319 {
50320 resultobj = wxPyMake_wxObject(result, 0);
50321 }
50322 return resultobj;
50323 fail:
50324 return NULL;
50325 }
50326
50327
50328 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50329 PyObject *resultobj = 0;
50330 wxSizer *arg1 = (wxSizer *) 0 ;
50331 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50332 wxSizerItem *result = 0 ;
50333 void *argp1 = 0 ;
50334 int res1 = 0 ;
50335 int res2 = 0 ;
50336 PyObject * obj0 = 0 ;
50337 PyObject * obj1 = 0 ;
50338 char * kwnames[] = {
50339 (char *) "self",(char *) "item", NULL
50340 };
50341
50342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50344 if (!SWIG_IsOK(res1)) {
50345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50346 }
50347 arg1 = reinterpret_cast< wxSizer * >(argp1);
50348 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50349 if (!SWIG_IsOK(res2)) {
50350 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50351 }
50352 {
50353 PyThreadState* __tstate = wxPyBeginAllowThreads();
50354 result = (wxSizerItem *)(arg1)->Add(arg2);
50355 wxPyEndAllowThreads(__tstate);
50356 if (PyErr_Occurred()) SWIG_fail;
50357 }
50358 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50359 return resultobj;
50360 fail:
50361 return NULL;
50362 }
50363
50364
50365 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50366 PyObject *resultobj = 0;
50367 wxSizer *arg1 = (wxSizer *) 0 ;
50368 size_t arg2 ;
50369 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50370 wxSizerItem *result = 0 ;
50371 void *argp1 = 0 ;
50372 int res1 = 0 ;
50373 size_t val2 ;
50374 int ecode2 = 0 ;
50375 int res3 = 0 ;
50376 PyObject * obj0 = 0 ;
50377 PyObject * obj1 = 0 ;
50378 PyObject * obj2 = 0 ;
50379 char * kwnames[] = {
50380 (char *) "self",(char *) "index",(char *) "item", NULL
50381 };
50382
50383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50385 if (!SWIG_IsOK(res1)) {
50386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50387 }
50388 arg1 = reinterpret_cast< wxSizer * >(argp1);
50389 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50390 if (!SWIG_IsOK(ecode2)) {
50391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50392 }
50393 arg2 = static_cast< size_t >(val2);
50394 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50395 if (!SWIG_IsOK(res3)) {
50396 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50397 }
50398 {
50399 PyThreadState* __tstate = wxPyBeginAllowThreads();
50400 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50401 wxPyEndAllowThreads(__tstate);
50402 if (PyErr_Occurred()) SWIG_fail;
50403 }
50404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50405 return resultobj;
50406 fail:
50407 return NULL;
50408 }
50409
50410
50411 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50412 PyObject *resultobj = 0;
50413 wxSizer *arg1 = (wxSizer *) 0 ;
50414 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50415 wxSizerItem *result = 0 ;
50416 void *argp1 = 0 ;
50417 int res1 = 0 ;
50418 int res2 = 0 ;
50419 PyObject * obj0 = 0 ;
50420 PyObject * obj1 = 0 ;
50421 char * kwnames[] = {
50422 (char *) "self",(char *) "item", NULL
50423 };
50424
50425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50427 if (!SWIG_IsOK(res1)) {
50428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50429 }
50430 arg1 = reinterpret_cast< wxSizer * >(argp1);
50431 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50432 if (!SWIG_IsOK(res2)) {
50433 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50434 }
50435 {
50436 PyThreadState* __tstate = wxPyBeginAllowThreads();
50437 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50438 wxPyEndAllowThreads(__tstate);
50439 if (PyErr_Occurred()) SWIG_fail;
50440 }
50441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50442 return resultobj;
50443 fail:
50444 return NULL;
50445 }
50446
50447
50448 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50449 PyObject *resultobj = 0;
50450 wxSizer *arg1 = (wxSizer *) 0 ;
50451 int arg2 ;
50452 int arg3 ;
50453 int arg4 ;
50454 int arg5 ;
50455 void *argp1 = 0 ;
50456 int res1 = 0 ;
50457 int val2 ;
50458 int ecode2 = 0 ;
50459 int val3 ;
50460 int ecode3 = 0 ;
50461 int val4 ;
50462 int ecode4 = 0 ;
50463 int val5 ;
50464 int ecode5 = 0 ;
50465 PyObject * obj0 = 0 ;
50466 PyObject * obj1 = 0 ;
50467 PyObject * obj2 = 0 ;
50468 PyObject * obj3 = 0 ;
50469 PyObject * obj4 = 0 ;
50470 char * kwnames[] = {
50471 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50472 };
50473
50474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50476 if (!SWIG_IsOK(res1)) {
50477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50478 }
50479 arg1 = reinterpret_cast< wxSizer * >(argp1);
50480 ecode2 = SWIG_AsVal_int(obj1, &val2);
50481 if (!SWIG_IsOK(ecode2)) {
50482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50483 }
50484 arg2 = static_cast< int >(val2);
50485 ecode3 = SWIG_AsVal_int(obj2, &val3);
50486 if (!SWIG_IsOK(ecode3)) {
50487 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50488 }
50489 arg3 = static_cast< int >(val3);
50490 ecode4 = SWIG_AsVal_int(obj3, &val4);
50491 if (!SWIG_IsOK(ecode4)) {
50492 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50493 }
50494 arg4 = static_cast< int >(val4);
50495 ecode5 = SWIG_AsVal_int(obj4, &val5);
50496 if (!SWIG_IsOK(ecode5)) {
50497 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50498 }
50499 arg5 = static_cast< int >(val5);
50500 {
50501 PyThreadState* __tstate = wxPyBeginAllowThreads();
50502 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50503 wxPyEndAllowThreads(__tstate);
50504 if (PyErr_Occurred()) SWIG_fail;
50505 }
50506 resultobj = SWIG_Py_Void();
50507 return resultobj;
50508 fail:
50509 return NULL;
50510 }
50511
50512
50513 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50514 PyObject *resultobj = 0;
50515 wxSizer *arg1 = (wxSizer *) 0 ;
50516 wxSize *arg2 = 0 ;
50517 void *argp1 = 0 ;
50518 int res1 = 0 ;
50519 wxSize temp2 ;
50520 PyObject * obj0 = 0 ;
50521 PyObject * obj1 = 0 ;
50522 char * kwnames[] = {
50523 (char *) "self",(char *) "size", NULL
50524 };
50525
50526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50528 if (!SWIG_IsOK(res1)) {
50529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50530 }
50531 arg1 = reinterpret_cast< wxSizer * >(argp1);
50532 {
50533 arg2 = &temp2;
50534 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50535 }
50536 {
50537 PyThreadState* __tstate = wxPyBeginAllowThreads();
50538 (arg1)->SetMinSize((wxSize const &)*arg2);
50539 wxPyEndAllowThreads(__tstate);
50540 if (PyErr_Occurred()) SWIG_fail;
50541 }
50542 resultobj = SWIG_Py_Void();
50543 return resultobj;
50544 fail:
50545 return NULL;
50546 }
50547
50548
50549 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50550 PyObject *resultobj = 0;
50551 wxSizer *arg1 = (wxSizer *) 0 ;
50552 wxSize result;
50553 void *argp1 = 0 ;
50554 int res1 = 0 ;
50555 PyObject *swig_obj[1] ;
50556
50557 if (!args) SWIG_fail;
50558 swig_obj[0] = args;
50559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50560 if (!SWIG_IsOK(res1)) {
50561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50562 }
50563 arg1 = reinterpret_cast< wxSizer * >(argp1);
50564 {
50565 PyThreadState* __tstate = wxPyBeginAllowThreads();
50566 result = (arg1)->GetSize();
50567 wxPyEndAllowThreads(__tstate);
50568 if (PyErr_Occurred()) SWIG_fail;
50569 }
50570 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50571 return resultobj;
50572 fail:
50573 return NULL;
50574 }
50575
50576
50577 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50578 PyObject *resultobj = 0;
50579 wxSizer *arg1 = (wxSizer *) 0 ;
50580 wxPoint result;
50581 void *argp1 = 0 ;
50582 int res1 = 0 ;
50583 PyObject *swig_obj[1] ;
50584
50585 if (!args) SWIG_fail;
50586 swig_obj[0] = args;
50587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50588 if (!SWIG_IsOK(res1)) {
50589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50590 }
50591 arg1 = reinterpret_cast< wxSizer * >(argp1);
50592 {
50593 PyThreadState* __tstate = wxPyBeginAllowThreads();
50594 result = (arg1)->GetPosition();
50595 wxPyEndAllowThreads(__tstate);
50596 if (PyErr_Occurred()) SWIG_fail;
50597 }
50598 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50599 return resultobj;
50600 fail:
50601 return NULL;
50602 }
50603
50604
50605 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50606 PyObject *resultobj = 0;
50607 wxSizer *arg1 = (wxSizer *) 0 ;
50608 wxSize result;
50609 void *argp1 = 0 ;
50610 int res1 = 0 ;
50611 PyObject *swig_obj[1] ;
50612
50613 if (!args) SWIG_fail;
50614 swig_obj[0] = args;
50615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50616 if (!SWIG_IsOK(res1)) {
50617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50618 }
50619 arg1 = reinterpret_cast< wxSizer * >(argp1);
50620 {
50621 PyThreadState* __tstate = wxPyBeginAllowThreads();
50622 result = (arg1)->GetMinSize();
50623 wxPyEndAllowThreads(__tstate);
50624 if (PyErr_Occurred()) SWIG_fail;
50625 }
50626 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50627 return resultobj;
50628 fail:
50629 return NULL;
50630 }
50631
50632
50633 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50634 PyObject *resultobj = 0;
50635 wxSizer *arg1 = (wxSizer *) 0 ;
50636 void *argp1 = 0 ;
50637 int res1 = 0 ;
50638 PyObject *swig_obj[1] ;
50639
50640 if (!args) SWIG_fail;
50641 swig_obj[0] = args;
50642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50643 if (!SWIG_IsOK(res1)) {
50644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50645 }
50646 arg1 = reinterpret_cast< wxSizer * >(argp1);
50647 {
50648 PyThreadState* __tstate = wxPyBeginAllowThreads();
50649 (arg1)->RecalcSizes();
50650 wxPyEndAllowThreads(__tstate);
50651 if (PyErr_Occurred()) SWIG_fail;
50652 }
50653 resultobj = SWIG_Py_Void();
50654 return resultobj;
50655 fail:
50656 return NULL;
50657 }
50658
50659
50660 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50661 PyObject *resultobj = 0;
50662 wxSizer *arg1 = (wxSizer *) 0 ;
50663 wxSize result;
50664 void *argp1 = 0 ;
50665 int res1 = 0 ;
50666 PyObject *swig_obj[1] ;
50667
50668 if (!args) SWIG_fail;
50669 swig_obj[0] = args;
50670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50671 if (!SWIG_IsOK(res1)) {
50672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50673 }
50674 arg1 = reinterpret_cast< wxSizer * >(argp1);
50675 {
50676 PyThreadState* __tstate = wxPyBeginAllowThreads();
50677 result = (arg1)->CalcMin();
50678 wxPyEndAllowThreads(__tstate);
50679 if (PyErr_Occurred()) SWIG_fail;
50680 }
50681 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50682 return resultobj;
50683 fail:
50684 return NULL;
50685 }
50686
50687
50688 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50689 PyObject *resultobj = 0;
50690 wxSizer *arg1 = (wxSizer *) 0 ;
50691 void *argp1 = 0 ;
50692 int res1 = 0 ;
50693 PyObject *swig_obj[1] ;
50694
50695 if (!args) SWIG_fail;
50696 swig_obj[0] = args;
50697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50698 if (!SWIG_IsOK(res1)) {
50699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50700 }
50701 arg1 = reinterpret_cast< wxSizer * >(argp1);
50702 {
50703 PyThreadState* __tstate = wxPyBeginAllowThreads();
50704 (arg1)->Layout();
50705 wxPyEndAllowThreads(__tstate);
50706 if (PyErr_Occurred()) SWIG_fail;
50707 }
50708 resultobj = SWIG_Py_Void();
50709 return resultobj;
50710 fail:
50711 return NULL;
50712 }
50713
50714
50715 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50716 PyObject *resultobj = 0;
50717 wxSizer *arg1 = (wxSizer *) 0 ;
50718 wxWindow *arg2 = (wxWindow *) 0 ;
50719 wxSize result;
50720 void *argp1 = 0 ;
50721 int res1 = 0 ;
50722 void *argp2 = 0 ;
50723 int res2 = 0 ;
50724 PyObject * obj0 = 0 ;
50725 PyObject * obj1 = 0 ;
50726 char * kwnames[] = {
50727 (char *) "self",(char *) "window", NULL
50728 };
50729
50730 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50731 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50732 if (!SWIG_IsOK(res1)) {
50733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50734 }
50735 arg1 = reinterpret_cast< wxSizer * >(argp1);
50736 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50737 if (!SWIG_IsOK(res2)) {
50738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50739 }
50740 arg2 = reinterpret_cast< wxWindow * >(argp2);
50741 {
50742 PyThreadState* __tstate = wxPyBeginAllowThreads();
50743 result = (arg1)->Fit(arg2);
50744 wxPyEndAllowThreads(__tstate);
50745 if (PyErr_Occurred()) SWIG_fail;
50746 }
50747 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50748 return resultobj;
50749 fail:
50750 return NULL;
50751 }
50752
50753
50754 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50755 PyObject *resultobj = 0;
50756 wxSizer *arg1 = (wxSizer *) 0 ;
50757 wxWindow *arg2 = (wxWindow *) 0 ;
50758 void *argp1 = 0 ;
50759 int res1 = 0 ;
50760 void *argp2 = 0 ;
50761 int res2 = 0 ;
50762 PyObject * obj0 = 0 ;
50763 PyObject * obj1 = 0 ;
50764 char * kwnames[] = {
50765 (char *) "self",(char *) "window", NULL
50766 };
50767
50768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50770 if (!SWIG_IsOK(res1)) {
50771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50772 }
50773 arg1 = reinterpret_cast< wxSizer * >(argp1);
50774 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50775 if (!SWIG_IsOK(res2)) {
50776 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50777 }
50778 arg2 = reinterpret_cast< wxWindow * >(argp2);
50779 {
50780 PyThreadState* __tstate = wxPyBeginAllowThreads();
50781 (arg1)->FitInside(arg2);
50782 wxPyEndAllowThreads(__tstate);
50783 if (PyErr_Occurred()) SWIG_fail;
50784 }
50785 resultobj = SWIG_Py_Void();
50786 return resultobj;
50787 fail:
50788 return NULL;
50789 }
50790
50791
50792 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50793 PyObject *resultobj = 0;
50794 wxSizer *arg1 = (wxSizer *) 0 ;
50795 wxWindow *arg2 = (wxWindow *) 0 ;
50796 void *argp1 = 0 ;
50797 int res1 = 0 ;
50798 void *argp2 = 0 ;
50799 int res2 = 0 ;
50800 PyObject * obj0 = 0 ;
50801 PyObject * obj1 = 0 ;
50802 char * kwnames[] = {
50803 (char *) "self",(char *) "window", NULL
50804 };
50805
50806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50808 if (!SWIG_IsOK(res1)) {
50809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50810 }
50811 arg1 = reinterpret_cast< wxSizer * >(argp1);
50812 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50813 if (!SWIG_IsOK(res2)) {
50814 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50815 }
50816 arg2 = reinterpret_cast< wxWindow * >(argp2);
50817 {
50818 PyThreadState* __tstate = wxPyBeginAllowThreads();
50819 (arg1)->SetSizeHints(arg2);
50820 wxPyEndAllowThreads(__tstate);
50821 if (PyErr_Occurred()) SWIG_fail;
50822 }
50823 resultobj = SWIG_Py_Void();
50824 return resultobj;
50825 fail:
50826 return NULL;
50827 }
50828
50829
50830 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50831 PyObject *resultobj = 0;
50832 wxSizer *arg1 = (wxSizer *) 0 ;
50833 wxWindow *arg2 = (wxWindow *) 0 ;
50834 void *argp1 = 0 ;
50835 int res1 = 0 ;
50836 void *argp2 = 0 ;
50837 int res2 = 0 ;
50838 PyObject * obj0 = 0 ;
50839 PyObject * obj1 = 0 ;
50840 char * kwnames[] = {
50841 (char *) "self",(char *) "window", NULL
50842 };
50843
50844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
50845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50846 if (!SWIG_IsOK(res1)) {
50847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
50848 }
50849 arg1 = reinterpret_cast< wxSizer * >(argp1);
50850 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50851 if (!SWIG_IsOK(res2)) {
50852 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
50853 }
50854 arg2 = reinterpret_cast< wxWindow * >(argp2);
50855 {
50856 PyThreadState* __tstate = wxPyBeginAllowThreads();
50857 (arg1)->SetVirtualSizeHints(arg2);
50858 wxPyEndAllowThreads(__tstate);
50859 if (PyErr_Occurred()) SWIG_fail;
50860 }
50861 resultobj = SWIG_Py_Void();
50862 return resultobj;
50863 fail:
50864 return NULL;
50865 }
50866
50867
50868 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50869 PyObject *resultobj = 0;
50870 wxSizer *arg1 = (wxSizer *) 0 ;
50871 bool arg2 = (bool) false ;
50872 void *argp1 = 0 ;
50873 int res1 = 0 ;
50874 bool val2 ;
50875 int ecode2 = 0 ;
50876 PyObject * obj0 = 0 ;
50877 PyObject * obj1 = 0 ;
50878 char * kwnames[] = {
50879 (char *) "self",(char *) "deleteWindows", NULL
50880 };
50881
50882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
50883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50884 if (!SWIG_IsOK(res1)) {
50885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
50886 }
50887 arg1 = reinterpret_cast< wxSizer * >(argp1);
50888 if (obj1) {
50889 ecode2 = SWIG_AsVal_bool(obj1, &val2);
50890 if (!SWIG_IsOK(ecode2)) {
50891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
50892 }
50893 arg2 = static_cast< bool >(val2);
50894 }
50895 {
50896 PyThreadState* __tstate = wxPyBeginAllowThreads();
50897 (arg1)->Clear(arg2);
50898 wxPyEndAllowThreads(__tstate);
50899 if (PyErr_Occurred()) SWIG_fail;
50900 }
50901 resultobj = SWIG_Py_Void();
50902 return resultobj;
50903 fail:
50904 return NULL;
50905 }
50906
50907
50908 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50909 PyObject *resultobj = 0;
50910 wxSizer *arg1 = (wxSizer *) 0 ;
50911 void *argp1 = 0 ;
50912 int res1 = 0 ;
50913 PyObject *swig_obj[1] ;
50914
50915 if (!args) SWIG_fail;
50916 swig_obj[0] = args;
50917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50918 if (!SWIG_IsOK(res1)) {
50919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
50920 }
50921 arg1 = reinterpret_cast< wxSizer * >(argp1);
50922 {
50923 PyThreadState* __tstate = wxPyBeginAllowThreads();
50924 (arg1)->DeleteWindows();
50925 wxPyEndAllowThreads(__tstate);
50926 if (PyErr_Occurred()) SWIG_fail;
50927 }
50928 resultobj = SWIG_Py_Void();
50929 return resultobj;
50930 fail:
50931 return NULL;
50932 }
50933
50934
50935 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50936 PyObject *resultobj = 0;
50937 wxSizer *arg1 = (wxSizer *) 0 ;
50938 PyObject *result = 0 ;
50939 void *argp1 = 0 ;
50940 int res1 = 0 ;
50941 PyObject *swig_obj[1] ;
50942
50943 if (!args) SWIG_fail;
50944 swig_obj[0] = args;
50945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50946 if (!SWIG_IsOK(res1)) {
50947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
50948 }
50949 arg1 = reinterpret_cast< wxSizer * >(argp1);
50950 {
50951 PyThreadState* __tstate = wxPyBeginAllowThreads();
50952 result = (PyObject *)wxSizer_GetChildren(arg1);
50953 wxPyEndAllowThreads(__tstate);
50954 if (PyErr_Occurred()) SWIG_fail;
50955 }
50956 resultobj = result;
50957 return resultobj;
50958 fail:
50959 return NULL;
50960 }
50961
50962
50963 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50964 PyObject *resultobj = 0;
50965 wxSizer *arg1 = (wxSizer *) 0 ;
50966 PyObject *arg2 = (PyObject *) 0 ;
50967 bool arg3 = (bool) true ;
50968 bool arg4 = (bool) false ;
50969 bool result;
50970 void *argp1 = 0 ;
50971 int res1 = 0 ;
50972 bool val3 ;
50973 int ecode3 = 0 ;
50974 bool val4 ;
50975 int ecode4 = 0 ;
50976 PyObject * obj0 = 0 ;
50977 PyObject * obj1 = 0 ;
50978 PyObject * obj2 = 0 ;
50979 PyObject * obj3 = 0 ;
50980 char * kwnames[] = {
50981 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
50982 };
50983
50984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50986 if (!SWIG_IsOK(res1)) {
50987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
50988 }
50989 arg1 = reinterpret_cast< wxSizer * >(argp1);
50990 arg2 = obj1;
50991 if (obj2) {
50992 ecode3 = SWIG_AsVal_bool(obj2, &val3);
50993 if (!SWIG_IsOK(ecode3)) {
50994 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
50995 }
50996 arg3 = static_cast< bool >(val3);
50997 }
50998 if (obj3) {
50999 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51000 if (!SWIG_IsOK(ecode4)) {
51001 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51002 }
51003 arg4 = static_cast< bool >(val4);
51004 }
51005 {
51006 PyThreadState* __tstate = wxPyBeginAllowThreads();
51007 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51008 wxPyEndAllowThreads(__tstate);
51009 if (PyErr_Occurred()) SWIG_fail;
51010 }
51011 {
51012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51013 }
51014 return resultobj;
51015 fail:
51016 return NULL;
51017 }
51018
51019
51020 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51021 PyObject *resultobj = 0;
51022 wxSizer *arg1 = (wxSizer *) 0 ;
51023 PyObject *arg2 = (PyObject *) 0 ;
51024 bool result;
51025 void *argp1 = 0 ;
51026 int res1 = 0 ;
51027 PyObject * obj0 = 0 ;
51028 PyObject * obj1 = 0 ;
51029 char * kwnames[] = {
51030 (char *) "self",(char *) "item", NULL
51031 };
51032
51033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51035 if (!SWIG_IsOK(res1)) {
51036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51037 }
51038 arg1 = reinterpret_cast< wxSizer * >(argp1);
51039 arg2 = obj1;
51040 {
51041 PyThreadState* __tstate = wxPyBeginAllowThreads();
51042 result = (bool)wxSizer_IsShown(arg1,arg2);
51043 wxPyEndAllowThreads(__tstate);
51044 if (PyErr_Occurred()) SWIG_fail;
51045 }
51046 {
51047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51048 }
51049 return resultobj;
51050 fail:
51051 return NULL;
51052 }
51053
51054
51055 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51056 PyObject *resultobj = 0;
51057 wxSizer *arg1 = (wxSizer *) 0 ;
51058 bool arg2 ;
51059 void *argp1 = 0 ;
51060 int res1 = 0 ;
51061 bool val2 ;
51062 int ecode2 = 0 ;
51063 PyObject * obj0 = 0 ;
51064 PyObject * obj1 = 0 ;
51065 char * kwnames[] = {
51066 (char *) "self",(char *) "show", NULL
51067 };
51068
51069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51071 if (!SWIG_IsOK(res1)) {
51072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51073 }
51074 arg1 = reinterpret_cast< wxSizer * >(argp1);
51075 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51076 if (!SWIG_IsOK(ecode2)) {
51077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51078 }
51079 arg2 = static_cast< bool >(val2);
51080 {
51081 PyThreadState* __tstate = wxPyBeginAllowThreads();
51082 (arg1)->ShowItems(arg2);
51083 wxPyEndAllowThreads(__tstate);
51084 if (PyErr_Occurred()) SWIG_fail;
51085 }
51086 resultobj = SWIG_Py_Void();
51087 return resultobj;
51088 fail:
51089 return NULL;
51090 }
51091
51092
51093 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51094 PyObject *obj;
51095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51096 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51097 return SWIG_Py_Void();
51098 }
51099
51100 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51101 PyObject *resultobj = 0;
51102 wxPySizer *result = 0 ;
51103
51104 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51105 {
51106 PyThreadState* __tstate = wxPyBeginAllowThreads();
51107 result = (wxPySizer *)new wxPySizer();
51108 wxPyEndAllowThreads(__tstate);
51109 if (PyErr_Occurred()) SWIG_fail;
51110 }
51111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51112 return resultobj;
51113 fail:
51114 return NULL;
51115 }
51116
51117
51118 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51119 PyObject *resultobj = 0;
51120 wxPySizer *arg1 = (wxPySizer *) 0 ;
51121 PyObject *arg2 = (PyObject *) 0 ;
51122 PyObject *arg3 = (PyObject *) 0 ;
51123 void *argp1 = 0 ;
51124 int res1 = 0 ;
51125 PyObject * obj0 = 0 ;
51126 PyObject * obj1 = 0 ;
51127 PyObject * obj2 = 0 ;
51128 char * kwnames[] = {
51129 (char *) "self",(char *) "self",(char *) "_class", NULL
51130 };
51131
51132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51134 if (!SWIG_IsOK(res1)) {
51135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51136 }
51137 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51138 arg2 = obj1;
51139 arg3 = obj2;
51140 {
51141 PyThreadState* __tstate = wxPyBeginAllowThreads();
51142 (arg1)->_setCallbackInfo(arg2,arg3);
51143 wxPyEndAllowThreads(__tstate);
51144 if (PyErr_Occurred()) SWIG_fail;
51145 }
51146 resultobj = SWIG_Py_Void();
51147 return resultobj;
51148 fail:
51149 return NULL;
51150 }
51151
51152
51153 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51154 PyObject *obj;
51155 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51156 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51157 return SWIG_Py_Void();
51158 }
51159
51160 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51161 return SWIG_Python_InitShadowInstance(args);
51162 }
51163
51164 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51165 PyObject *resultobj = 0;
51166 int arg1 = (int) wxHORIZONTAL ;
51167 wxBoxSizer *result = 0 ;
51168 int val1 ;
51169 int ecode1 = 0 ;
51170 PyObject * obj0 = 0 ;
51171 char * kwnames[] = {
51172 (char *) "orient", NULL
51173 };
51174
51175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51176 if (obj0) {
51177 ecode1 = SWIG_AsVal_int(obj0, &val1);
51178 if (!SWIG_IsOK(ecode1)) {
51179 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51180 }
51181 arg1 = static_cast< int >(val1);
51182 }
51183 {
51184 PyThreadState* __tstate = wxPyBeginAllowThreads();
51185 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51186 wxPyEndAllowThreads(__tstate);
51187 if (PyErr_Occurred()) SWIG_fail;
51188 }
51189 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51190 return resultobj;
51191 fail:
51192 return NULL;
51193 }
51194
51195
51196 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51197 PyObject *resultobj = 0;
51198 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51199 int result;
51200 void *argp1 = 0 ;
51201 int res1 = 0 ;
51202 PyObject *swig_obj[1] ;
51203
51204 if (!args) SWIG_fail;
51205 swig_obj[0] = args;
51206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51207 if (!SWIG_IsOK(res1)) {
51208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51209 }
51210 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51211 {
51212 PyThreadState* __tstate = wxPyBeginAllowThreads();
51213 result = (int)(arg1)->GetOrientation();
51214 wxPyEndAllowThreads(__tstate);
51215 if (PyErr_Occurred()) SWIG_fail;
51216 }
51217 resultobj = SWIG_From_int(static_cast< int >(result));
51218 return resultobj;
51219 fail:
51220 return NULL;
51221 }
51222
51223
51224 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51225 PyObject *resultobj = 0;
51226 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51227 int arg2 ;
51228 void *argp1 = 0 ;
51229 int res1 = 0 ;
51230 int val2 ;
51231 int ecode2 = 0 ;
51232 PyObject * obj0 = 0 ;
51233 PyObject * obj1 = 0 ;
51234 char * kwnames[] = {
51235 (char *) "self",(char *) "orient", NULL
51236 };
51237
51238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51240 if (!SWIG_IsOK(res1)) {
51241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51242 }
51243 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51244 ecode2 = SWIG_AsVal_int(obj1, &val2);
51245 if (!SWIG_IsOK(ecode2)) {
51246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51247 }
51248 arg2 = static_cast< int >(val2);
51249 {
51250 PyThreadState* __tstate = wxPyBeginAllowThreads();
51251 (arg1)->SetOrientation(arg2);
51252 wxPyEndAllowThreads(__tstate);
51253 if (PyErr_Occurred()) SWIG_fail;
51254 }
51255 resultobj = SWIG_Py_Void();
51256 return resultobj;
51257 fail:
51258 return NULL;
51259 }
51260
51261
51262 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51263 PyObject *obj;
51264 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51265 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51266 return SWIG_Py_Void();
51267 }
51268
51269 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51270 return SWIG_Python_InitShadowInstance(args);
51271 }
51272
51273 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51274 PyObject *resultobj = 0;
51275 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51276 int arg2 = (int) wxHORIZONTAL ;
51277 wxStaticBoxSizer *result = 0 ;
51278 void *argp1 = 0 ;
51279 int res1 = 0 ;
51280 int val2 ;
51281 int ecode2 = 0 ;
51282 PyObject * obj0 = 0 ;
51283 PyObject * obj1 = 0 ;
51284 char * kwnames[] = {
51285 (char *) "box",(char *) "orient", NULL
51286 };
51287
51288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51290 if (!SWIG_IsOK(res1)) {
51291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51292 }
51293 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51294 if (obj1) {
51295 ecode2 = SWIG_AsVal_int(obj1, &val2);
51296 if (!SWIG_IsOK(ecode2)) {
51297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51298 }
51299 arg2 = static_cast< int >(val2);
51300 }
51301 {
51302 PyThreadState* __tstate = wxPyBeginAllowThreads();
51303 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51304 wxPyEndAllowThreads(__tstate);
51305 if (PyErr_Occurred()) SWIG_fail;
51306 }
51307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51308 return resultobj;
51309 fail:
51310 return NULL;
51311 }
51312
51313
51314 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51315 PyObject *resultobj = 0;
51316 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51317 wxStaticBox *result = 0 ;
51318 void *argp1 = 0 ;
51319 int res1 = 0 ;
51320 PyObject *swig_obj[1] ;
51321
51322 if (!args) SWIG_fail;
51323 swig_obj[0] = args;
51324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51325 if (!SWIG_IsOK(res1)) {
51326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51327 }
51328 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51329 {
51330 PyThreadState* __tstate = wxPyBeginAllowThreads();
51331 result = (wxStaticBox *)(arg1)->GetStaticBox();
51332 wxPyEndAllowThreads(__tstate);
51333 if (PyErr_Occurred()) SWIG_fail;
51334 }
51335 {
51336 resultobj = wxPyMake_wxObject(result, (bool)0);
51337 }
51338 return resultobj;
51339 fail:
51340 return NULL;
51341 }
51342
51343
51344 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51345 PyObject *obj;
51346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51347 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51348 return SWIG_Py_Void();
51349 }
51350
51351 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51352 return SWIG_Python_InitShadowInstance(args);
51353 }
51354
51355 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51356 PyObject *resultobj = 0;
51357 int arg1 = (int) 1 ;
51358 int arg2 = (int) 0 ;
51359 int arg3 = (int) 0 ;
51360 int arg4 = (int) 0 ;
51361 wxGridSizer *result = 0 ;
51362 int val1 ;
51363 int ecode1 = 0 ;
51364 int val2 ;
51365 int ecode2 = 0 ;
51366 int val3 ;
51367 int ecode3 = 0 ;
51368 int val4 ;
51369 int ecode4 = 0 ;
51370 PyObject * obj0 = 0 ;
51371 PyObject * obj1 = 0 ;
51372 PyObject * obj2 = 0 ;
51373 PyObject * obj3 = 0 ;
51374 char * kwnames[] = {
51375 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51376 };
51377
51378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51379 if (obj0) {
51380 ecode1 = SWIG_AsVal_int(obj0, &val1);
51381 if (!SWIG_IsOK(ecode1)) {
51382 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51383 }
51384 arg1 = static_cast< int >(val1);
51385 }
51386 if (obj1) {
51387 ecode2 = SWIG_AsVal_int(obj1, &val2);
51388 if (!SWIG_IsOK(ecode2)) {
51389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51390 }
51391 arg2 = static_cast< int >(val2);
51392 }
51393 if (obj2) {
51394 ecode3 = SWIG_AsVal_int(obj2, &val3);
51395 if (!SWIG_IsOK(ecode3)) {
51396 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51397 }
51398 arg3 = static_cast< int >(val3);
51399 }
51400 if (obj3) {
51401 ecode4 = SWIG_AsVal_int(obj3, &val4);
51402 if (!SWIG_IsOK(ecode4)) {
51403 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51404 }
51405 arg4 = static_cast< int >(val4);
51406 }
51407 {
51408 PyThreadState* __tstate = wxPyBeginAllowThreads();
51409 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51410 wxPyEndAllowThreads(__tstate);
51411 if (PyErr_Occurred()) SWIG_fail;
51412 }
51413 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51414 return resultobj;
51415 fail:
51416 return NULL;
51417 }
51418
51419
51420 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51421 PyObject *resultobj = 0;
51422 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51423 int arg2 ;
51424 void *argp1 = 0 ;
51425 int res1 = 0 ;
51426 int val2 ;
51427 int ecode2 = 0 ;
51428 PyObject * obj0 = 0 ;
51429 PyObject * obj1 = 0 ;
51430 char * kwnames[] = {
51431 (char *) "self",(char *) "cols", NULL
51432 };
51433
51434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51436 if (!SWIG_IsOK(res1)) {
51437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51438 }
51439 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51440 ecode2 = SWIG_AsVal_int(obj1, &val2);
51441 if (!SWIG_IsOK(ecode2)) {
51442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51443 }
51444 arg2 = static_cast< int >(val2);
51445 {
51446 PyThreadState* __tstate = wxPyBeginAllowThreads();
51447 (arg1)->SetCols(arg2);
51448 wxPyEndAllowThreads(__tstate);
51449 if (PyErr_Occurred()) SWIG_fail;
51450 }
51451 resultobj = SWIG_Py_Void();
51452 return resultobj;
51453 fail:
51454 return NULL;
51455 }
51456
51457
51458 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51459 PyObject *resultobj = 0;
51460 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51461 int arg2 ;
51462 void *argp1 = 0 ;
51463 int res1 = 0 ;
51464 int val2 ;
51465 int ecode2 = 0 ;
51466 PyObject * obj0 = 0 ;
51467 PyObject * obj1 = 0 ;
51468 char * kwnames[] = {
51469 (char *) "self",(char *) "rows", NULL
51470 };
51471
51472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51474 if (!SWIG_IsOK(res1)) {
51475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51476 }
51477 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51478 ecode2 = SWIG_AsVal_int(obj1, &val2);
51479 if (!SWIG_IsOK(ecode2)) {
51480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51481 }
51482 arg2 = static_cast< int >(val2);
51483 {
51484 PyThreadState* __tstate = wxPyBeginAllowThreads();
51485 (arg1)->SetRows(arg2);
51486 wxPyEndAllowThreads(__tstate);
51487 if (PyErr_Occurred()) SWIG_fail;
51488 }
51489 resultobj = SWIG_Py_Void();
51490 return resultobj;
51491 fail:
51492 return NULL;
51493 }
51494
51495
51496 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51497 PyObject *resultobj = 0;
51498 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51499 int arg2 ;
51500 void *argp1 = 0 ;
51501 int res1 = 0 ;
51502 int val2 ;
51503 int ecode2 = 0 ;
51504 PyObject * obj0 = 0 ;
51505 PyObject * obj1 = 0 ;
51506 char * kwnames[] = {
51507 (char *) "self",(char *) "gap", NULL
51508 };
51509
51510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51512 if (!SWIG_IsOK(res1)) {
51513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51514 }
51515 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51516 ecode2 = SWIG_AsVal_int(obj1, &val2);
51517 if (!SWIG_IsOK(ecode2)) {
51518 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51519 }
51520 arg2 = static_cast< int >(val2);
51521 {
51522 PyThreadState* __tstate = wxPyBeginAllowThreads();
51523 (arg1)->SetVGap(arg2);
51524 wxPyEndAllowThreads(__tstate);
51525 if (PyErr_Occurred()) SWIG_fail;
51526 }
51527 resultobj = SWIG_Py_Void();
51528 return resultobj;
51529 fail:
51530 return NULL;
51531 }
51532
51533
51534 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51535 PyObject *resultobj = 0;
51536 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51537 int arg2 ;
51538 void *argp1 = 0 ;
51539 int res1 = 0 ;
51540 int val2 ;
51541 int ecode2 = 0 ;
51542 PyObject * obj0 = 0 ;
51543 PyObject * obj1 = 0 ;
51544 char * kwnames[] = {
51545 (char *) "self",(char *) "gap", NULL
51546 };
51547
51548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51550 if (!SWIG_IsOK(res1)) {
51551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51552 }
51553 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51554 ecode2 = SWIG_AsVal_int(obj1, &val2);
51555 if (!SWIG_IsOK(ecode2)) {
51556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51557 }
51558 arg2 = static_cast< int >(val2);
51559 {
51560 PyThreadState* __tstate = wxPyBeginAllowThreads();
51561 (arg1)->SetHGap(arg2);
51562 wxPyEndAllowThreads(__tstate);
51563 if (PyErr_Occurred()) SWIG_fail;
51564 }
51565 resultobj = SWIG_Py_Void();
51566 return resultobj;
51567 fail:
51568 return NULL;
51569 }
51570
51571
51572 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51573 PyObject *resultobj = 0;
51574 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51575 int result;
51576 void *argp1 = 0 ;
51577 int res1 = 0 ;
51578 PyObject *swig_obj[1] ;
51579
51580 if (!args) SWIG_fail;
51581 swig_obj[0] = args;
51582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51583 if (!SWIG_IsOK(res1)) {
51584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51585 }
51586 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51587 {
51588 PyThreadState* __tstate = wxPyBeginAllowThreads();
51589 result = (int)(arg1)->GetCols();
51590 wxPyEndAllowThreads(__tstate);
51591 if (PyErr_Occurred()) SWIG_fail;
51592 }
51593 resultobj = SWIG_From_int(static_cast< int >(result));
51594 return resultobj;
51595 fail:
51596 return NULL;
51597 }
51598
51599
51600 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51601 PyObject *resultobj = 0;
51602 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51603 int result;
51604 void *argp1 = 0 ;
51605 int res1 = 0 ;
51606 PyObject *swig_obj[1] ;
51607
51608 if (!args) SWIG_fail;
51609 swig_obj[0] = args;
51610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51611 if (!SWIG_IsOK(res1)) {
51612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51613 }
51614 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51615 {
51616 PyThreadState* __tstate = wxPyBeginAllowThreads();
51617 result = (int)(arg1)->GetRows();
51618 wxPyEndAllowThreads(__tstate);
51619 if (PyErr_Occurred()) SWIG_fail;
51620 }
51621 resultobj = SWIG_From_int(static_cast< int >(result));
51622 return resultobj;
51623 fail:
51624 return NULL;
51625 }
51626
51627
51628 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51629 PyObject *resultobj = 0;
51630 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51631 int result;
51632 void *argp1 = 0 ;
51633 int res1 = 0 ;
51634 PyObject *swig_obj[1] ;
51635
51636 if (!args) SWIG_fail;
51637 swig_obj[0] = args;
51638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51639 if (!SWIG_IsOK(res1)) {
51640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51641 }
51642 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51643 {
51644 PyThreadState* __tstate = wxPyBeginAllowThreads();
51645 result = (int)(arg1)->GetVGap();
51646 wxPyEndAllowThreads(__tstate);
51647 if (PyErr_Occurred()) SWIG_fail;
51648 }
51649 resultobj = SWIG_From_int(static_cast< int >(result));
51650 return resultobj;
51651 fail:
51652 return NULL;
51653 }
51654
51655
51656 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51657 PyObject *resultobj = 0;
51658 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51659 int result;
51660 void *argp1 = 0 ;
51661 int res1 = 0 ;
51662 PyObject *swig_obj[1] ;
51663
51664 if (!args) SWIG_fail;
51665 swig_obj[0] = args;
51666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51667 if (!SWIG_IsOK(res1)) {
51668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51669 }
51670 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51671 {
51672 PyThreadState* __tstate = wxPyBeginAllowThreads();
51673 result = (int)(arg1)->GetHGap();
51674 wxPyEndAllowThreads(__tstate);
51675 if (PyErr_Occurred()) SWIG_fail;
51676 }
51677 resultobj = SWIG_From_int(static_cast< int >(result));
51678 return resultobj;
51679 fail:
51680 return NULL;
51681 }
51682
51683
51684 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51685 PyObject *obj;
51686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51687 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51688 return SWIG_Py_Void();
51689 }
51690
51691 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51692 return SWIG_Python_InitShadowInstance(args);
51693 }
51694
51695 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51696 PyObject *resultobj = 0;
51697 int arg1 = (int) 1 ;
51698 int arg2 = (int) 0 ;
51699 int arg3 = (int) 0 ;
51700 int arg4 = (int) 0 ;
51701 wxFlexGridSizer *result = 0 ;
51702 int val1 ;
51703 int ecode1 = 0 ;
51704 int val2 ;
51705 int ecode2 = 0 ;
51706 int val3 ;
51707 int ecode3 = 0 ;
51708 int val4 ;
51709 int ecode4 = 0 ;
51710 PyObject * obj0 = 0 ;
51711 PyObject * obj1 = 0 ;
51712 PyObject * obj2 = 0 ;
51713 PyObject * obj3 = 0 ;
51714 char * kwnames[] = {
51715 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51716 };
51717
51718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51719 if (obj0) {
51720 ecode1 = SWIG_AsVal_int(obj0, &val1);
51721 if (!SWIG_IsOK(ecode1)) {
51722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51723 }
51724 arg1 = static_cast< int >(val1);
51725 }
51726 if (obj1) {
51727 ecode2 = SWIG_AsVal_int(obj1, &val2);
51728 if (!SWIG_IsOK(ecode2)) {
51729 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51730 }
51731 arg2 = static_cast< int >(val2);
51732 }
51733 if (obj2) {
51734 ecode3 = SWIG_AsVal_int(obj2, &val3);
51735 if (!SWIG_IsOK(ecode3)) {
51736 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51737 }
51738 arg3 = static_cast< int >(val3);
51739 }
51740 if (obj3) {
51741 ecode4 = SWIG_AsVal_int(obj3, &val4);
51742 if (!SWIG_IsOK(ecode4)) {
51743 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51744 }
51745 arg4 = static_cast< int >(val4);
51746 }
51747 {
51748 PyThreadState* __tstate = wxPyBeginAllowThreads();
51749 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51750 wxPyEndAllowThreads(__tstate);
51751 if (PyErr_Occurred()) SWIG_fail;
51752 }
51753 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51754 return resultobj;
51755 fail:
51756 return NULL;
51757 }
51758
51759
51760 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51761 PyObject *resultobj = 0;
51762 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51763 size_t arg2 ;
51764 int arg3 = (int) 0 ;
51765 void *argp1 = 0 ;
51766 int res1 = 0 ;
51767 size_t val2 ;
51768 int ecode2 = 0 ;
51769 int val3 ;
51770 int ecode3 = 0 ;
51771 PyObject * obj0 = 0 ;
51772 PyObject * obj1 = 0 ;
51773 PyObject * obj2 = 0 ;
51774 char * kwnames[] = {
51775 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51776 };
51777
51778 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51779 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51780 if (!SWIG_IsOK(res1)) {
51781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51782 }
51783 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51784 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51785 if (!SWIG_IsOK(ecode2)) {
51786 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51787 }
51788 arg2 = static_cast< size_t >(val2);
51789 if (obj2) {
51790 ecode3 = SWIG_AsVal_int(obj2, &val3);
51791 if (!SWIG_IsOK(ecode3)) {
51792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51793 }
51794 arg3 = static_cast< int >(val3);
51795 }
51796 {
51797 PyThreadState* __tstate = wxPyBeginAllowThreads();
51798 (arg1)->AddGrowableRow(arg2,arg3);
51799 wxPyEndAllowThreads(__tstate);
51800 if (PyErr_Occurred()) SWIG_fail;
51801 }
51802 resultobj = SWIG_Py_Void();
51803 return resultobj;
51804 fail:
51805 return NULL;
51806 }
51807
51808
51809 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51810 PyObject *resultobj = 0;
51811 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51812 size_t arg2 ;
51813 void *argp1 = 0 ;
51814 int res1 = 0 ;
51815 size_t val2 ;
51816 int ecode2 = 0 ;
51817 PyObject * obj0 = 0 ;
51818 PyObject * obj1 = 0 ;
51819 char * kwnames[] = {
51820 (char *) "self",(char *) "idx", NULL
51821 };
51822
51823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
51824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51825 if (!SWIG_IsOK(res1)) {
51826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51827 }
51828 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51829 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51830 if (!SWIG_IsOK(ecode2)) {
51831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51832 }
51833 arg2 = static_cast< size_t >(val2);
51834 {
51835 PyThreadState* __tstate = wxPyBeginAllowThreads();
51836 (arg1)->RemoveGrowableRow(arg2);
51837 wxPyEndAllowThreads(__tstate);
51838 if (PyErr_Occurred()) SWIG_fail;
51839 }
51840 resultobj = SWIG_Py_Void();
51841 return resultobj;
51842 fail:
51843 return NULL;
51844 }
51845
51846
51847 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51848 PyObject *resultobj = 0;
51849 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51850 size_t arg2 ;
51851 int arg3 = (int) 0 ;
51852 void *argp1 = 0 ;
51853 int res1 = 0 ;
51854 size_t val2 ;
51855 int ecode2 = 0 ;
51856 int val3 ;
51857 int ecode3 = 0 ;
51858 PyObject * obj0 = 0 ;
51859 PyObject * obj1 = 0 ;
51860 PyObject * obj2 = 0 ;
51861 char * kwnames[] = {
51862 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51863 };
51864
51865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51867 if (!SWIG_IsOK(res1)) {
51868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51869 }
51870 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51871 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51872 if (!SWIG_IsOK(ecode2)) {
51873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51874 }
51875 arg2 = static_cast< size_t >(val2);
51876 if (obj2) {
51877 ecode3 = SWIG_AsVal_int(obj2, &val3);
51878 if (!SWIG_IsOK(ecode3)) {
51879 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
51880 }
51881 arg3 = static_cast< int >(val3);
51882 }
51883 {
51884 PyThreadState* __tstate = wxPyBeginAllowThreads();
51885 (arg1)->AddGrowableCol(arg2,arg3);
51886 wxPyEndAllowThreads(__tstate);
51887 if (PyErr_Occurred()) SWIG_fail;
51888 }
51889 resultobj = SWIG_Py_Void();
51890 return resultobj;
51891 fail:
51892 return NULL;
51893 }
51894
51895
51896 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51897 PyObject *resultobj = 0;
51898 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51899 size_t arg2 ;
51900 void *argp1 = 0 ;
51901 int res1 = 0 ;
51902 size_t val2 ;
51903 int ecode2 = 0 ;
51904 PyObject * obj0 = 0 ;
51905 PyObject * obj1 = 0 ;
51906 char * kwnames[] = {
51907 (char *) "self",(char *) "idx", NULL
51908 };
51909
51910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
51911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51912 if (!SWIG_IsOK(res1)) {
51913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51914 }
51915 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51916 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51917 if (!SWIG_IsOK(ecode2)) {
51918 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
51919 }
51920 arg2 = static_cast< size_t >(val2);
51921 {
51922 PyThreadState* __tstate = wxPyBeginAllowThreads();
51923 (arg1)->RemoveGrowableCol(arg2);
51924 wxPyEndAllowThreads(__tstate);
51925 if (PyErr_Occurred()) SWIG_fail;
51926 }
51927 resultobj = SWIG_Py_Void();
51928 return resultobj;
51929 fail:
51930 return NULL;
51931 }
51932
51933
51934 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51935 PyObject *resultobj = 0;
51936 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51937 int arg2 ;
51938 void *argp1 = 0 ;
51939 int res1 = 0 ;
51940 int val2 ;
51941 int ecode2 = 0 ;
51942 PyObject * obj0 = 0 ;
51943 PyObject * obj1 = 0 ;
51944 char * kwnames[] = {
51945 (char *) "self",(char *) "direction", NULL
51946 };
51947
51948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
51949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51950 if (!SWIG_IsOK(res1)) {
51951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51952 }
51953 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51954 ecode2 = SWIG_AsVal_int(obj1, &val2);
51955 if (!SWIG_IsOK(ecode2)) {
51956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
51957 }
51958 arg2 = static_cast< int >(val2);
51959 {
51960 PyThreadState* __tstate = wxPyBeginAllowThreads();
51961 (arg1)->SetFlexibleDirection(arg2);
51962 wxPyEndAllowThreads(__tstate);
51963 if (PyErr_Occurred()) SWIG_fail;
51964 }
51965 resultobj = SWIG_Py_Void();
51966 return resultobj;
51967 fail:
51968 return NULL;
51969 }
51970
51971
51972 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51973 PyObject *resultobj = 0;
51974 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51975 int result;
51976 void *argp1 = 0 ;
51977 int res1 = 0 ;
51978 PyObject *swig_obj[1] ;
51979
51980 if (!args) SWIG_fail;
51981 swig_obj[0] = args;
51982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51983 if (!SWIG_IsOK(res1)) {
51984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51985 }
51986 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51987 {
51988 PyThreadState* __tstate = wxPyBeginAllowThreads();
51989 result = (int)(arg1)->GetFlexibleDirection();
51990 wxPyEndAllowThreads(__tstate);
51991 if (PyErr_Occurred()) SWIG_fail;
51992 }
51993 resultobj = SWIG_From_int(static_cast< int >(result));
51994 return resultobj;
51995 fail:
51996 return NULL;
51997 }
51998
51999
52000 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52001 PyObject *resultobj = 0;
52002 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52003 wxFlexSizerGrowMode arg2 ;
52004 void *argp1 = 0 ;
52005 int res1 = 0 ;
52006 int val2 ;
52007 int ecode2 = 0 ;
52008 PyObject * obj0 = 0 ;
52009 PyObject * obj1 = 0 ;
52010 char * kwnames[] = {
52011 (char *) "self",(char *) "mode", NULL
52012 };
52013
52014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52015 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52016 if (!SWIG_IsOK(res1)) {
52017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52018 }
52019 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52020 ecode2 = SWIG_AsVal_int(obj1, &val2);
52021 if (!SWIG_IsOK(ecode2)) {
52022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52023 }
52024 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52025 {
52026 PyThreadState* __tstate = wxPyBeginAllowThreads();
52027 (arg1)->SetNonFlexibleGrowMode(arg2);
52028 wxPyEndAllowThreads(__tstate);
52029 if (PyErr_Occurred()) SWIG_fail;
52030 }
52031 resultobj = SWIG_Py_Void();
52032 return resultobj;
52033 fail:
52034 return NULL;
52035 }
52036
52037
52038 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52039 PyObject *resultobj = 0;
52040 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52041 wxFlexSizerGrowMode result;
52042 void *argp1 = 0 ;
52043 int res1 = 0 ;
52044 PyObject *swig_obj[1] ;
52045
52046 if (!args) SWIG_fail;
52047 swig_obj[0] = args;
52048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52049 if (!SWIG_IsOK(res1)) {
52050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52051 }
52052 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52053 {
52054 PyThreadState* __tstate = wxPyBeginAllowThreads();
52055 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52056 wxPyEndAllowThreads(__tstate);
52057 if (PyErr_Occurred()) SWIG_fail;
52058 }
52059 resultobj = SWIG_From_int(static_cast< int >(result));
52060 return resultobj;
52061 fail:
52062 return NULL;
52063 }
52064
52065
52066 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52067 PyObject *resultobj = 0;
52068 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52069 wxArrayInt *result = 0 ;
52070 void *argp1 = 0 ;
52071 int res1 = 0 ;
52072 PyObject *swig_obj[1] ;
52073
52074 if (!args) SWIG_fail;
52075 swig_obj[0] = args;
52076 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52077 if (!SWIG_IsOK(res1)) {
52078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52079 }
52080 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52081 {
52082 PyThreadState* __tstate = wxPyBeginAllowThreads();
52083 {
52084 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52085 result = (wxArrayInt *) &_result_ref;
52086 }
52087 wxPyEndAllowThreads(__tstate);
52088 if (PyErr_Occurred()) SWIG_fail;
52089 }
52090 {
52091 resultobj = wxArrayInt2PyList_helper(*result);
52092 }
52093 return resultobj;
52094 fail:
52095 return NULL;
52096 }
52097
52098
52099 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52100 PyObject *resultobj = 0;
52101 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52102 wxArrayInt *result = 0 ;
52103 void *argp1 = 0 ;
52104 int res1 = 0 ;
52105 PyObject *swig_obj[1] ;
52106
52107 if (!args) SWIG_fail;
52108 swig_obj[0] = args;
52109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52110 if (!SWIG_IsOK(res1)) {
52111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52112 }
52113 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52114 {
52115 PyThreadState* __tstate = wxPyBeginAllowThreads();
52116 {
52117 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52118 result = (wxArrayInt *) &_result_ref;
52119 }
52120 wxPyEndAllowThreads(__tstate);
52121 if (PyErr_Occurred()) SWIG_fail;
52122 }
52123 {
52124 resultobj = wxArrayInt2PyList_helper(*result);
52125 }
52126 return resultobj;
52127 fail:
52128 return NULL;
52129 }
52130
52131
52132 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52133 PyObject *obj;
52134 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52135 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52136 return SWIG_Py_Void();
52137 }
52138
52139 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52140 return SWIG_Python_InitShadowInstance(args);
52141 }
52142
52143 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52144 PyObject *resultobj = 0;
52145 wxStdDialogButtonSizer *result = 0 ;
52146
52147 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52148 {
52149 PyThreadState* __tstate = wxPyBeginAllowThreads();
52150 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52151 wxPyEndAllowThreads(__tstate);
52152 if (PyErr_Occurred()) SWIG_fail;
52153 }
52154 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52155 return resultobj;
52156 fail:
52157 return NULL;
52158 }
52159
52160
52161 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52162 PyObject *resultobj = 0;
52163 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52164 wxButton *arg2 = (wxButton *) 0 ;
52165 void *argp1 = 0 ;
52166 int res1 = 0 ;
52167 void *argp2 = 0 ;
52168 int res2 = 0 ;
52169 PyObject * obj0 = 0 ;
52170 PyObject * obj1 = 0 ;
52171 char * kwnames[] = {
52172 (char *) "self",(char *) "button", NULL
52173 };
52174
52175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52177 if (!SWIG_IsOK(res1)) {
52178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52179 }
52180 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52181 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52182 if (!SWIG_IsOK(res2)) {
52183 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52184 }
52185 arg2 = reinterpret_cast< wxButton * >(argp2);
52186 {
52187 PyThreadState* __tstate = wxPyBeginAllowThreads();
52188 (arg1)->AddButton(arg2);
52189 wxPyEndAllowThreads(__tstate);
52190 if (PyErr_Occurred()) SWIG_fail;
52191 }
52192 resultobj = SWIG_Py_Void();
52193 return resultobj;
52194 fail:
52195 return NULL;
52196 }
52197
52198
52199 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52200 PyObject *resultobj = 0;
52201 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52202 void *argp1 = 0 ;
52203 int res1 = 0 ;
52204 PyObject *swig_obj[1] ;
52205
52206 if (!args) SWIG_fail;
52207 swig_obj[0] = args;
52208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52209 if (!SWIG_IsOK(res1)) {
52210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52211 }
52212 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52213 {
52214 PyThreadState* __tstate = wxPyBeginAllowThreads();
52215 (arg1)->Realize();
52216 wxPyEndAllowThreads(__tstate);
52217 if (PyErr_Occurred()) SWIG_fail;
52218 }
52219 resultobj = SWIG_Py_Void();
52220 return resultobj;
52221 fail:
52222 return NULL;
52223 }
52224
52225
52226 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52227 PyObject *resultobj = 0;
52228 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52229 wxButton *arg2 = (wxButton *) 0 ;
52230 void *argp1 = 0 ;
52231 int res1 = 0 ;
52232 void *argp2 = 0 ;
52233 int res2 = 0 ;
52234 PyObject * obj0 = 0 ;
52235 PyObject * obj1 = 0 ;
52236 char * kwnames[] = {
52237 (char *) "self",(char *) "button", NULL
52238 };
52239
52240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52242 if (!SWIG_IsOK(res1)) {
52243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52244 }
52245 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52246 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52247 if (!SWIG_IsOK(res2)) {
52248 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52249 }
52250 arg2 = reinterpret_cast< wxButton * >(argp2);
52251 {
52252 PyThreadState* __tstate = wxPyBeginAllowThreads();
52253 (arg1)->SetAffirmativeButton(arg2);
52254 wxPyEndAllowThreads(__tstate);
52255 if (PyErr_Occurred()) SWIG_fail;
52256 }
52257 resultobj = SWIG_Py_Void();
52258 return resultobj;
52259 fail:
52260 return NULL;
52261 }
52262
52263
52264 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52265 PyObject *resultobj = 0;
52266 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52267 wxButton *arg2 = (wxButton *) 0 ;
52268 void *argp1 = 0 ;
52269 int res1 = 0 ;
52270 void *argp2 = 0 ;
52271 int res2 = 0 ;
52272 PyObject * obj0 = 0 ;
52273 PyObject * obj1 = 0 ;
52274 char * kwnames[] = {
52275 (char *) "self",(char *) "button", NULL
52276 };
52277
52278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52280 if (!SWIG_IsOK(res1)) {
52281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52282 }
52283 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52285 if (!SWIG_IsOK(res2)) {
52286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52287 }
52288 arg2 = reinterpret_cast< wxButton * >(argp2);
52289 {
52290 PyThreadState* __tstate = wxPyBeginAllowThreads();
52291 (arg1)->SetNegativeButton(arg2);
52292 wxPyEndAllowThreads(__tstate);
52293 if (PyErr_Occurred()) SWIG_fail;
52294 }
52295 resultobj = SWIG_Py_Void();
52296 return resultobj;
52297 fail:
52298 return NULL;
52299 }
52300
52301
52302 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52303 PyObject *resultobj = 0;
52304 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52305 wxButton *arg2 = (wxButton *) 0 ;
52306 void *argp1 = 0 ;
52307 int res1 = 0 ;
52308 void *argp2 = 0 ;
52309 int res2 = 0 ;
52310 PyObject * obj0 = 0 ;
52311 PyObject * obj1 = 0 ;
52312 char * kwnames[] = {
52313 (char *) "self",(char *) "button", NULL
52314 };
52315
52316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52318 if (!SWIG_IsOK(res1)) {
52319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52320 }
52321 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52322 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52323 if (!SWIG_IsOK(res2)) {
52324 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52325 }
52326 arg2 = reinterpret_cast< wxButton * >(argp2);
52327 {
52328 PyThreadState* __tstate = wxPyBeginAllowThreads();
52329 (arg1)->SetCancelButton(arg2);
52330 wxPyEndAllowThreads(__tstate);
52331 if (PyErr_Occurred()) SWIG_fail;
52332 }
52333 resultobj = SWIG_Py_Void();
52334 return resultobj;
52335 fail:
52336 return NULL;
52337 }
52338
52339
52340 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52341 PyObject *resultobj = 0;
52342 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52343 wxButton *result = 0 ;
52344 void *argp1 = 0 ;
52345 int res1 = 0 ;
52346 PyObject *swig_obj[1] ;
52347
52348 if (!args) SWIG_fail;
52349 swig_obj[0] = args;
52350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52351 if (!SWIG_IsOK(res1)) {
52352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52353 }
52354 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52355 {
52356 PyThreadState* __tstate = wxPyBeginAllowThreads();
52357 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52358 wxPyEndAllowThreads(__tstate);
52359 if (PyErr_Occurred()) SWIG_fail;
52360 }
52361 {
52362 resultobj = wxPyMake_wxObject(result, (bool)0);
52363 }
52364 return resultobj;
52365 fail:
52366 return NULL;
52367 }
52368
52369
52370 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52371 PyObject *resultobj = 0;
52372 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52373 wxButton *result = 0 ;
52374 void *argp1 = 0 ;
52375 int res1 = 0 ;
52376 PyObject *swig_obj[1] ;
52377
52378 if (!args) SWIG_fail;
52379 swig_obj[0] = args;
52380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52381 if (!SWIG_IsOK(res1)) {
52382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52383 }
52384 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52385 {
52386 PyThreadState* __tstate = wxPyBeginAllowThreads();
52387 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52388 wxPyEndAllowThreads(__tstate);
52389 if (PyErr_Occurred()) SWIG_fail;
52390 }
52391 {
52392 resultobj = wxPyMake_wxObject(result, (bool)0);
52393 }
52394 return resultobj;
52395 fail:
52396 return NULL;
52397 }
52398
52399
52400 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52401 PyObject *resultobj = 0;
52402 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52403 wxButton *result = 0 ;
52404 void *argp1 = 0 ;
52405 int res1 = 0 ;
52406 PyObject *swig_obj[1] ;
52407
52408 if (!args) SWIG_fail;
52409 swig_obj[0] = args;
52410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52411 if (!SWIG_IsOK(res1)) {
52412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52413 }
52414 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52415 {
52416 PyThreadState* __tstate = wxPyBeginAllowThreads();
52417 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52418 wxPyEndAllowThreads(__tstate);
52419 if (PyErr_Occurred()) SWIG_fail;
52420 }
52421 {
52422 resultobj = wxPyMake_wxObject(result, (bool)0);
52423 }
52424 return resultobj;
52425 fail:
52426 return NULL;
52427 }
52428
52429
52430 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52431 PyObject *resultobj = 0;
52432 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52433 wxButton *result = 0 ;
52434 void *argp1 = 0 ;
52435 int res1 = 0 ;
52436 PyObject *swig_obj[1] ;
52437
52438 if (!args) SWIG_fail;
52439 swig_obj[0] = args;
52440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52441 if (!SWIG_IsOK(res1)) {
52442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52443 }
52444 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52445 {
52446 PyThreadState* __tstate = wxPyBeginAllowThreads();
52447 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52448 wxPyEndAllowThreads(__tstate);
52449 if (PyErr_Occurred()) SWIG_fail;
52450 }
52451 {
52452 resultobj = wxPyMake_wxObject(result, (bool)0);
52453 }
52454 return resultobj;
52455 fail:
52456 return NULL;
52457 }
52458
52459
52460 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52461 PyObject *resultobj = 0;
52462 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52463 wxButton *result = 0 ;
52464 void *argp1 = 0 ;
52465 int res1 = 0 ;
52466 PyObject *swig_obj[1] ;
52467
52468 if (!args) SWIG_fail;
52469 swig_obj[0] = args;
52470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52471 if (!SWIG_IsOK(res1)) {
52472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52473 }
52474 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52475 {
52476 PyThreadState* __tstate = wxPyBeginAllowThreads();
52477 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52478 wxPyEndAllowThreads(__tstate);
52479 if (PyErr_Occurred()) SWIG_fail;
52480 }
52481 {
52482 resultobj = wxPyMake_wxObject(result, (bool)0);
52483 }
52484 return resultobj;
52485 fail:
52486 return NULL;
52487 }
52488
52489
52490 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52491 PyObject *obj;
52492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52493 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52494 return SWIG_Py_Void();
52495 }
52496
52497 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52498 return SWIG_Python_InitShadowInstance(args);
52499 }
52500
52501 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52502 PyObject *resultobj = 0;
52503 int arg1 = (int) 0 ;
52504 int arg2 = (int) 0 ;
52505 wxGBPosition *result = 0 ;
52506 int val1 ;
52507 int ecode1 = 0 ;
52508 int val2 ;
52509 int ecode2 = 0 ;
52510 PyObject * obj0 = 0 ;
52511 PyObject * obj1 = 0 ;
52512 char * kwnames[] = {
52513 (char *) "row",(char *) "col", NULL
52514 };
52515
52516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52517 if (obj0) {
52518 ecode1 = SWIG_AsVal_int(obj0, &val1);
52519 if (!SWIG_IsOK(ecode1)) {
52520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52521 }
52522 arg1 = static_cast< int >(val1);
52523 }
52524 if (obj1) {
52525 ecode2 = SWIG_AsVal_int(obj1, &val2);
52526 if (!SWIG_IsOK(ecode2)) {
52527 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52528 }
52529 arg2 = static_cast< int >(val2);
52530 }
52531 {
52532 PyThreadState* __tstate = wxPyBeginAllowThreads();
52533 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52534 wxPyEndAllowThreads(__tstate);
52535 if (PyErr_Occurred()) SWIG_fail;
52536 }
52537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52538 return resultobj;
52539 fail:
52540 return NULL;
52541 }
52542
52543
52544 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52545 PyObject *resultobj = 0;
52546 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52547 void *argp1 = 0 ;
52548 int res1 = 0 ;
52549 PyObject *swig_obj[1] ;
52550
52551 if (!args) SWIG_fail;
52552 swig_obj[0] = args;
52553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52554 if (!SWIG_IsOK(res1)) {
52555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52556 }
52557 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52558 {
52559 PyThreadState* __tstate = wxPyBeginAllowThreads();
52560 delete arg1;
52561
52562 wxPyEndAllowThreads(__tstate);
52563 if (PyErr_Occurred()) SWIG_fail;
52564 }
52565 resultobj = SWIG_Py_Void();
52566 return resultobj;
52567 fail:
52568 return NULL;
52569 }
52570
52571
52572 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52573 PyObject *resultobj = 0;
52574 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52575 int result;
52576 void *argp1 = 0 ;
52577 int res1 = 0 ;
52578 PyObject *swig_obj[1] ;
52579
52580 if (!args) SWIG_fail;
52581 swig_obj[0] = args;
52582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52583 if (!SWIG_IsOK(res1)) {
52584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52585 }
52586 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52587 {
52588 PyThreadState* __tstate = wxPyBeginAllowThreads();
52589 result = (int)((wxGBPosition const *)arg1)->GetRow();
52590 wxPyEndAllowThreads(__tstate);
52591 if (PyErr_Occurred()) SWIG_fail;
52592 }
52593 resultobj = SWIG_From_int(static_cast< int >(result));
52594 return resultobj;
52595 fail:
52596 return NULL;
52597 }
52598
52599
52600 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52601 PyObject *resultobj = 0;
52602 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52603 int result;
52604 void *argp1 = 0 ;
52605 int res1 = 0 ;
52606 PyObject *swig_obj[1] ;
52607
52608 if (!args) SWIG_fail;
52609 swig_obj[0] = args;
52610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52611 if (!SWIG_IsOK(res1)) {
52612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52613 }
52614 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52615 {
52616 PyThreadState* __tstate = wxPyBeginAllowThreads();
52617 result = (int)((wxGBPosition const *)arg1)->GetCol();
52618 wxPyEndAllowThreads(__tstate);
52619 if (PyErr_Occurred()) SWIG_fail;
52620 }
52621 resultobj = SWIG_From_int(static_cast< int >(result));
52622 return resultobj;
52623 fail:
52624 return NULL;
52625 }
52626
52627
52628 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52629 PyObject *resultobj = 0;
52630 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52631 int arg2 ;
52632 void *argp1 = 0 ;
52633 int res1 = 0 ;
52634 int val2 ;
52635 int ecode2 = 0 ;
52636 PyObject * obj0 = 0 ;
52637 PyObject * obj1 = 0 ;
52638 char * kwnames[] = {
52639 (char *) "self",(char *) "row", NULL
52640 };
52641
52642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52644 if (!SWIG_IsOK(res1)) {
52645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52646 }
52647 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52648 ecode2 = SWIG_AsVal_int(obj1, &val2);
52649 if (!SWIG_IsOK(ecode2)) {
52650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52651 }
52652 arg2 = static_cast< int >(val2);
52653 {
52654 PyThreadState* __tstate = wxPyBeginAllowThreads();
52655 (arg1)->SetRow(arg2);
52656 wxPyEndAllowThreads(__tstate);
52657 if (PyErr_Occurred()) SWIG_fail;
52658 }
52659 resultobj = SWIG_Py_Void();
52660 return resultobj;
52661 fail:
52662 return NULL;
52663 }
52664
52665
52666 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52667 PyObject *resultobj = 0;
52668 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52669 int arg2 ;
52670 void *argp1 = 0 ;
52671 int res1 = 0 ;
52672 int val2 ;
52673 int ecode2 = 0 ;
52674 PyObject * obj0 = 0 ;
52675 PyObject * obj1 = 0 ;
52676 char * kwnames[] = {
52677 (char *) "self",(char *) "col", NULL
52678 };
52679
52680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52682 if (!SWIG_IsOK(res1)) {
52683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52684 }
52685 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52686 ecode2 = SWIG_AsVal_int(obj1, &val2);
52687 if (!SWIG_IsOK(ecode2)) {
52688 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52689 }
52690 arg2 = static_cast< int >(val2);
52691 {
52692 PyThreadState* __tstate = wxPyBeginAllowThreads();
52693 (arg1)->SetCol(arg2);
52694 wxPyEndAllowThreads(__tstate);
52695 if (PyErr_Occurred()) SWIG_fail;
52696 }
52697 resultobj = SWIG_Py_Void();
52698 return resultobj;
52699 fail:
52700 return NULL;
52701 }
52702
52703
52704 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52705 PyObject *resultobj = 0;
52706 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52707 PyObject *arg2 = (PyObject *) 0 ;
52708 bool result;
52709 void *argp1 = 0 ;
52710 int res1 = 0 ;
52711 PyObject * obj0 = 0 ;
52712 PyObject * obj1 = 0 ;
52713 char * kwnames[] = {
52714 (char *) "self",(char *) "other", NULL
52715 };
52716
52717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52719 if (!SWIG_IsOK(res1)) {
52720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52721 }
52722 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52723 arg2 = obj1;
52724 {
52725 result = (bool)wxGBPosition___eq__(arg1,arg2);
52726 if (PyErr_Occurred()) SWIG_fail;
52727 }
52728 {
52729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52730 }
52731 return resultobj;
52732 fail:
52733 return NULL;
52734 }
52735
52736
52737 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52738 PyObject *resultobj = 0;
52739 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52740 PyObject *arg2 = (PyObject *) 0 ;
52741 bool result;
52742 void *argp1 = 0 ;
52743 int res1 = 0 ;
52744 PyObject * obj0 = 0 ;
52745 PyObject * obj1 = 0 ;
52746 char * kwnames[] = {
52747 (char *) "self",(char *) "other", NULL
52748 };
52749
52750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52752 if (!SWIG_IsOK(res1)) {
52753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52754 }
52755 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52756 arg2 = obj1;
52757 {
52758 result = (bool)wxGBPosition___ne__(arg1,arg2);
52759 if (PyErr_Occurred()) SWIG_fail;
52760 }
52761 {
52762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52763 }
52764 return resultobj;
52765 fail:
52766 return NULL;
52767 }
52768
52769
52770 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52771 PyObject *resultobj = 0;
52772 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52773 int arg2 = (int) 0 ;
52774 int arg3 = (int) 0 ;
52775 void *argp1 = 0 ;
52776 int res1 = 0 ;
52777 int val2 ;
52778 int ecode2 = 0 ;
52779 int val3 ;
52780 int ecode3 = 0 ;
52781 PyObject * obj0 = 0 ;
52782 PyObject * obj1 = 0 ;
52783 PyObject * obj2 = 0 ;
52784 char * kwnames[] = {
52785 (char *) "self",(char *) "row",(char *) "col", NULL
52786 };
52787
52788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52790 if (!SWIG_IsOK(res1)) {
52791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52792 }
52793 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52794 if (obj1) {
52795 ecode2 = SWIG_AsVal_int(obj1, &val2);
52796 if (!SWIG_IsOK(ecode2)) {
52797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52798 }
52799 arg2 = static_cast< int >(val2);
52800 }
52801 if (obj2) {
52802 ecode3 = SWIG_AsVal_int(obj2, &val3);
52803 if (!SWIG_IsOK(ecode3)) {
52804 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
52805 }
52806 arg3 = static_cast< int >(val3);
52807 }
52808 {
52809 PyThreadState* __tstate = wxPyBeginAllowThreads();
52810 wxGBPosition_Set(arg1,arg2,arg3);
52811 wxPyEndAllowThreads(__tstate);
52812 if (PyErr_Occurred()) SWIG_fail;
52813 }
52814 resultobj = SWIG_Py_Void();
52815 return resultobj;
52816 fail:
52817 return NULL;
52818 }
52819
52820
52821 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52822 PyObject *resultobj = 0;
52823 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52824 PyObject *result = 0 ;
52825 void *argp1 = 0 ;
52826 int res1 = 0 ;
52827 PyObject *swig_obj[1] ;
52828
52829 if (!args) SWIG_fail;
52830 swig_obj[0] = args;
52831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52832 if (!SWIG_IsOK(res1)) {
52833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52834 }
52835 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52836 {
52837 PyThreadState* __tstate = wxPyBeginAllowThreads();
52838 result = (PyObject *)wxGBPosition_Get(arg1);
52839 wxPyEndAllowThreads(__tstate);
52840 if (PyErr_Occurred()) SWIG_fail;
52841 }
52842 resultobj = result;
52843 return resultobj;
52844 fail:
52845 return NULL;
52846 }
52847
52848
52849 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52850 PyObject *obj;
52851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52852 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
52853 return SWIG_Py_Void();
52854 }
52855
52856 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52857 return SWIG_Python_InitShadowInstance(args);
52858 }
52859
52860 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52861 PyObject *resultobj = 0;
52862 int arg1 = (int) 1 ;
52863 int arg2 = (int) 1 ;
52864 wxGBSpan *result = 0 ;
52865 int val1 ;
52866 int ecode1 = 0 ;
52867 int val2 ;
52868 int ecode2 = 0 ;
52869 PyObject * obj0 = 0 ;
52870 PyObject * obj1 = 0 ;
52871 char * kwnames[] = {
52872 (char *) "rowspan",(char *) "colspan", NULL
52873 };
52874
52875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
52876 if (obj0) {
52877 ecode1 = SWIG_AsVal_int(obj0, &val1);
52878 if (!SWIG_IsOK(ecode1)) {
52879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
52880 }
52881 arg1 = static_cast< int >(val1);
52882 }
52883 if (obj1) {
52884 ecode2 = SWIG_AsVal_int(obj1, &val2);
52885 if (!SWIG_IsOK(ecode2)) {
52886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
52887 }
52888 arg2 = static_cast< int >(val2);
52889 }
52890 {
52891 PyThreadState* __tstate = wxPyBeginAllowThreads();
52892 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
52893 wxPyEndAllowThreads(__tstate);
52894 if (PyErr_Occurred()) SWIG_fail;
52895 }
52896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
52897 return resultobj;
52898 fail:
52899 return NULL;
52900 }
52901
52902
52903 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52904 PyObject *resultobj = 0;
52905 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52906 void *argp1 = 0 ;
52907 int res1 = 0 ;
52908 PyObject *swig_obj[1] ;
52909
52910 if (!args) SWIG_fail;
52911 swig_obj[0] = args;
52912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
52913 if (!SWIG_IsOK(res1)) {
52914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
52915 }
52916 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52917 {
52918 PyThreadState* __tstate = wxPyBeginAllowThreads();
52919 delete arg1;
52920
52921 wxPyEndAllowThreads(__tstate);
52922 if (PyErr_Occurred()) SWIG_fail;
52923 }
52924 resultobj = SWIG_Py_Void();
52925 return resultobj;
52926 fail:
52927 return NULL;
52928 }
52929
52930
52931 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52932 PyObject *resultobj = 0;
52933 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52934 int result;
52935 void *argp1 = 0 ;
52936 int res1 = 0 ;
52937 PyObject *swig_obj[1] ;
52938
52939 if (!args) SWIG_fail;
52940 swig_obj[0] = args;
52941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52942 if (!SWIG_IsOK(res1)) {
52943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52944 }
52945 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52946 {
52947 PyThreadState* __tstate = wxPyBeginAllowThreads();
52948 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
52949 wxPyEndAllowThreads(__tstate);
52950 if (PyErr_Occurred()) SWIG_fail;
52951 }
52952 resultobj = SWIG_From_int(static_cast< int >(result));
52953 return resultobj;
52954 fail:
52955 return NULL;
52956 }
52957
52958
52959 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52960 PyObject *resultobj = 0;
52961 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52962 int result;
52963 void *argp1 = 0 ;
52964 int res1 = 0 ;
52965 PyObject *swig_obj[1] ;
52966
52967 if (!args) SWIG_fail;
52968 swig_obj[0] = args;
52969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
52970 if (!SWIG_IsOK(res1)) {
52971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
52972 }
52973 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
52974 {
52975 PyThreadState* __tstate = wxPyBeginAllowThreads();
52976 result = (int)((wxGBSpan const *)arg1)->GetColspan();
52977 wxPyEndAllowThreads(__tstate);
52978 if (PyErr_Occurred()) SWIG_fail;
52979 }
52980 resultobj = SWIG_From_int(static_cast< int >(result));
52981 return resultobj;
52982 fail:
52983 return NULL;
52984 }
52985
52986
52987 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52988 PyObject *resultobj = 0;
52989 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
52990 int arg2 ;
52991 void *argp1 = 0 ;
52992 int res1 = 0 ;
52993 int val2 ;
52994 int ecode2 = 0 ;
52995 PyObject * obj0 = 0 ;
52996 PyObject * obj1 = 0 ;
52997 char * kwnames[] = {
52998 (char *) "self",(char *) "rowspan", NULL
52999 };
53000
53001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53003 if (!SWIG_IsOK(res1)) {
53004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53005 }
53006 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53007 ecode2 = SWIG_AsVal_int(obj1, &val2);
53008 if (!SWIG_IsOK(ecode2)) {
53009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53010 }
53011 arg2 = static_cast< int >(val2);
53012 {
53013 PyThreadState* __tstate = wxPyBeginAllowThreads();
53014 (arg1)->SetRowspan(arg2);
53015 wxPyEndAllowThreads(__tstate);
53016 if (PyErr_Occurred()) SWIG_fail;
53017 }
53018 resultobj = SWIG_Py_Void();
53019 return resultobj;
53020 fail:
53021 return NULL;
53022 }
53023
53024
53025 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53026 PyObject *resultobj = 0;
53027 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53028 int arg2 ;
53029 void *argp1 = 0 ;
53030 int res1 = 0 ;
53031 int val2 ;
53032 int ecode2 = 0 ;
53033 PyObject * obj0 = 0 ;
53034 PyObject * obj1 = 0 ;
53035 char * kwnames[] = {
53036 (char *) "self",(char *) "colspan", NULL
53037 };
53038
53039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53041 if (!SWIG_IsOK(res1)) {
53042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53043 }
53044 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53045 ecode2 = SWIG_AsVal_int(obj1, &val2);
53046 if (!SWIG_IsOK(ecode2)) {
53047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53048 }
53049 arg2 = static_cast< int >(val2);
53050 {
53051 PyThreadState* __tstate = wxPyBeginAllowThreads();
53052 (arg1)->SetColspan(arg2);
53053 wxPyEndAllowThreads(__tstate);
53054 if (PyErr_Occurred()) SWIG_fail;
53055 }
53056 resultobj = SWIG_Py_Void();
53057 return resultobj;
53058 fail:
53059 return NULL;
53060 }
53061
53062
53063 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53064 PyObject *resultobj = 0;
53065 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53066 PyObject *arg2 = (PyObject *) 0 ;
53067 bool result;
53068 void *argp1 = 0 ;
53069 int res1 = 0 ;
53070 PyObject * obj0 = 0 ;
53071 PyObject * obj1 = 0 ;
53072 char * kwnames[] = {
53073 (char *) "self",(char *) "other", NULL
53074 };
53075
53076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53078 if (!SWIG_IsOK(res1)) {
53079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53080 }
53081 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53082 arg2 = obj1;
53083 {
53084 result = (bool)wxGBSpan___eq__(arg1,arg2);
53085 if (PyErr_Occurred()) SWIG_fail;
53086 }
53087 {
53088 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53089 }
53090 return resultobj;
53091 fail:
53092 return NULL;
53093 }
53094
53095
53096 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53097 PyObject *resultobj = 0;
53098 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53099 PyObject *arg2 = (PyObject *) 0 ;
53100 bool result;
53101 void *argp1 = 0 ;
53102 int res1 = 0 ;
53103 PyObject * obj0 = 0 ;
53104 PyObject * obj1 = 0 ;
53105 char * kwnames[] = {
53106 (char *) "self",(char *) "other", NULL
53107 };
53108
53109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53111 if (!SWIG_IsOK(res1)) {
53112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53113 }
53114 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53115 arg2 = obj1;
53116 {
53117 result = (bool)wxGBSpan___ne__(arg1,arg2);
53118 if (PyErr_Occurred()) SWIG_fail;
53119 }
53120 {
53121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53122 }
53123 return resultobj;
53124 fail:
53125 return NULL;
53126 }
53127
53128
53129 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53130 PyObject *resultobj = 0;
53131 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53132 int arg2 = (int) 1 ;
53133 int arg3 = (int) 1 ;
53134 void *argp1 = 0 ;
53135 int res1 = 0 ;
53136 int val2 ;
53137 int ecode2 = 0 ;
53138 int val3 ;
53139 int ecode3 = 0 ;
53140 PyObject * obj0 = 0 ;
53141 PyObject * obj1 = 0 ;
53142 PyObject * obj2 = 0 ;
53143 char * kwnames[] = {
53144 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53145 };
53146
53147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53149 if (!SWIG_IsOK(res1)) {
53150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53151 }
53152 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53153 if (obj1) {
53154 ecode2 = SWIG_AsVal_int(obj1, &val2);
53155 if (!SWIG_IsOK(ecode2)) {
53156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53157 }
53158 arg2 = static_cast< int >(val2);
53159 }
53160 if (obj2) {
53161 ecode3 = SWIG_AsVal_int(obj2, &val3);
53162 if (!SWIG_IsOK(ecode3)) {
53163 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53164 }
53165 arg3 = static_cast< int >(val3);
53166 }
53167 {
53168 PyThreadState* __tstate = wxPyBeginAllowThreads();
53169 wxGBSpan_Set(arg1,arg2,arg3);
53170 wxPyEndAllowThreads(__tstate);
53171 if (PyErr_Occurred()) SWIG_fail;
53172 }
53173 resultobj = SWIG_Py_Void();
53174 return resultobj;
53175 fail:
53176 return NULL;
53177 }
53178
53179
53180 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53181 PyObject *resultobj = 0;
53182 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53183 PyObject *result = 0 ;
53184 void *argp1 = 0 ;
53185 int res1 = 0 ;
53186 PyObject *swig_obj[1] ;
53187
53188 if (!args) SWIG_fail;
53189 swig_obj[0] = args;
53190 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53191 if (!SWIG_IsOK(res1)) {
53192 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53193 }
53194 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53195 {
53196 PyThreadState* __tstate = wxPyBeginAllowThreads();
53197 result = (PyObject *)wxGBSpan_Get(arg1);
53198 wxPyEndAllowThreads(__tstate);
53199 if (PyErr_Occurred()) SWIG_fail;
53200 }
53201 resultobj = result;
53202 return resultobj;
53203 fail:
53204 return NULL;
53205 }
53206
53207
53208 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53209 PyObject *obj;
53210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53211 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53212 return SWIG_Py_Void();
53213 }
53214
53215 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53216 return SWIG_Python_InitShadowInstance(args);
53217 }
53218
53219 SWIGINTERN int DefaultSpan_set(PyObject *) {
53220 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53221 return 1;
53222 }
53223
53224
53225 SWIGINTERN PyObject *DefaultSpan_get(void) {
53226 PyObject *pyobj = 0;
53227
53228 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53229 return pyobj;
53230 }
53231
53232
53233 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53234 PyObject *resultobj = 0;
53235 wxGBSizerItem *result = 0 ;
53236
53237 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53238 {
53239 PyThreadState* __tstate = wxPyBeginAllowThreads();
53240 result = (wxGBSizerItem *)new wxGBSizerItem();
53241 wxPyEndAllowThreads(__tstate);
53242 if (PyErr_Occurred()) SWIG_fail;
53243 }
53244 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53245 return resultobj;
53246 fail:
53247 return NULL;
53248 }
53249
53250
53251 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53252 PyObject *resultobj = 0;
53253 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53254 void *argp1 = 0 ;
53255 int res1 = 0 ;
53256 PyObject *swig_obj[1] ;
53257
53258 if (!args) SWIG_fail;
53259 swig_obj[0] = args;
53260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53261 if (!SWIG_IsOK(res1)) {
53262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53263 }
53264 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53265 {
53266 PyThreadState* __tstate = wxPyBeginAllowThreads();
53267 delete arg1;
53268
53269 wxPyEndAllowThreads(__tstate);
53270 if (PyErr_Occurred()) SWIG_fail;
53271 }
53272 resultobj = SWIG_Py_Void();
53273 return resultobj;
53274 fail:
53275 return NULL;
53276 }
53277
53278
53279 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53280 PyObject *resultobj = 0;
53281 wxWindow *arg1 = (wxWindow *) 0 ;
53282 wxGBPosition *arg2 = 0 ;
53283 wxGBSpan *arg3 = 0 ;
53284 int arg4 ;
53285 int arg5 ;
53286 PyObject *arg6 = (PyObject *) NULL ;
53287 wxGBSizerItem *result = 0 ;
53288 void *argp1 = 0 ;
53289 int res1 = 0 ;
53290 wxGBPosition temp2 ;
53291 wxGBSpan temp3 ;
53292 int val4 ;
53293 int ecode4 = 0 ;
53294 int val5 ;
53295 int ecode5 = 0 ;
53296 PyObject * obj0 = 0 ;
53297 PyObject * obj1 = 0 ;
53298 PyObject * obj2 = 0 ;
53299 PyObject * obj3 = 0 ;
53300 PyObject * obj4 = 0 ;
53301 PyObject * obj5 = 0 ;
53302 char * kwnames[] = {
53303 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53304 };
53305
53306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53308 if (!SWIG_IsOK(res1)) {
53309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53310 }
53311 arg1 = reinterpret_cast< wxWindow * >(argp1);
53312 {
53313 arg2 = &temp2;
53314 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53315 }
53316 {
53317 arg3 = &temp3;
53318 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53319 }
53320 ecode4 = SWIG_AsVal_int(obj3, &val4);
53321 if (!SWIG_IsOK(ecode4)) {
53322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53323 }
53324 arg4 = static_cast< int >(val4);
53325 ecode5 = SWIG_AsVal_int(obj4, &val5);
53326 if (!SWIG_IsOK(ecode5)) {
53327 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53328 }
53329 arg5 = static_cast< int >(val5);
53330 if (obj5) {
53331 arg6 = obj5;
53332 }
53333 {
53334 PyThreadState* __tstate = wxPyBeginAllowThreads();
53335 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53336 wxPyEndAllowThreads(__tstate);
53337 if (PyErr_Occurred()) SWIG_fail;
53338 }
53339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53340 return resultobj;
53341 fail:
53342 return NULL;
53343 }
53344
53345
53346 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53347 PyObject *resultobj = 0;
53348 wxSizer *arg1 = (wxSizer *) 0 ;
53349 wxGBPosition *arg2 = 0 ;
53350 wxGBSpan *arg3 = 0 ;
53351 int arg4 ;
53352 int arg5 ;
53353 PyObject *arg6 = (PyObject *) NULL ;
53354 wxGBSizerItem *result = 0 ;
53355 int res1 = 0 ;
53356 wxGBPosition temp2 ;
53357 wxGBSpan temp3 ;
53358 int val4 ;
53359 int ecode4 = 0 ;
53360 int val5 ;
53361 int ecode5 = 0 ;
53362 PyObject * obj0 = 0 ;
53363 PyObject * obj1 = 0 ;
53364 PyObject * obj2 = 0 ;
53365 PyObject * obj3 = 0 ;
53366 PyObject * obj4 = 0 ;
53367 PyObject * obj5 = 0 ;
53368 char * kwnames[] = {
53369 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53370 };
53371
53372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53373 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53374 if (!SWIG_IsOK(res1)) {
53375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53376 }
53377 {
53378 arg2 = &temp2;
53379 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53380 }
53381 {
53382 arg3 = &temp3;
53383 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53384 }
53385 ecode4 = SWIG_AsVal_int(obj3, &val4);
53386 if (!SWIG_IsOK(ecode4)) {
53387 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53388 }
53389 arg4 = static_cast< int >(val4);
53390 ecode5 = SWIG_AsVal_int(obj4, &val5);
53391 if (!SWIG_IsOK(ecode5)) {
53392 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53393 }
53394 arg5 = static_cast< int >(val5);
53395 if (obj5) {
53396 arg6 = obj5;
53397 }
53398 {
53399 PyThreadState* __tstate = wxPyBeginAllowThreads();
53400 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53401 wxPyEndAllowThreads(__tstate);
53402 if (PyErr_Occurred()) SWIG_fail;
53403 }
53404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53405 return resultobj;
53406 fail:
53407 return NULL;
53408 }
53409
53410
53411 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53412 PyObject *resultobj = 0;
53413 int arg1 ;
53414 int arg2 ;
53415 wxGBPosition *arg3 = 0 ;
53416 wxGBSpan *arg4 = 0 ;
53417 int arg5 ;
53418 int arg6 ;
53419 PyObject *arg7 = (PyObject *) NULL ;
53420 wxGBSizerItem *result = 0 ;
53421 int val1 ;
53422 int ecode1 = 0 ;
53423 int val2 ;
53424 int ecode2 = 0 ;
53425 wxGBPosition temp3 ;
53426 wxGBSpan temp4 ;
53427 int val5 ;
53428 int ecode5 = 0 ;
53429 int val6 ;
53430 int ecode6 = 0 ;
53431 PyObject * obj0 = 0 ;
53432 PyObject * obj1 = 0 ;
53433 PyObject * obj2 = 0 ;
53434 PyObject * obj3 = 0 ;
53435 PyObject * obj4 = 0 ;
53436 PyObject * obj5 = 0 ;
53437 PyObject * obj6 = 0 ;
53438 char * kwnames[] = {
53439 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53440 };
53441
53442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53443 ecode1 = SWIG_AsVal_int(obj0, &val1);
53444 if (!SWIG_IsOK(ecode1)) {
53445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53446 }
53447 arg1 = static_cast< int >(val1);
53448 ecode2 = SWIG_AsVal_int(obj1, &val2);
53449 if (!SWIG_IsOK(ecode2)) {
53450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53451 }
53452 arg2 = static_cast< int >(val2);
53453 {
53454 arg3 = &temp3;
53455 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53456 }
53457 {
53458 arg4 = &temp4;
53459 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53460 }
53461 ecode5 = SWIG_AsVal_int(obj4, &val5);
53462 if (!SWIG_IsOK(ecode5)) {
53463 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53464 }
53465 arg5 = static_cast< int >(val5);
53466 ecode6 = SWIG_AsVal_int(obj5, &val6);
53467 if (!SWIG_IsOK(ecode6)) {
53468 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53469 }
53470 arg6 = static_cast< int >(val6);
53471 if (obj6) {
53472 arg7 = obj6;
53473 }
53474 {
53475 PyThreadState* __tstate = wxPyBeginAllowThreads();
53476 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53477 wxPyEndAllowThreads(__tstate);
53478 if (PyErr_Occurred()) SWIG_fail;
53479 }
53480 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53481 return resultobj;
53482 fail:
53483 return NULL;
53484 }
53485
53486
53487 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53488 PyObject *resultobj = 0;
53489 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53490 wxGBPosition result;
53491 void *argp1 = 0 ;
53492 int res1 = 0 ;
53493 PyObject *swig_obj[1] ;
53494
53495 if (!args) SWIG_fail;
53496 swig_obj[0] = args;
53497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53498 if (!SWIG_IsOK(res1)) {
53499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53500 }
53501 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53502 {
53503 PyThreadState* __tstate = wxPyBeginAllowThreads();
53504 result = ((wxGBSizerItem const *)arg1)->GetPos();
53505 wxPyEndAllowThreads(__tstate);
53506 if (PyErr_Occurred()) SWIG_fail;
53507 }
53508 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53509 return resultobj;
53510 fail:
53511 return NULL;
53512 }
53513
53514
53515 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53516 PyObject *resultobj = 0;
53517 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53518 wxGBSpan result;
53519 void *argp1 = 0 ;
53520 int res1 = 0 ;
53521 PyObject *swig_obj[1] ;
53522
53523 if (!args) SWIG_fail;
53524 swig_obj[0] = args;
53525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53526 if (!SWIG_IsOK(res1)) {
53527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53528 }
53529 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53530 {
53531 PyThreadState* __tstate = wxPyBeginAllowThreads();
53532 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53533 wxPyEndAllowThreads(__tstate);
53534 if (PyErr_Occurred()) SWIG_fail;
53535 }
53536 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53537 return resultobj;
53538 fail:
53539 return NULL;
53540 }
53541
53542
53543 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53544 PyObject *resultobj = 0;
53545 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53546 wxGBPosition *arg2 = 0 ;
53547 bool result;
53548 void *argp1 = 0 ;
53549 int res1 = 0 ;
53550 wxGBPosition temp2 ;
53551 PyObject * obj0 = 0 ;
53552 PyObject * obj1 = 0 ;
53553 char * kwnames[] = {
53554 (char *) "self",(char *) "pos", NULL
53555 };
53556
53557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53559 if (!SWIG_IsOK(res1)) {
53560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53561 }
53562 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53563 {
53564 arg2 = &temp2;
53565 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53566 }
53567 {
53568 PyThreadState* __tstate = wxPyBeginAllowThreads();
53569 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53570 wxPyEndAllowThreads(__tstate);
53571 if (PyErr_Occurred()) SWIG_fail;
53572 }
53573 {
53574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53575 }
53576 return resultobj;
53577 fail:
53578 return NULL;
53579 }
53580
53581
53582 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53583 PyObject *resultobj = 0;
53584 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53585 wxGBSpan *arg2 = 0 ;
53586 bool result;
53587 void *argp1 = 0 ;
53588 int res1 = 0 ;
53589 wxGBSpan temp2 ;
53590 PyObject * obj0 = 0 ;
53591 PyObject * obj1 = 0 ;
53592 char * kwnames[] = {
53593 (char *) "self",(char *) "span", NULL
53594 };
53595
53596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53598 if (!SWIG_IsOK(res1)) {
53599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53600 }
53601 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53602 {
53603 arg2 = &temp2;
53604 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53605 }
53606 {
53607 PyThreadState* __tstate = wxPyBeginAllowThreads();
53608 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53609 wxPyEndAllowThreads(__tstate);
53610 if (PyErr_Occurred()) SWIG_fail;
53611 }
53612 {
53613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53614 }
53615 return resultobj;
53616 fail:
53617 return NULL;
53618 }
53619
53620
53621 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53622 PyObject *resultobj = 0;
53623 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53624 wxGBSizerItem *arg2 = 0 ;
53625 bool result;
53626 void *argp1 = 0 ;
53627 int res1 = 0 ;
53628 void *argp2 = 0 ;
53629 int res2 = 0 ;
53630 PyObject * obj0 = 0 ;
53631 PyObject * obj1 = 0 ;
53632 char * kwnames[] = {
53633 (char *) "self",(char *) "other", NULL
53634 };
53635
53636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53638 if (!SWIG_IsOK(res1)) {
53639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53640 }
53641 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53642 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53643 if (!SWIG_IsOK(res2)) {
53644 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53645 }
53646 if (!argp2) {
53647 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53648 }
53649 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53650 {
53651 PyThreadState* __tstate = wxPyBeginAllowThreads();
53652 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53653 wxPyEndAllowThreads(__tstate);
53654 if (PyErr_Occurred()) SWIG_fail;
53655 }
53656 {
53657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53658 }
53659 return resultobj;
53660 fail:
53661 return NULL;
53662 }
53663
53664
53665 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53666 PyObject *resultobj = 0;
53667 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53668 wxGBPosition *arg2 = 0 ;
53669 wxGBSpan *arg3 = 0 ;
53670 bool result;
53671 void *argp1 = 0 ;
53672 int res1 = 0 ;
53673 wxGBPosition temp2 ;
53674 wxGBSpan temp3 ;
53675 PyObject * obj0 = 0 ;
53676 PyObject * obj1 = 0 ;
53677 PyObject * obj2 = 0 ;
53678 char * kwnames[] = {
53679 (char *) "self",(char *) "pos",(char *) "span", NULL
53680 };
53681
53682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53684 if (!SWIG_IsOK(res1)) {
53685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53686 }
53687 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53688 {
53689 arg2 = &temp2;
53690 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53691 }
53692 {
53693 arg3 = &temp3;
53694 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53695 }
53696 {
53697 PyThreadState* __tstate = wxPyBeginAllowThreads();
53698 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53699 wxPyEndAllowThreads(__tstate);
53700 if (PyErr_Occurred()) SWIG_fail;
53701 }
53702 {
53703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53704 }
53705 return resultobj;
53706 fail:
53707 return NULL;
53708 }
53709
53710
53711 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53712 PyObject *resultobj = 0;
53713 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53714 wxGBPosition result;
53715 void *argp1 = 0 ;
53716 int res1 = 0 ;
53717 PyObject *swig_obj[1] ;
53718
53719 if (!args) SWIG_fail;
53720 swig_obj[0] = args;
53721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53722 if (!SWIG_IsOK(res1)) {
53723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53724 }
53725 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53726 {
53727 PyThreadState* __tstate = wxPyBeginAllowThreads();
53728 result = wxGBSizerItem_GetEndPos(arg1);
53729 wxPyEndAllowThreads(__tstate);
53730 if (PyErr_Occurred()) SWIG_fail;
53731 }
53732 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53733 return resultobj;
53734 fail:
53735 return NULL;
53736 }
53737
53738
53739 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53740 PyObject *resultobj = 0;
53741 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53742 wxGridBagSizer *result = 0 ;
53743 void *argp1 = 0 ;
53744 int res1 = 0 ;
53745 PyObject *swig_obj[1] ;
53746
53747 if (!args) SWIG_fail;
53748 swig_obj[0] = args;
53749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53750 if (!SWIG_IsOK(res1)) {
53751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53752 }
53753 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53754 {
53755 PyThreadState* __tstate = wxPyBeginAllowThreads();
53756 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53757 wxPyEndAllowThreads(__tstate);
53758 if (PyErr_Occurred()) SWIG_fail;
53759 }
53760 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53761 return resultobj;
53762 fail:
53763 return NULL;
53764 }
53765
53766
53767 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53768 PyObject *resultobj = 0;
53769 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53770 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53771 void *argp1 = 0 ;
53772 int res1 = 0 ;
53773 void *argp2 = 0 ;
53774 int res2 = 0 ;
53775 PyObject * obj0 = 0 ;
53776 PyObject * obj1 = 0 ;
53777 char * kwnames[] = {
53778 (char *) "self",(char *) "sizer", NULL
53779 };
53780
53781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53783 if (!SWIG_IsOK(res1)) {
53784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53785 }
53786 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53787 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53788 if (!SWIG_IsOK(res2)) {
53789 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53790 }
53791 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53792 {
53793 PyThreadState* __tstate = wxPyBeginAllowThreads();
53794 (arg1)->SetGBSizer(arg2);
53795 wxPyEndAllowThreads(__tstate);
53796 if (PyErr_Occurred()) SWIG_fail;
53797 }
53798 resultobj = SWIG_Py_Void();
53799 return resultobj;
53800 fail:
53801 return NULL;
53802 }
53803
53804
53805 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53806 PyObject *obj;
53807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53808 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
53809 return SWIG_Py_Void();
53810 }
53811
53812 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53813 return SWIG_Python_InitShadowInstance(args);
53814 }
53815
53816 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53817 PyObject *resultobj = 0;
53818 int arg1 = (int) 0 ;
53819 int arg2 = (int) 0 ;
53820 wxGridBagSizer *result = 0 ;
53821 int val1 ;
53822 int ecode1 = 0 ;
53823 int val2 ;
53824 int ecode2 = 0 ;
53825 PyObject * obj0 = 0 ;
53826 PyObject * obj1 = 0 ;
53827 char * kwnames[] = {
53828 (char *) "vgap",(char *) "hgap", NULL
53829 };
53830
53831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53832 if (obj0) {
53833 ecode1 = SWIG_AsVal_int(obj0, &val1);
53834 if (!SWIG_IsOK(ecode1)) {
53835 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
53836 }
53837 arg1 = static_cast< int >(val1);
53838 }
53839 if (obj1) {
53840 ecode2 = SWIG_AsVal_int(obj1, &val2);
53841 if (!SWIG_IsOK(ecode2)) {
53842 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
53843 }
53844 arg2 = static_cast< int >(val2);
53845 }
53846 {
53847 PyThreadState* __tstate = wxPyBeginAllowThreads();
53848 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
53849 wxPyEndAllowThreads(__tstate);
53850 if (PyErr_Occurred()) SWIG_fail;
53851 }
53852 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
53853 return resultobj;
53854 fail:
53855 return NULL;
53856 }
53857
53858
53859 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53860 PyObject *resultobj = 0;
53861 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53862 PyObject *arg2 = (PyObject *) 0 ;
53863 wxGBPosition *arg3 = 0 ;
53864 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
53865 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
53866 int arg5 = (int) 0 ;
53867 int arg6 = (int) 0 ;
53868 PyObject *arg7 = (PyObject *) NULL ;
53869 wxGBSizerItem *result = 0 ;
53870 void *argp1 = 0 ;
53871 int res1 = 0 ;
53872 wxGBPosition temp3 ;
53873 wxGBSpan temp4 ;
53874 int val5 ;
53875 int ecode5 = 0 ;
53876 int val6 ;
53877 int ecode6 = 0 ;
53878 PyObject * obj0 = 0 ;
53879 PyObject * obj1 = 0 ;
53880 PyObject * obj2 = 0 ;
53881 PyObject * obj3 = 0 ;
53882 PyObject * obj4 = 0 ;
53883 PyObject * obj5 = 0 ;
53884 PyObject * obj6 = 0 ;
53885 char * kwnames[] = {
53886 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53887 };
53888
53889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53891 if (!SWIG_IsOK(res1)) {
53892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53893 }
53894 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53895 arg2 = obj1;
53896 {
53897 arg3 = &temp3;
53898 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53899 }
53900 if (obj3) {
53901 {
53902 arg4 = &temp4;
53903 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53904 }
53905 }
53906 if (obj4) {
53907 ecode5 = SWIG_AsVal_int(obj4, &val5);
53908 if (!SWIG_IsOK(ecode5)) {
53909 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
53910 }
53911 arg5 = static_cast< int >(val5);
53912 }
53913 if (obj5) {
53914 ecode6 = SWIG_AsVal_int(obj5, &val6);
53915 if (!SWIG_IsOK(ecode6)) {
53916 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
53917 }
53918 arg6 = static_cast< int >(val6);
53919 }
53920 if (obj6) {
53921 arg7 = obj6;
53922 }
53923 {
53924 PyThreadState* __tstate = wxPyBeginAllowThreads();
53925 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53926 wxPyEndAllowThreads(__tstate);
53927 if (PyErr_Occurred()) SWIG_fail;
53928 }
53929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53930 return resultobj;
53931 fail:
53932 return NULL;
53933 }
53934
53935
53936 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53937 PyObject *resultobj = 0;
53938 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53939 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
53940 wxGBSizerItem *result = 0 ;
53941 void *argp1 = 0 ;
53942 int res1 = 0 ;
53943 int res2 = 0 ;
53944 PyObject * obj0 = 0 ;
53945 PyObject * obj1 = 0 ;
53946 char * kwnames[] = {
53947 (char *) "self",(char *) "item", NULL
53948 };
53949
53950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
53951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53952 if (!SWIG_IsOK(res1)) {
53953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
53954 }
53955 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53956 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53957 if (!SWIG_IsOK(res2)) {
53958 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
53959 }
53960 {
53961 PyThreadState* __tstate = wxPyBeginAllowThreads();
53962 result = (wxGBSizerItem *)(arg1)->Add(arg2);
53963 wxPyEndAllowThreads(__tstate);
53964 if (PyErr_Occurred()) SWIG_fail;
53965 }
53966 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53967 return resultobj;
53968 fail:
53969 return NULL;
53970 }
53971
53972
53973 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53974 PyObject *resultobj = 0;
53975 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
53976 int arg2 ;
53977 int arg3 ;
53978 wxSize result;
53979 void *argp1 = 0 ;
53980 int res1 = 0 ;
53981 int val2 ;
53982 int ecode2 = 0 ;
53983 int val3 ;
53984 int ecode3 = 0 ;
53985 PyObject * obj0 = 0 ;
53986 PyObject * obj1 = 0 ;
53987 PyObject * obj2 = 0 ;
53988 char * kwnames[] = {
53989 (char *) "self",(char *) "row",(char *) "col", NULL
53990 };
53991
53992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53994 if (!SWIG_IsOK(res1)) {
53995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
53996 }
53997 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
53998 ecode2 = SWIG_AsVal_int(obj1, &val2);
53999 if (!SWIG_IsOK(ecode2)) {
54000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54001 }
54002 arg2 = static_cast< int >(val2);
54003 ecode3 = SWIG_AsVal_int(obj2, &val3);
54004 if (!SWIG_IsOK(ecode3)) {
54005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54006 }
54007 arg3 = static_cast< int >(val3);
54008 {
54009 PyThreadState* __tstate = wxPyBeginAllowThreads();
54010 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54011 wxPyEndAllowThreads(__tstate);
54012 if (PyErr_Occurred()) SWIG_fail;
54013 }
54014 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54015 return resultobj;
54016 fail:
54017 return NULL;
54018 }
54019
54020
54021 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54022 PyObject *resultobj = 0;
54023 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54024 wxSize result;
54025 void *argp1 = 0 ;
54026 int res1 = 0 ;
54027 PyObject *swig_obj[1] ;
54028
54029 if (!args) SWIG_fail;
54030 swig_obj[0] = args;
54031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54032 if (!SWIG_IsOK(res1)) {
54033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54034 }
54035 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54036 {
54037 PyThreadState* __tstate = wxPyBeginAllowThreads();
54038 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54039 wxPyEndAllowThreads(__tstate);
54040 if (PyErr_Occurred()) SWIG_fail;
54041 }
54042 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54043 return resultobj;
54044 fail:
54045 return NULL;
54046 }
54047
54048
54049 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54050 PyObject *resultobj = 0;
54051 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54052 wxSize *arg2 = 0 ;
54053 void *argp1 = 0 ;
54054 int res1 = 0 ;
54055 wxSize temp2 ;
54056 PyObject * obj0 = 0 ;
54057 PyObject * obj1 = 0 ;
54058 char * kwnames[] = {
54059 (char *) "self",(char *) "sz", NULL
54060 };
54061
54062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54064 if (!SWIG_IsOK(res1)) {
54065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54066 }
54067 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54068 {
54069 arg2 = &temp2;
54070 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54071 }
54072 {
54073 PyThreadState* __tstate = wxPyBeginAllowThreads();
54074 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54075 wxPyEndAllowThreads(__tstate);
54076 if (PyErr_Occurred()) SWIG_fail;
54077 }
54078 resultobj = SWIG_Py_Void();
54079 return resultobj;
54080 fail:
54081 return NULL;
54082 }
54083
54084
54085 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54086 PyObject *resultobj = 0;
54087 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54088 wxWindow *arg2 = (wxWindow *) 0 ;
54089 wxGBPosition result;
54090 void *argp1 = 0 ;
54091 int res1 = 0 ;
54092 void *argp2 = 0 ;
54093 int res2 = 0 ;
54094
54095 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54097 if (!SWIG_IsOK(res1)) {
54098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54099 }
54100 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54101 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54102 if (!SWIG_IsOK(res2)) {
54103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54104 }
54105 arg2 = reinterpret_cast< wxWindow * >(argp2);
54106 {
54107 PyThreadState* __tstate = wxPyBeginAllowThreads();
54108 result = (arg1)->GetItemPosition(arg2);
54109 wxPyEndAllowThreads(__tstate);
54110 if (PyErr_Occurred()) SWIG_fail;
54111 }
54112 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54113 return resultobj;
54114 fail:
54115 return NULL;
54116 }
54117
54118
54119 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54120 PyObject *resultobj = 0;
54121 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54122 wxSizer *arg2 = (wxSizer *) 0 ;
54123 wxGBPosition result;
54124 void *argp1 = 0 ;
54125 int res1 = 0 ;
54126 void *argp2 = 0 ;
54127 int res2 = 0 ;
54128
54129 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54131 if (!SWIG_IsOK(res1)) {
54132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54133 }
54134 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54135 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54136 if (!SWIG_IsOK(res2)) {
54137 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54138 }
54139 arg2 = reinterpret_cast< wxSizer * >(argp2);
54140 {
54141 PyThreadState* __tstate = wxPyBeginAllowThreads();
54142 result = (arg1)->GetItemPosition(arg2);
54143 wxPyEndAllowThreads(__tstate);
54144 if (PyErr_Occurred()) SWIG_fail;
54145 }
54146 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54147 return resultobj;
54148 fail:
54149 return NULL;
54150 }
54151
54152
54153 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54154 PyObject *resultobj = 0;
54155 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54156 size_t arg2 ;
54157 wxGBPosition result;
54158 void *argp1 = 0 ;
54159 int res1 = 0 ;
54160 size_t val2 ;
54161 int ecode2 = 0 ;
54162
54163 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54165 if (!SWIG_IsOK(res1)) {
54166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54167 }
54168 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54169 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54170 if (!SWIG_IsOK(ecode2)) {
54171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54172 }
54173 arg2 = static_cast< size_t >(val2);
54174 {
54175 PyThreadState* __tstate = wxPyBeginAllowThreads();
54176 result = (arg1)->GetItemPosition(arg2);
54177 wxPyEndAllowThreads(__tstate);
54178 if (PyErr_Occurred()) SWIG_fail;
54179 }
54180 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54181 return resultobj;
54182 fail:
54183 return NULL;
54184 }
54185
54186
54187 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54188 int argc;
54189 PyObject *argv[3];
54190
54191 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54192 --argc;
54193 if (argc == 2) {
54194 int _v = 0;
54195 {
54196 void *vptr = 0;
54197 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54198 _v = SWIG_CheckState(res);
54199 }
54200 if (!_v) goto check_1;
54201 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54202 }
54203 check_1:
54204
54205 if (argc == 2) {
54206 int _v = 0;
54207 {
54208 void *vptr = 0;
54209 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54210 _v = SWIG_CheckState(res);
54211 }
54212 if (!_v) goto check_2;
54213 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54214 }
54215 check_2:
54216
54217 if (argc == 2) {
54218 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54219 }
54220
54221 fail:
54222 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54223 return NULL;
54224 }
54225
54226
54227 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54228 PyObject *resultobj = 0;
54229 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54230 wxWindow *arg2 = (wxWindow *) 0 ;
54231 wxGBPosition *arg3 = 0 ;
54232 bool result;
54233 void *argp1 = 0 ;
54234 int res1 = 0 ;
54235 void *argp2 = 0 ;
54236 int res2 = 0 ;
54237 wxGBPosition temp3 ;
54238
54239 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54241 if (!SWIG_IsOK(res1)) {
54242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54243 }
54244 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54245 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54246 if (!SWIG_IsOK(res2)) {
54247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54248 }
54249 arg2 = reinterpret_cast< wxWindow * >(argp2);
54250 {
54251 arg3 = &temp3;
54252 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54253 }
54254 {
54255 PyThreadState* __tstate = wxPyBeginAllowThreads();
54256 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54257 wxPyEndAllowThreads(__tstate);
54258 if (PyErr_Occurred()) SWIG_fail;
54259 }
54260 {
54261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54262 }
54263 return resultobj;
54264 fail:
54265 return NULL;
54266 }
54267
54268
54269 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54270 PyObject *resultobj = 0;
54271 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54272 wxSizer *arg2 = (wxSizer *) 0 ;
54273 wxGBPosition *arg3 = 0 ;
54274 bool result;
54275 void *argp1 = 0 ;
54276 int res1 = 0 ;
54277 void *argp2 = 0 ;
54278 int res2 = 0 ;
54279 wxGBPosition temp3 ;
54280
54281 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54283 if (!SWIG_IsOK(res1)) {
54284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54285 }
54286 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54287 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54288 if (!SWIG_IsOK(res2)) {
54289 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54290 }
54291 arg2 = reinterpret_cast< wxSizer * >(argp2);
54292 {
54293 arg3 = &temp3;
54294 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54295 }
54296 {
54297 PyThreadState* __tstate = wxPyBeginAllowThreads();
54298 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54299 wxPyEndAllowThreads(__tstate);
54300 if (PyErr_Occurred()) SWIG_fail;
54301 }
54302 {
54303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54304 }
54305 return resultobj;
54306 fail:
54307 return NULL;
54308 }
54309
54310
54311 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54312 PyObject *resultobj = 0;
54313 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54314 size_t arg2 ;
54315 wxGBPosition *arg3 = 0 ;
54316 bool result;
54317 void *argp1 = 0 ;
54318 int res1 = 0 ;
54319 size_t val2 ;
54320 int ecode2 = 0 ;
54321 wxGBPosition temp3 ;
54322
54323 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54325 if (!SWIG_IsOK(res1)) {
54326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54327 }
54328 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54329 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54330 if (!SWIG_IsOK(ecode2)) {
54331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54332 }
54333 arg2 = static_cast< size_t >(val2);
54334 {
54335 arg3 = &temp3;
54336 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54337 }
54338 {
54339 PyThreadState* __tstate = wxPyBeginAllowThreads();
54340 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54341 wxPyEndAllowThreads(__tstate);
54342 if (PyErr_Occurred()) SWIG_fail;
54343 }
54344 {
54345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54346 }
54347 return resultobj;
54348 fail:
54349 return NULL;
54350 }
54351
54352
54353 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54354 int argc;
54355 PyObject *argv[4];
54356
54357 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54358 --argc;
54359 if (argc == 3) {
54360 int _v = 0;
54361 {
54362 void *vptr = 0;
54363 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54364 _v = SWIG_CheckState(res);
54365 }
54366 if (!_v) goto check_1;
54367 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54368 }
54369 check_1:
54370
54371 if (argc == 3) {
54372 int _v = 0;
54373 {
54374 void *vptr = 0;
54375 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54376 _v = SWIG_CheckState(res);
54377 }
54378 if (!_v) goto check_2;
54379 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54380 }
54381 check_2:
54382
54383 if (argc == 3) {
54384 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54385 }
54386
54387 fail:
54388 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54389 return NULL;
54390 }
54391
54392
54393 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54394 PyObject *resultobj = 0;
54395 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54396 wxWindow *arg2 = (wxWindow *) 0 ;
54397 wxGBSpan result;
54398 void *argp1 = 0 ;
54399 int res1 = 0 ;
54400 void *argp2 = 0 ;
54401 int res2 = 0 ;
54402
54403 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54405 if (!SWIG_IsOK(res1)) {
54406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54407 }
54408 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54409 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54410 if (!SWIG_IsOK(res2)) {
54411 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54412 }
54413 arg2 = reinterpret_cast< wxWindow * >(argp2);
54414 {
54415 PyThreadState* __tstate = wxPyBeginAllowThreads();
54416 result = (arg1)->GetItemSpan(arg2);
54417 wxPyEndAllowThreads(__tstate);
54418 if (PyErr_Occurred()) SWIG_fail;
54419 }
54420 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54421 return resultobj;
54422 fail:
54423 return NULL;
54424 }
54425
54426
54427 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54428 PyObject *resultobj = 0;
54429 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54430 wxSizer *arg2 = (wxSizer *) 0 ;
54431 wxGBSpan result;
54432 void *argp1 = 0 ;
54433 int res1 = 0 ;
54434 void *argp2 = 0 ;
54435 int res2 = 0 ;
54436
54437 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54439 if (!SWIG_IsOK(res1)) {
54440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54441 }
54442 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54443 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54444 if (!SWIG_IsOK(res2)) {
54445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54446 }
54447 arg2 = reinterpret_cast< wxSizer * >(argp2);
54448 {
54449 PyThreadState* __tstate = wxPyBeginAllowThreads();
54450 result = (arg1)->GetItemSpan(arg2);
54451 wxPyEndAllowThreads(__tstate);
54452 if (PyErr_Occurred()) SWIG_fail;
54453 }
54454 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54455 return resultobj;
54456 fail:
54457 return NULL;
54458 }
54459
54460
54461 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54462 PyObject *resultobj = 0;
54463 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54464 size_t arg2 ;
54465 wxGBSpan result;
54466 void *argp1 = 0 ;
54467 int res1 = 0 ;
54468 size_t val2 ;
54469 int ecode2 = 0 ;
54470
54471 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54473 if (!SWIG_IsOK(res1)) {
54474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54475 }
54476 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54477 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54478 if (!SWIG_IsOK(ecode2)) {
54479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54480 }
54481 arg2 = static_cast< size_t >(val2);
54482 {
54483 PyThreadState* __tstate = wxPyBeginAllowThreads();
54484 result = (arg1)->GetItemSpan(arg2);
54485 wxPyEndAllowThreads(__tstate);
54486 if (PyErr_Occurred()) SWIG_fail;
54487 }
54488 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54489 return resultobj;
54490 fail:
54491 return NULL;
54492 }
54493
54494
54495 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54496 int argc;
54497 PyObject *argv[3];
54498
54499 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54500 --argc;
54501 if (argc == 2) {
54502 int _v = 0;
54503 {
54504 void *vptr = 0;
54505 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54506 _v = SWIG_CheckState(res);
54507 }
54508 if (!_v) goto check_1;
54509 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54510 }
54511 check_1:
54512
54513 if (argc == 2) {
54514 int _v = 0;
54515 {
54516 void *vptr = 0;
54517 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54518 _v = SWIG_CheckState(res);
54519 }
54520 if (!_v) goto check_2;
54521 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54522 }
54523 check_2:
54524
54525 if (argc == 2) {
54526 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54527 }
54528
54529 fail:
54530 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54531 return NULL;
54532 }
54533
54534
54535 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54536 PyObject *resultobj = 0;
54537 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54538 wxWindow *arg2 = (wxWindow *) 0 ;
54539 wxGBSpan *arg3 = 0 ;
54540 bool result;
54541 void *argp1 = 0 ;
54542 int res1 = 0 ;
54543 void *argp2 = 0 ;
54544 int res2 = 0 ;
54545 wxGBSpan temp3 ;
54546
54547 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54549 if (!SWIG_IsOK(res1)) {
54550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54551 }
54552 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54553 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54554 if (!SWIG_IsOK(res2)) {
54555 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54556 }
54557 arg2 = reinterpret_cast< wxWindow * >(argp2);
54558 {
54559 arg3 = &temp3;
54560 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54561 }
54562 {
54563 PyThreadState* __tstate = wxPyBeginAllowThreads();
54564 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54565 wxPyEndAllowThreads(__tstate);
54566 if (PyErr_Occurred()) SWIG_fail;
54567 }
54568 {
54569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54570 }
54571 return resultobj;
54572 fail:
54573 return NULL;
54574 }
54575
54576
54577 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54578 PyObject *resultobj = 0;
54579 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54580 wxSizer *arg2 = (wxSizer *) 0 ;
54581 wxGBSpan *arg3 = 0 ;
54582 bool result;
54583 void *argp1 = 0 ;
54584 int res1 = 0 ;
54585 void *argp2 = 0 ;
54586 int res2 = 0 ;
54587 wxGBSpan temp3 ;
54588
54589 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54591 if (!SWIG_IsOK(res1)) {
54592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54593 }
54594 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54595 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54596 if (!SWIG_IsOK(res2)) {
54597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54598 }
54599 arg2 = reinterpret_cast< wxSizer * >(argp2);
54600 {
54601 arg3 = &temp3;
54602 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54603 }
54604 {
54605 PyThreadState* __tstate = wxPyBeginAllowThreads();
54606 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54607 wxPyEndAllowThreads(__tstate);
54608 if (PyErr_Occurred()) SWIG_fail;
54609 }
54610 {
54611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54612 }
54613 return resultobj;
54614 fail:
54615 return NULL;
54616 }
54617
54618
54619 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54620 PyObject *resultobj = 0;
54621 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54622 size_t arg2 ;
54623 wxGBSpan *arg3 = 0 ;
54624 bool result;
54625 void *argp1 = 0 ;
54626 int res1 = 0 ;
54627 size_t val2 ;
54628 int ecode2 = 0 ;
54629 wxGBSpan temp3 ;
54630
54631 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54633 if (!SWIG_IsOK(res1)) {
54634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54635 }
54636 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54637 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54638 if (!SWIG_IsOK(ecode2)) {
54639 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54640 }
54641 arg2 = static_cast< size_t >(val2);
54642 {
54643 arg3 = &temp3;
54644 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54645 }
54646 {
54647 PyThreadState* __tstate = wxPyBeginAllowThreads();
54648 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54649 wxPyEndAllowThreads(__tstate);
54650 if (PyErr_Occurred()) SWIG_fail;
54651 }
54652 {
54653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54654 }
54655 return resultobj;
54656 fail:
54657 return NULL;
54658 }
54659
54660
54661 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54662 int argc;
54663 PyObject *argv[4];
54664
54665 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54666 --argc;
54667 if (argc == 3) {
54668 int _v = 0;
54669 {
54670 void *vptr = 0;
54671 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54672 _v = SWIG_CheckState(res);
54673 }
54674 if (!_v) goto check_1;
54675 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54676 }
54677 check_1:
54678
54679 if (argc == 3) {
54680 int _v = 0;
54681 {
54682 void *vptr = 0;
54683 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54684 _v = SWIG_CheckState(res);
54685 }
54686 if (!_v) goto check_2;
54687 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54688 }
54689 check_2:
54690
54691 if (argc == 3) {
54692 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54693 }
54694
54695 fail:
54696 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54697 return NULL;
54698 }
54699
54700
54701 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54702 PyObject *resultobj = 0;
54703 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54704 wxWindow *arg2 = (wxWindow *) 0 ;
54705 wxGBSizerItem *result = 0 ;
54706 void *argp1 = 0 ;
54707 int res1 = 0 ;
54708 void *argp2 = 0 ;
54709 int res2 = 0 ;
54710
54711 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54713 if (!SWIG_IsOK(res1)) {
54714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54715 }
54716 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54717 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54718 if (!SWIG_IsOK(res2)) {
54719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54720 }
54721 arg2 = reinterpret_cast< wxWindow * >(argp2);
54722 {
54723 PyThreadState* __tstate = wxPyBeginAllowThreads();
54724 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54725 wxPyEndAllowThreads(__tstate);
54726 if (PyErr_Occurred()) SWIG_fail;
54727 }
54728 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54729 return resultobj;
54730 fail:
54731 return NULL;
54732 }
54733
54734
54735 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54736 PyObject *resultobj = 0;
54737 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54738 wxSizer *arg2 = (wxSizer *) 0 ;
54739 wxGBSizerItem *result = 0 ;
54740 void *argp1 = 0 ;
54741 int res1 = 0 ;
54742 void *argp2 = 0 ;
54743 int res2 = 0 ;
54744
54745 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54747 if (!SWIG_IsOK(res1)) {
54748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54749 }
54750 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54751 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54752 if (!SWIG_IsOK(res2)) {
54753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54754 }
54755 arg2 = reinterpret_cast< wxSizer * >(argp2);
54756 {
54757 PyThreadState* __tstate = wxPyBeginAllowThreads();
54758 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54759 wxPyEndAllowThreads(__tstate);
54760 if (PyErr_Occurred()) SWIG_fail;
54761 }
54762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54763 return resultobj;
54764 fail:
54765 return NULL;
54766 }
54767
54768
54769 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54770 int argc;
54771 PyObject *argv[3];
54772
54773 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54774 --argc;
54775 if (argc == 2) {
54776 int _v = 0;
54777 {
54778 void *vptr = 0;
54779 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54780 _v = SWIG_CheckState(res);
54781 }
54782 if (!_v) goto check_1;
54783 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54784 }
54785 check_1:
54786
54787 if (argc == 2) {
54788 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54789 }
54790
54791 fail:
54792 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54793 return NULL;
54794 }
54795
54796
54797 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54798 PyObject *resultobj = 0;
54799 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54800 wxGBPosition *arg2 = 0 ;
54801 wxGBSizerItem *result = 0 ;
54802 void *argp1 = 0 ;
54803 int res1 = 0 ;
54804 wxGBPosition temp2 ;
54805 PyObject * obj0 = 0 ;
54806 PyObject * obj1 = 0 ;
54807 char * kwnames[] = {
54808 (char *) "self",(char *) "pos", NULL
54809 };
54810
54811 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
54812 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54813 if (!SWIG_IsOK(res1)) {
54814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54815 }
54816 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54817 {
54818 arg2 = &temp2;
54819 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54820 }
54821 {
54822 PyThreadState* __tstate = wxPyBeginAllowThreads();
54823 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
54824 wxPyEndAllowThreads(__tstate);
54825 if (PyErr_Occurred()) SWIG_fail;
54826 }
54827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54828 return resultobj;
54829 fail:
54830 return NULL;
54831 }
54832
54833
54834 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54835 PyObject *resultobj = 0;
54836 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54837 wxPoint *arg2 = 0 ;
54838 wxGBSizerItem *result = 0 ;
54839 void *argp1 = 0 ;
54840 int res1 = 0 ;
54841 wxPoint temp2 ;
54842 PyObject * obj0 = 0 ;
54843 PyObject * obj1 = 0 ;
54844 char * kwnames[] = {
54845 (char *) "self",(char *) "pt", NULL
54846 };
54847
54848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
54849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54850 if (!SWIG_IsOK(res1)) {
54851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54852 }
54853 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54854 {
54855 arg2 = &temp2;
54856 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
54857 }
54858 {
54859 PyThreadState* __tstate = wxPyBeginAllowThreads();
54860 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
54861 wxPyEndAllowThreads(__tstate);
54862 if (PyErr_Occurred()) SWIG_fail;
54863 }
54864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54865 return resultobj;
54866 fail:
54867 return NULL;
54868 }
54869
54870
54871 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54872 PyObject *resultobj = 0;
54873 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54874 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54875 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
54876 bool result;
54877 void *argp1 = 0 ;
54878 int res1 = 0 ;
54879 void *argp2 = 0 ;
54880 int res2 = 0 ;
54881 void *argp3 = 0 ;
54882 int res3 = 0 ;
54883 PyObject * obj0 = 0 ;
54884 PyObject * obj1 = 0 ;
54885 PyObject * obj2 = 0 ;
54886 char * kwnames[] = {
54887 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
54888 };
54889
54890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54892 if (!SWIG_IsOK(res1)) {
54893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54894 }
54895 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54897 if (!SWIG_IsOK(res2)) {
54898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54899 }
54900 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
54901 if (obj2) {
54902 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54903 if (!SWIG_IsOK(res3)) {
54904 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
54905 }
54906 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
54907 }
54908 {
54909 PyThreadState* __tstate = wxPyBeginAllowThreads();
54910 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
54911 wxPyEndAllowThreads(__tstate);
54912 if (PyErr_Occurred()) SWIG_fail;
54913 }
54914 {
54915 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54916 }
54917 return resultobj;
54918 fail:
54919 return NULL;
54920 }
54921
54922
54923 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54924 PyObject *resultobj = 0;
54925 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54926 wxGBPosition *arg2 = 0 ;
54927 wxGBSpan *arg3 = 0 ;
54928 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
54929 bool result;
54930 void *argp1 = 0 ;
54931 int res1 = 0 ;
54932 wxGBPosition temp2 ;
54933 wxGBSpan temp3 ;
54934 void *argp4 = 0 ;
54935 int res4 = 0 ;
54936 PyObject * obj0 = 0 ;
54937 PyObject * obj1 = 0 ;
54938 PyObject * obj2 = 0 ;
54939 PyObject * obj3 = 0 ;
54940 char * kwnames[] = {
54941 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
54942 };
54943
54944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
54945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54946 if (!SWIG_IsOK(res1)) {
54947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54948 }
54949 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54950 {
54951 arg2 = &temp2;
54952 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
54953 }
54954 {
54955 arg3 = &temp3;
54956 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
54957 }
54958 if (obj3) {
54959 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54960 if (!SWIG_IsOK(res4)) {
54961 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
54962 }
54963 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
54964 }
54965 {
54966 PyThreadState* __tstate = wxPyBeginAllowThreads();
54967 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
54968 wxPyEndAllowThreads(__tstate);
54969 if (PyErr_Occurred()) SWIG_fail;
54970 }
54971 {
54972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54973 }
54974 return resultobj;
54975 fail:
54976 return NULL;
54977 }
54978
54979
54980 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54981 PyObject *obj;
54982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54983 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
54984 return SWIG_Py_Void();
54985 }
54986
54987 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54988 return SWIG_Python_InitShadowInstance(args);
54989 }
54990
54991 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54992 PyObject *resultobj = 0;
54993 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
54994 wxRelationship arg2 ;
54995 wxWindow *arg3 = (wxWindow *) 0 ;
54996 wxEdge arg4 ;
54997 int arg5 = (int) 0 ;
54998 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
54999 void *argp1 = 0 ;
55000 int res1 = 0 ;
55001 int val2 ;
55002 int ecode2 = 0 ;
55003 void *argp3 = 0 ;
55004 int res3 = 0 ;
55005 int val4 ;
55006 int ecode4 = 0 ;
55007 int val5 ;
55008 int ecode5 = 0 ;
55009 int val6 ;
55010 int ecode6 = 0 ;
55011 PyObject * obj0 = 0 ;
55012 PyObject * obj1 = 0 ;
55013 PyObject * obj2 = 0 ;
55014 PyObject * obj3 = 0 ;
55015 PyObject * obj4 = 0 ;
55016 PyObject * obj5 = 0 ;
55017 char * kwnames[] = {
55018 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55019 };
55020
55021 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55022 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55023 if (!SWIG_IsOK(res1)) {
55024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55025 }
55026 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55027 ecode2 = SWIG_AsVal_int(obj1, &val2);
55028 if (!SWIG_IsOK(ecode2)) {
55029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55030 }
55031 arg2 = static_cast< wxRelationship >(val2);
55032 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55033 if (!SWIG_IsOK(res3)) {
55034 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55035 }
55036 arg3 = reinterpret_cast< wxWindow * >(argp3);
55037 ecode4 = SWIG_AsVal_int(obj3, &val4);
55038 if (!SWIG_IsOK(ecode4)) {
55039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55040 }
55041 arg4 = static_cast< wxEdge >(val4);
55042 if (obj4) {
55043 ecode5 = SWIG_AsVal_int(obj4, &val5);
55044 if (!SWIG_IsOK(ecode5)) {
55045 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55046 }
55047 arg5 = static_cast< int >(val5);
55048 }
55049 if (obj5) {
55050 ecode6 = SWIG_AsVal_int(obj5, &val6);
55051 if (!SWIG_IsOK(ecode6)) {
55052 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55053 }
55054 arg6 = static_cast< int >(val6);
55055 }
55056 {
55057 PyThreadState* __tstate = wxPyBeginAllowThreads();
55058 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55059 wxPyEndAllowThreads(__tstate);
55060 if (PyErr_Occurred()) SWIG_fail;
55061 }
55062 resultobj = SWIG_Py_Void();
55063 return resultobj;
55064 fail:
55065 return NULL;
55066 }
55067
55068
55069 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55070 PyObject *resultobj = 0;
55071 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55072 wxWindow *arg2 = (wxWindow *) 0 ;
55073 int arg3 = (int) 0 ;
55074 void *argp1 = 0 ;
55075 int res1 = 0 ;
55076 void *argp2 = 0 ;
55077 int res2 = 0 ;
55078 int val3 ;
55079 int ecode3 = 0 ;
55080 PyObject * obj0 = 0 ;
55081 PyObject * obj1 = 0 ;
55082 PyObject * obj2 = 0 ;
55083 char * kwnames[] = {
55084 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55085 };
55086
55087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55089 if (!SWIG_IsOK(res1)) {
55090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55091 }
55092 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55093 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55094 if (!SWIG_IsOK(res2)) {
55095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55096 }
55097 arg2 = reinterpret_cast< wxWindow * >(argp2);
55098 if (obj2) {
55099 ecode3 = SWIG_AsVal_int(obj2, &val3);
55100 if (!SWIG_IsOK(ecode3)) {
55101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55102 }
55103 arg3 = static_cast< int >(val3);
55104 }
55105 {
55106 PyThreadState* __tstate = wxPyBeginAllowThreads();
55107 (arg1)->LeftOf(arg2,arg3);
55108 wxPyEndAllowThreads(__tstate);
55109 if (PyErr_Occurred()) SWIG_fail;
55110 }
55111 resultobj = SWIG_Py_Void();
55112 return resultobj;
55113 fail:
55114 return NULL;
55115 }
55116
55117
55118 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55119 PyObject *resultobj = 0;
55120 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55121 wxWindow *arg2 = (wxWindow *) 0 ;
55122 int arg3 = (int) 0 ;
55123 void *argp1 = 0 ;
55124 int res1 = 0 ;
55125 void *argp2 = 0 ;
55126 int res2 = 0 ;
55127 int val3 ;
55128 int ecode3 = 0 ;
55129 PyObject * obj0 = 0 ;
55130 PyObject * obj1 = 0 ;
55131 PyObject * obj2 = 0 ;
55132 char * kwnames[] = {
55133 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55134 };
55135
55136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55138 if (!SWIG_IsOK(res1)) {
55139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55140 }
55141 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55143 if (!SWIG_IsOK(res2)) {
55144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55145 }
55146 arg2 = reinterpret_cast< wxWindow * >(argp2);
55147 if (obj2) {
55148 ecode3 = SWIG_AsVal_int(obj2, &val3);
55149 if (!SWIG_IsOK(ecode3)) {
55150 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55151 }
55152 arg3 = static_cast< int >(val3);
55153 }
55154 {
55155 PyThreadState* __tstate = wxPyBeginAllowThreads();
55156 (arg1)->RightOf(arg2,arg3);
55157 wxPyEndAllowThreads(__tstate);
55158 if (PyErr_Occurred()) SWIG_fail;
55159 }
55160 resultobj = SWIG_Py_Void();
55161 return resultobj;
55162 fail:
55163 return NULL;
55164 }
55165
55166
55167 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55168 PyObject *resultobj = 0;
55169 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55170 wxWindow *arg2 = (wxWindow *) 0 ;
55171 int arg3 = (int) 0 ;
55172 void *argp1 = 0 ;
55173 int res1 = 0 ;
55174 void *argp2 = 0 ;
55175 int res2 = 0 ;
55176 int val3 ;
55177 int ecode3 = 0 ;
55178 PyObject * obj0 = 0 ;
55179 PyObject * obj1 = 0 ;
55180 PyObject * obj2 = 0 ;
55181 char * kwnames[] = {
55182 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55183 };
55184
55185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55187 if (!SWIG_IsOK(res1)) {
55188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55189 }
55190 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55191 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55192 if (!SWIG_IsOK(res2)) {
55193 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55194 }
55195 arg2 = reinterpret_cast< wxWindow * >(argp2);
55196 if (obj2) {
55197 ecode3 = SWIG_AsVal_int(obj2, &val3);
55198 if (!SWIG_IsOK(ecode3)) {
55199 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55200 }
55201 arg3 = static_cast< int >(val3);
55202 }
55203 {
55204 PyThreadState* __tstate = wxPyBeginAllowThreads();
55205 (arg1)->Above(arg2,arg3);
55206 wxPyEndAllowThreads(__tstate);
55207 if (PyErr_Occurred()) SWIG_fail;
55208 }
55209 resultobj = SWIG_Py_Void();
55210 return resultobj;
55211 fail:
55212 return NULL;
55213 }
55214
55215
55216 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55217 PyObject *resultobj = 0;
55218 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55219 wxWindow *arg2 = (wxWindow *) 0 ;
55220 int arg3 = (int) 0 ;
55221 void *argp1 = 0 ;
55222 int res1 = 0 ;
55223 void *argp2 = 0 ;
55224 int res2 = 0 ;
55225 int val3 ;
55226 int ecode3 = 0 ;
55227 PyObject * obj0 = 0 ;
55228 PyObject * obj1 = 0 ;
55229 PyObject * obj2 = 0 ;
55230 char * kwnames[] = {
55231 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55232 };
55233
55234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55236 if (!SWIG_IsOK(res1)) {
55237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55238 }
55239 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55240 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55241 if (!SWIG_IsOK(res2)) {
55242 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55243 }
55244 arg2 = reinterpret_cast< wxWindow * >(argp2);
55245 if (obj2) {
55246 ecode3 = SWIG_AsVal_int(obj2, &val3);
55247 if (!SWIG_IsOK(ecode3)) {
55248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55249 }
55250 arg3 = static_cast< int >(val3);
55251 }
55252 {
55253 PyThreadState* __tstate = wxPyBeginAllowThreads();
55254 (arg1)->Below(arg2,arg3);
55255 wxPyEndAllowThreads(__tstate);
55256 if (PyErr_Occurred()) SWIG_fail;
55257 }
55258 resultobj = SWIG_Py_Void();
55259 return resultobj;
55260 fail:
55261 return NULL;
55262 }
55263
55264
55265 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55266 PyObject *resultobj = 0;
55267 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55268 wxWindow *arg2 = (wxWindow *) 0 ;
55269 wxEdge arg3 ;
55270 int arg4 = (int) 0 ;
55271 void *argp1 = 0 ;
55272 int res1 = 0 ;
55273 void *argp2 = 0 ;
55274 int res2 = 0 ;
55275 int val3 ;
55276 int ecode3 = 0 ;
55277 int val4 ;
55278 int ecode4 = 0 ;
55279 PyObject * obj0 = 0 ;
55280 PyObject * obj1 = 0 ;
55281 PyObject * obj2 = 0 ;
55282 PyObject * obj3 = 0 ;
55283 char * kwnames[] = {
55284 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55285 };
55286
55287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55289 if (!SWIG_IsOK(res1)) {
55290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55291 }
55292 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55294 if (!SWIG_IsOK(res2)) {
55295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55296 }
55297 arg2 = reinterpret_cast< wxWindow * >(argp2);
55298 ecode3 = SWIG_AsVal_int(obj2, &val3);
55299 if (!SWIG_IsOK(ecode3)) {
55300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55301 }
55302 arg3 = static_cast< wxEdge >(val3);
55303 if (obj3) {
55304 ecode4 = SWIG_AsVal_int(obj3, &val4);
55305 if (!SWIG_IsOK(ecode4)) {
55306 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55307 }
55308 arg4 = static_cast< int >(val4);
55309 }
55310 {
55311 PyThreadState* __tstate = wxPyBeginAllowThreads();
55312 (arg1)->SameAs(arg2,arg3,arg4);
55313 wxPyEndAllowThreads(__tstate);
55314 if (PyErr_Occurred()) SWIG_fail;
55315 }
55316 resultobj = SWIG_Py_Void();
55317 return resultobj;
55318 fail:
55319 return NULL;
55320 }
55321
55322
55323 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55324 PyObject *resultobj = 0;
55325 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55326 wxWindow *arg2 = (wxWindow *) 0 ;
55327 wxEdge arg3 ;
55328 int arg4 ;
55329 void *argp1 = 0 ;
55330 int res1 = 0 ;
55331 void *argp2 = 0 ;
55332 int res2 = 0 ;
55333 int val3 ;
55334 int ecode3 = 0 ;
55335 int val4 ;
55336 int ecode4 = 0 ;
55337 PyObject * obj0 = 0 ;
55338 PyObject * obj1 = 0 ;
55339 PyObject * obj2 = 0 ;
55340 PyObject * obj3 = 0 ;
55341 char * kwnames[] = {
55342 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55343 };
55344
55345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55347 if (!SWIG_IsOK(res1)) {
55348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55349 }
55350 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55352 if (!SWIG_IsOK(res2)) {
55353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55354 }
55355 arg2 = reinterpret_cast< wxWindow * >(argp2);
55356 ecode3 = SWIG_AsVal_int(obj2, &val3);
55357 if (!SWIG_IsOK(ecode3)) {
55358 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55359 }
55360 arg3 = static_cast< wxEdge >(val3);
55361 ecode4 = SWIG_AsVal_int(obj3, &val4);
55362 if (!SWIG_IsOK(ecode4)) {
55363 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55364 }
55365 arg4 = static_cast< int >(val4);
55366 {
55367 PyThreadState* __tstate = wxPyBeginAllowThreads();
55368 (arg1)->PercentOf(arg2,arg3,arg4);
55369 wxPyEndAllowThreads(__tstate);
55370 if (PyErr_Occurred()) SWIG_fail;
55371 }
55372 resultobj = SWIG_Py_Void();
55373 return resultobj;
55374 fail:
55375 return NULL;
55376 }
55377
55378
55379 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55380 PyObject *resultobj = 0;
55381 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55382 int arg2 ;
55383 void *argp1 = 0 ;
55384 int res1 = 0 ;
55385 int val2 ;
55386 int ecode2 = 0 ;
55387 PyObject * obj0 = 0 ;
55388 PyObject * obj1 = 0 ;
55389 char * kwnames[] = {
55390 (char *) "self",(char *) "val", NULL
55391 };
55392
55393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55395 if (!SWIG_IsOK(res1)) {
55396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55397 }
55398 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55399 ecode2 = SWIG_AsVal_int(obj1, &val2);
55400 if (!SWIG_IsOK(ecode2)) {
55401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55402 }
55403 arg2 = static_cast< int >(val2);
55404 {
55405 PyThreadState* __tstate = wxPyBeginAllowThreads();
55406 (arg1)->Absolute(arg2);
55407 wxPyEndAllowThreads(__tstate);
55408 if (PyErr_Occurred()) SWIG_fail;
55409 }
55410 resultobj = SWIG_Py_Void();
55411 return resultobj;
55412 fail:
55413 return NULL;
55414 }
55415
55416
55417 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55418 PyObject *resultobj = 0;
55419 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55420 void *argp1 = 0 ;
55421 int res1 = 0 ;
55422 PyObject *swig_obj[1] ;
55423
55424 if (!args) SWIG_fail;
55425 swig_obj[0] = args;
55426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55427 if (!SWIG_IsOK(res1)) {
55428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55429 }
55430 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55431 {
55432 PyThreadState* __tstate = wxPyBeginAllowThreads();
55433 (arg1)->Unconstrained();
55434 wxPyEndAllowThreads(__tstate);
55435 if (PyErr_Occurred()) SWIG_fail;
55436 }
55437 resultobj = SWIG_Py_Void();
55438 return resultobj;
55439 fail:
55440 return NULL;
55441 }
55442
55443
55444 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55445 PyObject *resultobj = 0;
55446 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55447 void *argp1 = 0 ;
55448 int res1 = 0 ;
55449 PyObject *swig_obj[1] ;
55450
55451 if (!args) SWIG_fail;
55452 swig_obj[0] = args;
55453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55454 if (!SWIG_IsOK(res1)) {
55455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55456 }
55457 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55458 {
55459 PyThreadState* __tstate = wxPyBeginAllowThreads();
55460 (arg1)->AsIs();
55461 wxPyEndAllowThreads(__tstate);
55462 if (PyErr_Occurred()) SWIG_fail;
55463 }
55464 resultobj = SWIG_Py_Void();
55465 return resultobj;
55466 fail:
55467 return NULL;
55468 }
55469
55470
55471 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55472 PyObject *resultobj = 0;
55473 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55474 wxWindow *result = 0 ;
55475 void *argp1 = 0 ;
55476 int res1 = 0 ;
55477 PyObject *swig_obj[1] ;
55478
55479 if (!args) SWIG_fail;
55480 swig_obj[0] = args;
55481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55482 if (!SWIG_IsOK(res1)) {
55483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55484 }
55485 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55486 {
55487 PyThreadState* __tstate = wxPyBeginAllowThreads();
55488 result = (wxWindow *)(arg1)->GetOtherWindow();
55489 wxPyEndAllowThreads(__tstate);
55490 if (PyErr_Occurred()) SWIG_fail;
55491 }
55492 {
55493 resultobj = wxPyMake_wxObject(result, 0);
55494 }
55495 return resultobj;
55496 fail:
55497 return NULL;
55498 }
55499
55500
55501 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55502 PyObject *resultobj = 0;
55503 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55504 wxEdge result;
55505 void *argp1 = 0 ;
55506 int res1 = 0 ;
55507 PyObject *swig_obj[1] ;
55508
55509 if (!args) SWIG_fail;
55510 swig_obj[0] = args;
55511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55512 if (!SWIG_IsOK(res1)) {
55513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55514 }
55515 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55516 {
55517 PyThreadState* __tstate = wxPyBeginAllowThreads();
55518 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55519 wxPyEndAllowThreads(__tstate);
55520 if (PyErr_Occurred()) SWIG_fail;
55521 }
55522 resultobj = SWIG_From_int(static_cast< int >(result));
55523 return resultobj;
55524 fail:
55525 return NULL;
55526 }
55527
55528
55529 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55530 PyObject *resultobj = 0;
55531 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55532 wxEdge arg2 ;
55533 void *argp1 = 0 ;
55534 int res1 = 0 ;
55535 int val2 ;
55536 int ecode2 = 0 ;
55537 PyObject * obj0 = 0 ;
55538 PyObject * obj1 = 0 ;
55539 char * kwnames[] = {
55540 (char *) "self",(char *) "which", NULL
55541 };
55542
55543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55545 if (!SWIG_IsOK(res1)) {
55546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55547 }
55548 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55549 ecode2 = SWIG_AsVal_int(obj1, &val2);
55550 if (!SWIG_IsOK(ecode2)) {
55551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55552 }
55553 arg2 = static_cast< wxEdge >(val2);
55554 {
55555 PyThreadState* __tstate = wxPyBeginAllowThreads();
55556 (arg1)->SetEdge(arg2);
55557 wxPyEndAllowThreads(__tstate);
55558 if (PyErr_Occurred()) SWIG_fail;
55559 }
55560 resultobj = SWIG_Py_Void();
55561 return resultobj;
55562 fail:
55563 return NULL;
55564 }
55565
55566
55567 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55568 PyObject *resultobj = 0;
55569 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55570 int arg2 ;
55571 void *argp1 = 0 ;
55572 int res1 = 0 ;
55573 int val2 ;
55574 int ecode2 = 0 ;
55575 PyObject * obj0 = 0 ;
55576 PyObject * obj1 = 0 ;
55577 char * kwnames[] = {
55578 (char *) "self",(char *) "v", NULL
55579 };
55580
55581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55583 if (!SWIG_IsOK(res1)) {
55584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55585 }
55586 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55587 ecode2 = SWIG_AsVal_int(obj1, &val2);
55588 if (!SWIG_IsOK(ecode2)) {
55589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55590 }
55591 arg2 = static_cast< int >(val2);
55592 {
55593 PyThreadState* __tstate = wxPyBeginAllowThreads();
55594 (arg1)->SetValue(arg2);
55595 wxPyEndAllowThreads(__tstate);
55596 if (PyErr_Occurred()) SWIG_fail;
55597 }
55598 resultobj = SWIG_Py_Void();
55599 return resultobj;
55600 fail:
55601 return NULL;
55602 }
55603
55604
55605 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55606 PyObject *resultobj = 0;
55607 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55608 int result;
55609 void *argp1 = 0 ;
55610 int res1 = 0 ;
55611 PyObject *swig_obj[1] ;
55612
55613 if (!args) SWIG_fail;
55614 swig_obj[0] = args;
55615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55616 if (!SWIG_IsOK(res1)) {
55617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55618 }
55619 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55620 {
55621 PyThreadState* __tstate = wxPyBeginAllowThreads();
55622 result = (int)(arg1)->GetMargin();
55623 wxPyEndAllowThreads(__tstate);
55624 if (PyErr_Occurred()) SWIG_fail;
55625 }
55626 resultobj = SWIG_From_int(static_cast< int >(result));
55627 return resultobj;
55628 fail:
55629 return NULL;
55630 }
55631
55632
55633 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55634 PyObject *resultobj = 0;
55635 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55636 int arg2 ;
55637 void *argp1 = 0 ;
55638 int res1 = 0 ;
55639 int val2 ;
55640 int ecode2 = 0 ;
55641 PyObject * obj0 = 0 ;
55642 PyObject * obj1 = 0 ;
55643 char * kwnames[] = {
55644 (char *) "self",(char *) "m", NULL
55645 };
55646
55647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55649 if (!SWIG_IsOK(res1)) {
55650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55651 }
55652 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55653 ecode2 = SWIG_AsVal_int(obj1, &val2);
55654 if (!SWIG_IsOK(ecode2)) {
55655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55656 }
55657 arg2 = static_cast< int >(val2);
55658 {
55659 PyThreadState* __tstate = wxPyBeginAllowThreads();
55660 (arg1)->SetMargin(arg2);
55661 wxPyEndAllowThreads(__tstate);
55662 if (PyErr_Occurred()) SWIG_fail;
55663 }
55664 resultobj = SWIG_Py_Void();
55665 return resultobj;
55666 fail:
55667 return NULL;
55668 }
55669
55670
55671 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55672 PyObject *resultobj = 0;
55673 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55674 int result;
55675 void *argp1 = 0 ;
55676 int res1 = 0 ;
55677 PyObject *swig_obj[1] ;
55678
55679 if (!args) SWIG_fail;
55680 swig_obj[0] = args;
55681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55682 if (!SWIG_IsOK(res1)) {
55683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55684 }
55685 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55686 {
55687 PyThreadState* __tstate = wxPyBeginAllowThreads();
55688 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55689 wxPyEndAllowThreads(__tstate);
55690 if (PyErr_Occurred()) SWIG_fail;
55691 }
55692 resultobj = SWIG_From_int(static_cast< int >(result));
55693 return resultobj;
55694 fail:
55695 return NULL;
55696 }
55697
55698
55699 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55700 PyObject *resultobj = 0;
55701 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55702 int result;
55703 void *argp1 = 0 ;
55704 int res1 = 0 ;
55705 PyObject *swig_obj[1] ;
55706
55707 if (!args) SWIG_fail;
55708 swig_obj[0] = args;
55709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55710 if (!SWIG_IsOK(res1)) {
55711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55712 }
55713 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55714 {
55715 PyThreadState* __tstate = wxPyBeginAllowThreads();
55716 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55717 wxPyEndAllowThreads(__tstate);
55718 if (PyErr_Occurred()) SWIG_fail;
55719 }
55720 resultobj = SWIG_From_int(static_cast< int >(result));
55721 return resultobj;
55722 fail:
55723 return NULL;
55724 }
55725
55726
55727 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55728 PyObject *resultobj = 0;
55729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55730 int result;
55731 void *argp1 = 0 ;
55732 int res1 = 0 ;
55733 PyObject *swig_obj[1] ;
55734
55735 if (!args) SWIG_fail;
55736 swig_obj[0] = args;
55737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55738 if (!SWIG_IsOK(res1)) {
55739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55740 }
55741 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55742 {
55743 PyThreadState* __tstate = wxPyBeginAllowThreads();
55744 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55745 wxPyEndAllowThreads(__tstate);
55746 if (PyErr_Occurred()) SWIG_fail;
55747 }
55748 resultobj = SWIG_From_int(static_cast< int >(result));
55749 return resultobj;
55750 fail:
55751 return NULL;
55752 }
55753
55754
55755 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55756 PyObject *resultobj = 0;
55757 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55758 bool result;
55759 void *argp1 = 0 ;
55760 int res1 = 0 ;
55761 PyObject *swig_obj[1] ;
55762
55763 if (!args) SWIG_fail;
55764 swig_obj[0] = args;
55765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55766 if (!SWIG_IsOK(res1)) {
55767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55768 }
55769 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55770 {
55771 PyThreadState* __tstate = wxPyBeginAllowThreads();
55772 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55773 wxPyEndAllowThreads(__tstate);
55774 if (PyErr_Occurred()) SWIG_fail;
55775 }
55776 {
55777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55778 }
55779 return resultobj;
55780 fail:
55781 return NULL;
55782 }
55783
55784
55785 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55786 PyObject *resultobj = 0;
55787 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55788 bool arg2 ;
55789 void *argp1 = 0 ;
55790 int res1 = 0 ;
55791 bool val2 ;
55792 int ecode2 = 0 ;
55793 PyObject * obj0 = 0 ;
55794 PyObject * obj1 = 0 ;
55795 char * kwnames[] = {
55796 (char *) "self",(char *) "d", NULL
55797 };
55798
55799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
55800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55801 if (!SWIG_IsOK(res1)) {
55802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55803 }
55804 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55805 ecode2 = SWIG_AsVal_bool(obj1, &val2);
55806 if (!SWIG_IsOK(ecode2)) {
55807 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
55808 }
55809 arg2 = static_cast< bool >(val2);
55810 {
55811 PyThreadState* __tstate = wxPyBeginAllowThreads();
55812 (arg1)->SetDone(arg2);
55813 wxPyEndAllowThreads(__tstate);
55814 if (PyErr_Occurred()) SWIG_fail;
55815 }
55816 resultobj = SWIG_Py_Void();
55817 return resultobj;
55818 fail:
55819 return NULL;
55820 }
55821
55822
55823 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55824 PyObject *resultobj = 0;
55825 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55826 wxRelationship result;
55827 void *argp1 = 0 ;
55828 int res1 = 0 ;
55829 PyObject *swig_obj[1] ;
55830
55831 if (!args) SWIG_fail;
55832 swig_obj[0] = args;
55833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55834 if (!SWIG_IsOK(res1)) {
55835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55836 }
55837 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55838 {
55839 PyThreadState* __tstate = wxPyBeginAllowThreads();
55840 result = (wxRelationship)(arg1)->GetRelationship();
55841 wxPyEndAllowThreads(__tstate);
55842 if (PyErr_Occurred()) SWIG_fail;
55843 }
55844 resultobj = SWIG_From_int(static_cast< int >(result));
55845 return resultobj;
55846 fail:
55847 return NULL;
55848 }
55849
55850
55851 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55852 PyObject *resultobj = 0;
55853 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55854 wxRelationship arg2 ;
55855 void *argp1 = 0 ;
55856 int res1 = 0 ;
55857 int val2 ;
55858 int ecode2 = 0 ;
55859 PyObject * obj0 = 0 ;
55860 PyObject * obj1 = 0 ;
55861 char * kwnames[] = {
55862 (char *) "self",(char *) "r", NULL
55863 };
55864
55865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
55866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55867 if (!SWIG_IsOK(res1)) {
55868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55869 }
55870 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55871 ecode2 = SWIG_AsVal_int(obj1, &val2);
55872 if (!SWIG_IsOK(ecode2)) {
55873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
55874 }
55875 arg2 = static_cast< wxRelationship >(val2);
55876 {
55877 PyThreadState* __tstate = wxPyBeginAllowThreads();
55878 (arg1)->SetRelationship(arg2);
55879 wxPyEndAllowThreads(__tstate);
55880 if (PyErr_Occurred()) SWIG_fail;
55881 }
55882 resultobj = SWIG_Py_Void();
55883 return resultobj;
55884 fail:
55885 return NULL;
55886 }
55887
55888
55889 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55890 PyObject *resultobj = 0;
55891 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55892 wxWindow *arg2 = (wxWindow *) 0 ;
55893 bool result;
55894 void *argp1 = 0 ;
55895 int res1 = 0 ;
55896 void *argp2 = 0 ;
55897 int res2 = 0 ;
55898 PyObject * obj0 = 0 ;
55899 PyObject * obj1 = 0 ;
55900 char * kwnames[] = {
55901 (char *) "self",(char *) "otherW", NULL
55902 };
55903
55904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
55905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55906 if (!SWIG_IsOK(res1)) {
55907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55908 }
55909 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55910 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55911 if (!SWIG_IsOK(res2)) {
55912 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
55913 }
55914 arg2 = reinterpret_cast< wxWindow * >(argp2);
55915 {
55916 PyThreadState* __tstate = wxPyBeginAllowThreads();
55917 result = (bool)(arg1)->ResetIfWin(arg2);
55918 wxPyEndAllowThreads(__tstate);
55919 if (PyErr_Occurred()) SWIG_fail;
55920 }
55921 {
55922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55923 }
55924 return resultobj;
55925 fail:
55926 return NULL;
55927 }
55928
55929
55930 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55931 PyObject *resultobj = 0;
55932 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55933 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
55934 wxWindow *arg3 = (wxWindow *) 0 ;
55935 bool result;
55936 void *argp1 = 0 ;
55937 int res1 = 0 ;
55938 void *argp2 = 0 ;
55939 int res2 = 0 ;
55940 void *argp3 = 0 ;
55941 int res3 = 0 ;
55942 PyObject * obj0 = 0 ;
55943 PyObject * obj1 = 0 ;
55944 PyObject * obj2 = 0 ;
55945 char * kwnames[] = {
55946 (char *) "self",(char *) "constraints",(char *) "win", NULL
55947 };
55948
55949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55951 if (!SWIG_IsOK(res1)) {
55952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55953 }
55954 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55955 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
55956 if (!SWIG_IsOK(res2)) {
55957 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
55958 }
55959 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
55960 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55961 if (!SWIG_IsOK(res3)) {
55962 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
55963 }
55964 arg3 = reinterpret_cast< wxWindow * >(argp3);
55965 {
55966 PyThreadState* __tstate = wxPyBeginAllowThreads();
55967 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
55968 wxPyEndAllowThreads(__tstate);
55969 if (PyErr_Occurred()) SWIG_fail;
55970 }
55971 {
55972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55973 }
55974 return resultobj;
55975 fail:
55976 return NULL;
55977 }
55978
55979
55980 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55981 PyObject *resultobj = 0;
55982 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55983 wxEdge arg2 ;
55984 wxWindow *arg3 = (wxWindow *) 0 ;
55985 wxWindow *arg4 = (wxWindow *) 0 ;
55986 int result;
55987 void *argp1 = 0 ;
55988 int res1 = 0 ;
55989 int val2 ;
55990 int ecode2 = 0 ;
55991 void *argp3 = 0 ;
55992 int res3 = 0 ;
55993 void *argp4 = 0 ;
55994 int res4 = 0 ;
55995 PyObject * obj0 = 0 ;
55996 PyObject * obj1 = 0 ;
55997 PyObject * obj2 = 0 ;
55998 PyObject * obj3 = 0 ;
55999 char * kwnames[] = {
56000 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56001 };
56002
56003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56005 if (!SWIG_IsOK(res1)) {
56006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56007 }
56008 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56009 ecode2 = SWIG_AsVal_int(obj1, &val2);
56010 if (!SWIG_IsOK(ecode2)) {
56011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56012 }
56013 arg2 = static_cast< wxEdge >(val2);
56014 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56015 if (!SWIG_IsOK(res3)) {
56016 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56017 }
56018 arg3 = reinterpret_cast< wxWindow * >(argp3);
56019 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56020 if (!SWIG_IsOK(res4)) {
56021 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56022 }
56023 arg4 = reinterpret_cast< wxWindow * >(argp4);
56024 {
56025 PyThreadState* __tstate = wxPyBeginAllowThreads();
56026 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56027 wxPyEndAllowThreads(__tstate);
56028 if (PyErr_Occurred()) SWIG_fail;
56029 }
56030 resultobj = SWIG_From_int(static_cast< int >(result));
56031 return resultobj;
56032 fail:
56033 return NULL;
56034 }
56035
56036
56037 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56038 PyObject *obj;
56039 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56040 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56041 return SWIG_Py_Void();
56042 }
56043
56044 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56045 PyObject *resultobj = 0;
56046 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56047 wxIndividualLayoutConstraint *result = 0 ;
56048 void *argp1 = 0 ;
56049 int res1 = 0 ;
56050 PyObject *swig_obj[1] ;
56051
56052 if (!args) SWIG_fail;
56053 swig_obj[0] = args;
56054 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56055 if (!SWIG_IsOK(res1)) {
56056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56057 }
56058 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56059 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56061 return resultobj;
56062 fail:
56063 return NULL;
56064 }
56065
56066
56067 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56068 PyObject *resultobj = 0;
56069 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56070 wxIndividualLayoutConstraint *result = 0 ;
56071 void *argp1 = 0 ;
56072 int res1 = 0 ;
56073 PyObject *swig_obj[1] ;
56074
56075 if (!args) SWIG_fail;
56076 swig_obj[0] = args;
56077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56078 if (!SWIG_IsOK(res1)) {
56079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56080 }
56081 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56082 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56083 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56084 return resultobj;
56085 fail:
56086 return NULL;
56087 }
56088
56089
56090 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56091 PyObject *resultobj = 0;
56092 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56093 wxIndividualLayoutConstraint *result = 0 ;
56094 void *argp1 = 0 ;
56095 int res1 = 0 ;
56096 PyObject *swig_obj[1] ;
56097
56098 if (!args) SWIG_fail;
56099 swig_obj[0] = args;
56100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56101 if (!SWIG_IsOK(res1)) {
56102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56103 }
56104 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56105 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56107 return resultobj;
56108 fail:
56109 return NULL;
56110 }
56111
56112
56113 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56114 PyObject *resultobj = 0;
56115 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56116 wxIndividualLayoutConstraint *result = 0 ;
56117 void *argp1 = 0 ;
56118 int res1 = 0 ;
56119 PyObject *swig_obj[1] ;
56120
56121 if (!args) SWIG_fail;
56122 swig_obj[0] = args;
56123 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56124 if (!SWIG_IsOK(res1)) {
56125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56126 }
56127 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56128 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56129 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56130 return resultobj;
56131 fail:
56132 return NULL;
56133 }
56134
56135
56136 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56137 PyObject *resultobj = 0;
56138 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56139 wxIndividualLayoutConstraint *result = 0 ;
56140 void *argp1 = 0 ;
56141 int res1 = 0 ;
56142 PyObject *swig_obj[1] ;
56143
56144 if (!args) SWIG_fail;
56145 swig_obj[0] = args;
56146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56147 if (!SWIG_IsOK(res1)) {
56148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56149 }
56150 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56151 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56152 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56153 return resultobj;
56154 fail:
56155 return NULL;
56156 }
56157
56158
56159 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56160 PyObject *resultobj = 0;
56161 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56162 wxIndividualLayoutConstraint *result = 0 ;
56163 void *argp1 = 0 ;
56164 int res1 = 0 ;
56165 PyObject *swig_obj[1] ;
56166
56167 if (!args) SWIG_fail;
56168 swig_obj[0] = args;
56169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56170 if (!SWIG_IsOK(res1)) {
56171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56172 }
56173 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56174 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56176 return resultobj;
56177 fail:
56178 return NULL;
56179 }
56180
56181
56182 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56183 PyObject *resultobj = 0;
56184 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56185 wxIndividualLayoutConstraint *result = 0 ;
56186 void *argp1 = 0 ;
56187 int res1 = 0 ;
56188 PyObject *swig_obj[1] ;
56189
56190 if (!args) SWIG_fail;
56191 swig_obj[0] = args;
56192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56193 if (!SWIG_IsOK(res1)) {
56194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56195 }
56196 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56197 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56199 return resultobj;
56200 fail:
56201 return NULL;
56202 }
56203
56204
56205 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56206 PyObject *resultobj = 0;
56207 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56208 wxIndividualLayoutConstraint *result = 0 ;
56209 void *argp1 = 0 ;
56210 int res1 = 0 ;
56211 PyObject *swig_obj[1] ;
56212
56213 if (!args) SWIG_fail;
56214 swig_obj[0] = args;
56215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56216 if (!SWIG_IsOK(res1)) {
56217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56218 }
56219 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56220 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56222 return resultobj;
56223 fail:
56224 return NULL;
56225 }
56226
56227
56228 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56229 PyObject *resultobj = 0;
56230 wxLayoutConstraints *result = 0 ;
56231
56232 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56233 {
56234 PyThreadState* __tstate = wxPyBeginAllowThreads();
56235 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56236 wxPyEndAllowThreads(__tstate);
56237 if (PyErr_Occurred()) SWIG_fail;
56238 }
56239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56240 return resultobj;
56241 fail:
56242 return NULL;
56243 }
56244
56245
56246 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56247 PyObject *resultobj = 0;
56248 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56249 void *argp1 = 0 ;
56250 int res1 = 0 ;
56251 PyObject *swig_obj[1] ;
56252
56253 if (!args) SWIG_fail;
56254 swig_obj[0] = args;
56255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56256 if (!SWIG_IsOK(res1)) {
56257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56258 }
56259 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56260 {
56261 PyThreadState* __tstate = wxPyBeginAllowThreads();
56262 delete arg1;
56263
56264 wxPyEndAllowThreads(__tstate);
56265 if (PyErr_Occurred()) SWIG_fail;
56266 }
56267 resultobj = SWIG_Py_Void();
56268 return resultobj;
56269 fail:
56270 return NULL;
56271 }
56272
56273
56274 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56275 PyObject *resultobj = 0;
56276 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56277 wxWindow *arg2 = (wxWindow *) 0 ;
56278 int *arg3 = (int *) 0 ;
56279 bool result;
56280 void *argp1 = 0 ;
56281 int res1 = 0 ;
56282 void *argp2 = 0 ;
56283 int res2 = 0 ;
56284 int temp3 ;
56285 int res3 = SWIG_TMPOBJ ;
56286 PyObject * obj0 = 0 ;
56287 PyObject * obj1 = 0 ;
56288 char * kwnames[] = {
56289 (char *) "self",(char *) "win", NULL
56290 };
56291
56292 arg3 = &temp3;
56293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56295 if (!SWIG_IsOK(res1)) {
56296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56297 }
56298 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56299 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56300 if (!SWIG_IsOK(res2)) {
56301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56302 }
56303 arg2 = reinterpret_cast< wxWindow * >(argp2);
56304 {
56305 PyThreadState* __tstate = wxPyBeginAllowThreads();
56306 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56307 wxPyEndAllowThreads(__tstate);
56308 if (PyErr_Occurred()) SWIG_fail;
56309 }
56310 {
56311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56312 }
56313 if (SWIG_IsTmpObj(res3)) {
56314 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56315 } else {
56316 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56317 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56318 }
56319 return resultobj;
56320 fail:
56321 return NULL;
56322 }
56323
56324
56325 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56326 PyObject *resultobj = 0;
56327 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56328 bool result;
56329 void *argp1 = 0 ;
56330 int res1 = 0 ;
56331 PyObject *swig_obj[1] ;
56332
56333 if (!args) SWIG_fail;
56334 swig_obj[0] = args;
56335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56336 if (!SWIG_IsOK(res1)) {
56337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56338 }
56339 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56340 {
56341 PyThreadState* __tstate = wxPyBeginAllowThreads();
56342 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56343 wxPyEndAllowThreads(__tstate);
56344 if (PyErr_Occurred()) SWIG_fail;
56345 }
56346 {
56347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56348 }
56349 return resultobj;
56350 fail:
56351 return NULL;
56352 }
56353
56354
56355 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56356 PyObject *obj;
56357 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56358 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56359 return SWIG_Py_Void();
56360 }
56361
56362 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56363 return SWIG_Python_InitShadowInstance(args);
56364 }
56365
56366 static PyMethodDef SwigMethods[] = {
56367 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56368 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56369 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56370 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56371 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56372 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56373 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56374 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56375 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56376 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56377 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56378 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56379 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56380 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56381 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56382 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56383 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56384 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56385 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56386 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56387 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56388 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56389 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56390 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56391 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56392 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56393 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56394 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56395 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56396 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56397 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56398 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56399 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56400 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56401 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56402 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56403 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56404 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56405 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56406 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56407 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56408 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56409 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56410 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56411 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56412 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56413 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56414 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56415 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56416 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56417 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56418 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56419 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56420 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56421 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56422 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56423 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56424 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56425 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56426 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56427 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56428 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56429 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56430 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56431 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56432 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56433 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56434 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56435 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56436 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56437 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56438 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56439 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56440 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56441 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56442 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56443 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56444 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56445 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56446 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56447 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56448 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56449 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56450 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56451 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56452 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56453 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56454 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56455 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56456 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56457 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56458 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56459 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56460 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56461 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56462 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56463 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56464 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56465 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56466 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56467 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56468 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56469 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56470 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56471 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56472 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56473 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56474 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56475 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56476 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56477 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56478 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56479 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56480 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56481 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56482 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56483 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56484 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56485 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56486 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56487 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56488 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56489 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56490 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56491 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56492 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56493 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56494 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56495 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56496 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56497 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56498 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56499 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56500 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56501 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56502 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56503 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56504 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56505 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56506 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56507 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56508 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56509 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56510 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56511 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56512 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56513 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56514 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56515 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56516 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56517 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56518 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56519 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56520 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56521 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56522 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56523 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56524 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56525 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56526 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56527 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56528 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56529 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56530 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56531 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56532 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56533 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56534 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56535 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56536 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56537 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56538 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56539 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56540 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56541 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56542 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56543 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56544 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56545 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56546 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56547 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56548 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56549 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56550 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56551 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56552 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56553 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56554 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56555 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56556 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56557 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56558 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56559 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56560 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56561 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56562 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56563 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56564 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56565 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56566 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56567 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56568 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56569 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56570 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56571 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56572 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56573 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56574 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56575 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56576 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56577 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56578 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56579 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56580 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56581 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56582 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56583 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56588 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56589 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56590 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56591 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56592 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56593 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56594 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56596 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56597 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56598 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56599 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56600 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56601 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56602 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56603 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56604 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56605 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56606 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56607 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56608 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56609 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56610 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56611 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56612 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56613 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56614 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56618 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56619 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56625 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56626 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56627 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56628 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56630 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56633 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56636 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56638 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56639 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56640 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56641 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56642 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56644 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56645 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56646 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56650 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56651 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56652 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56653 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56654 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56656 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56661 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56662 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56663 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56664 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56665 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56666 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56667 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56674 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56675 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56677 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56678 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56679 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56680 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56681 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56682 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56683 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56684 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56685 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56686 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56688 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56689 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56690 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56691 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56692 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56693 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56694 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56695 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56697 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56698 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56699 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56700 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56701 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56702 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56703 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56704 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56705 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56706 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56713 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56714 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56715 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56721 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56722 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56723 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56724 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56732 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56733 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56739 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56745 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56748 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56749 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56750 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56751 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56754 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56756 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56758 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56760 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56762 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56765 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56766 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56767 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56768 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56770 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56771 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56774 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56782 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56787 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56788 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56791 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56794 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56795 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56797 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56798 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
56799 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
56800 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
56801 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
56802 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
56803 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
56804 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
56805 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
56806 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
56807 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
56808 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
56809 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
56810 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
56811 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
56812 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
56813 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
56814 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
56815 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
56816 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
56817 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
56818 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
56819 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
56820 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
56821 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
56822 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
56823 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
56824 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
56825 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
56826 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
56827 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
56828 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
56829 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
56830 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
56831 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
56832 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
56834 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
56835 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
56836 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
56837 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
56840 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
56841 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
56844 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
56846 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
56848 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
56849 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
56850 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
56851 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
56852 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
56853 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
56854 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
56856 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
56857 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
56858 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
56860 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
56862 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
56863 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
56864 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
56866 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
56867 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
56868 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
56869 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
56870 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
56871 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
56873 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
56874 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
56875 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56876 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
56877 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
56878 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
56879 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
56880 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
56881 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
56883 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
56885 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
56886 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
56887 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
56888 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
56889 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
56890 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56891 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
56892 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
56893 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
56894 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
56895 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
56896 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
56898 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
56899 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56900 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56901 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
56902 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
56903 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56904 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
56905 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
56906 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56908 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
56909 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
56910 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56911 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
56912 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
56916 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
56918 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
56919 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
56920 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
56921 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
56922 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
56923 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
56924 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
56925 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
56926 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
56927 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
56928 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
56929 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
56930 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
56931 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
56932 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
56933 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
56934 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
56935 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
56936 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
56937 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
56938 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
56939 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
56940 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
56941 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
56943 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
56944 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
56945 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
56946 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
56947 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
56948 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
56949 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
56950 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
56951 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
56952 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
56953 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
56954 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
56955 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
56956 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
56957 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
56958 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
56959 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
56960 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
56961 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
56962 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
56963 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
56964 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
56965 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
56966 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
56967 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
56968 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
56969 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
56970 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
56971 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
56972 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
56973 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
56974 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56975 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
56976 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
56977 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
56978 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
56979 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
56980 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
56981 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
56982 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
56983 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
56984 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
56985 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
56986 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
56987 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
56988 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
56989 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
56990 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
56991 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
56992 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56993 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
56994 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
56995 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
56996 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
56997 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
56998 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
56999 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57000 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57001 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57002 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57003 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57004 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57005 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57006 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57007 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57008 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57009 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57010 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57011 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57012 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57013 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57014 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57015 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57016 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57017 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57018 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57019 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57020 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57021 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57022 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57023 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57024 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57025 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57026 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57027 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57028 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57029 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57030 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57031 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57032 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57033 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57034 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57035 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57036 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57037 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57038 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57039 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57040 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57041 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57042 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57043 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57044 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57045 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57046 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57047 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57048 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57049 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57050 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57051 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57052 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57053 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57054 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57055 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57056 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57057 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57058 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57059 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57060 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57061 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57062 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57063 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57064 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57065 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57066 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57067 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57068 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57069 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57070 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57071 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57072 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57073 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57074 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57075 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57076 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57077 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57078 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57079 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57080 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57081 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57082 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57083 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57084 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57085 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57086 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57087 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57088 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57089 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57090 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57091 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57092 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57093 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57094 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57095 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57096 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57097 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57098 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57099 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57100 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57101 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57102 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57103 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57104 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57105 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57106 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57107 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57110 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57111 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57112 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57113 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57115 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57116 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57117 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57118 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57119 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57120 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57121 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57122 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57123 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57124 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57125 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57126 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57127 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57128 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57129 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57130 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57132 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57133 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57134 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57135 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57136 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57137 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57138 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57139 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57140 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57141 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57142 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57143 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57144 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57145 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57146 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57147 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57148 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57149 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57150 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57151 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57152 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57153 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57154 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57155 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57156 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57157 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57158 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57159 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57160 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57161 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57162 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57163 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57164 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57165 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57166 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57167 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57168 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57169 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57170 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57171 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57172 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57173 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57174 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57175 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57176 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57178 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57179 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57180 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57181 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57182 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57183 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57184 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57186 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57187 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57188 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57189 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57190 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57191 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57192 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57193 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57194 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57195 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57196 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57197 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57198 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57199 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57200 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57201 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57202 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57203 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57204 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57205 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57206 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57207 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57208 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57209 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57210 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57211 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57212 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57213 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57214 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57215 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57216 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57217 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57218 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57219 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57220 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57222 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57223 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57224 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57225 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57226 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57227 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57228 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57229 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57230 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57231 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57232 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57233 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57234 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57236 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57237 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57238 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57239 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57240 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57241 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57242 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57243 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57244 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57245 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57246 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57247 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57248 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57249 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57251 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57252 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57253 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57254 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57255 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57256 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57257 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57258 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57259 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57260 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57261 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57262 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57263 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57264 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57265 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57266 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57267 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57268 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57269 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57270 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57271 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57272 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57273 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57274 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57275 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57276 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57277 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57278 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57279 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57280 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57281 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57282 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57283 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57284 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57285 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57286 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57287 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57288 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57289 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57290 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57291 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57292 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57293 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57294 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57295 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57296 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57297 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57298 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57299 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57300 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57301 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57302 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57303 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57304 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57305 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57306 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57307 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57309 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57310 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57313 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57315 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57316 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57317 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57319 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57320 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57321 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57322 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57323 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57324 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57325 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57326 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57328 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57329 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57330 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57331 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57332 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57333 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57334 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57335 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57336 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57337 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57338 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57339 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57340 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57341 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57342 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57343 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57344 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57346 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57347 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57348 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57351 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57353 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57354 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57355 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57356 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57357 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57358 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57359 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57360 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57361 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57362 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57363 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57364 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57365 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57366 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57367 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57368 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57369 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57370 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57371 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57372 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57374 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57376 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57377 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57378 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57380 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57381 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57382 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57383 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57384 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57385 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57386 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57388 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57390 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57391 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57392 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57393 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57394 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57400 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57401 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57404 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57406 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57407 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57408 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57409 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57410 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57411 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57412 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57414 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57415 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57416 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57418 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57420 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57421 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57422 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57423 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57424 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57425 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57427 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57428 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57429 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57430 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57431 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57432 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57434 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57435 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57436 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57437 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57440 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57444 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57445 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57446 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57447 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57448 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57449 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57451 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57452 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57453 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57454 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57455 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57457 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57459 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57460 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57461 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57463 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57464 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57470 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57471 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57472 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57473 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57474 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57475 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57477 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57479 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57481 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57482 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57484 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57485 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57487 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57488 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57489 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57490 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57491 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57492 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57494 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57495 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57497 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57498 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57499 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57500 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57501 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57503 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57505 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57506 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57507 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57508 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57509 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57510 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57511 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57512 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57513 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57514 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57516 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57517 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57520 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57522 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57523 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57524 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57526 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57527 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57528 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57530 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57532 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57533 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57534 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57536 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57537 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57538 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57540 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57542 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57543 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57546 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57548 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57555 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57561 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57563 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57564 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57565 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57566 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57567 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57570 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57571 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57572 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57573 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57575 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57577 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57580 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57582 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57584 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57585 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57587 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57589 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57590 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57591 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57592 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57593 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57594 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57598 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57599 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57601 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57616 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57617 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57618 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57619 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57620 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57621 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57623 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57624 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57625 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57627 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57628 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57631 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57632 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57634 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57635 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57637 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57640 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57641 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57643 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57644 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57645 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57647 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57648 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57650 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57651 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57654 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57656 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57657 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57658 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57660 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57663 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57665 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57666 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57667 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57669 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57670 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57671 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57673 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57675 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57676 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57679 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57680 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57683 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57684 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57686 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57688 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57689 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57691 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57695 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57696 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57697 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57699 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57700 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57701 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57702 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57706 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57707 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57708 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57709 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57711 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57712 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57717 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57718 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57719 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57720 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57721 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57723 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57724 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57725 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57727 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57728 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57730 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57732 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57735 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57736 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57737 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57738 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57739 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57740 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57741 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57744 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57748 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57754 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57760 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57761 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57762 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57763 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57764 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57765 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57771 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57772 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57775 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57776 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57777 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57779 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57780 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57782 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57784 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57785 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57787 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57788 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57789 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57790 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
57795 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
57796 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
57797 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
57798 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
57799 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
57800 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57801 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57802 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
57807 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
57809 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
57810 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
57811 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
57812 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
57813 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
57814 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
57816 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
57820 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
57821 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
57822 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
57823 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
57824 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
57825 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
57826 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
57828 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
57829 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
57830 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57833 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
57836 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
57837 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
57838 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57839 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
57840 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
57841 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
57842 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
57848 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
57849 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
57850 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
57851 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
57852 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57853 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57855 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
57856 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
57857 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
57858 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
57859 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
57862 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
57863 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
57865 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
57866 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
57871 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
57873 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
57874 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
57875 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
57876 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
57877 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57878 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
57882 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
57883 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
57892 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
57893 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
57894 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
57895 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
57898 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
57900 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
57901 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
57902 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
57903 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
57905 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
57908 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
57910 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
57911 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
57912 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
57913 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
57914 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
57915 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
57916 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
57917 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
57918 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
57919 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
57920 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
57922 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
57923 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
57924 { NULL, NULL, 0, NULL }
57925 };
57926
57927
57928 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
57929
57930 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
57931 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
57932 }
57933 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
57934 return (void *)((wxSizer *) ((wxBoxSizer *) x));
57935 }
57936 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
57937 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
57938 }
57939 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
57940 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57941 }
57942 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
57943 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
57944 }
57945 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
57946 return (void *)((wxSizer *) ((wxGridSizer *) x));
57947 }
57948 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
57949 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
57950 }
57951 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
57952 return (void *)((wxSizer *) ((wxPySizer *) x));
57953 }
57954 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
57955 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
57956 }
57957 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
57958 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
57959 }
57960 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
57961 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
57962 }
57963 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
57964 return (void *)((wxEvent *) ((wxMenuEvent *) x));
57965 }
57966 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
57967 return (void *)((wxEvent *) ((wxCloseEvent *) x));
57968 }
57969 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
57970 return (void *)((wxEvent *) ((wxMouseEvent *) x));
57971 }
57972 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
57973 return (void *)((wxEvent *) ((wxEraseEvent *) x));
57974 }
57975 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
57976 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
57977 }
57978 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
57979 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
57980 }
57981 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
57982 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
57983 }
57984 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
57985 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
57986 }
57987 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
57988 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
57989 }
57990 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
57991 return (void *)((wxEvent *) ((wxPyEvent *) x));
57992 }
57993 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
57994 return (void *)((wxEvent *) ((wxIdleEvent *) x));
57995 }
57996 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
57997 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
57998 }
57999 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58000 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58001 }
58002 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58003 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58004 }
58005 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58006 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58007 }
58008 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58009 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58010 }
58011 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58012 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58013 }
58014 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58015 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58016 }
58017 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58018 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58019 }
58020 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58021 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58022 }
58023 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58024 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58025 }
58026 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58027 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58028 }
58029 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58030 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58031 }
58032 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58033 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58034 }
58035 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58036 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58037 }
58038 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58039 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58040 }
58041 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58042 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58043 }
58044 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58045 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58046 }
58047 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58048 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58049 }
58050 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58051 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58052 }
58053 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58054 return (void *)((wxEvent *) ((wxShowEvent *) x));
58055 }
58056 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58057 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58058 }
58059 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58060 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58061 }
58062 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58063 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58064 }
58065 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58066 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58067 }
58068 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58069 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58070 }
58071 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58072 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58073 }
58074 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58075 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58076 }
58077 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58078 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58079 }
58080 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58081 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58082 }
58083 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58084 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58085 }
58086 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58087 return (void *)((wxControl *) ((wxControlWithItems *) x));
58088 }
58089 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58090 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58091 }
58092 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58093 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58094 }
58095 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58096 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58097 }
58098 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58099 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58100 }
58101 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58102 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58103 }
58104 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58105 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58106 }
58107 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58108 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58109 }
58110 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58111 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58112 }
58113 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58114 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58115 }
58116 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58117 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58118 }
58119 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58120 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58121 }
58122 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58123 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58124 }
58125 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58126 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58127 }
58128 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58129 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58130 }
58131 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58132 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58133 }
58134 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58135 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58136 }
58137 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58138 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58139 }
58140 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58141 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58142 }
58143 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58144 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58145 }
58146 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58147 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58148 }
58149 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58150 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58151 }
58152 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58153 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58154 }
58155 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58156 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58157 }
58158 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58159 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58160 }
58161 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58162 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58163 }
58164 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58165 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58166 }
58167 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58168 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58169 }
58170 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58171 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58172 }
58173 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58174 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58175 }
58176 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58177 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58178 }
58179 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58180 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58181 }
58182 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58183 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58184 }
58185 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58186 return (void *)((wxObject *) ((wxSizerItem *) x));
58187 }
58188 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58189 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58190 }
58191 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58192 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58193 }
58194 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58195 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58196 }
58197 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58198 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58199 }
58200 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58201 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58202 }
58203 static void *_p_wxSizerTo_p_wxObject(void *x) {
58204 return (void *)((wxObject *) ((wxSizer *) x));
58205 }
58206 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58207 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58208 }
58209 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58210 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58211 }
58212 static void *_p_wxEventTo_p_wxObject(void *x) {
58213 return (void *)((wxObject *) ((wxEvent *) x));
58214 }
58215 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58216 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58217 }
58218 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58219 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58220 }
58221 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58222 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58223 }
58224 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58225 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58226 }
58227 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58228 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58229 }
58230 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58231 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58232 }
58233 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58234 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58235 }
58236 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58237 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58238 }
58239 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58240 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58241 }
58242 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58243 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58244 }
58245 static void *_p_wxControlTo_p_wxObject(void *x) {
58246 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58247 }
58248 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58249 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58250 }
58251 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58252 return (void *)((wxObject *) ((wxFSFile *) x));
58253 }
58254 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58255 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58256 }
58257 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58258 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58259 }
58260 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58261 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58262 }
58263 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58264 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58265 }
58266 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58267 return (void *)((wxObject *) ((wxMenuItem *) x));
58268 }
58269 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58270 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58271 }
58272 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58273 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58274 }
58275 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58276 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58277 }
58278 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58279 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58280 }
58281 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58282 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58283 }
58284 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58285 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58286 }
58287 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58288 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58289 }
58290 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58291 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58292 }
58293 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58294 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58295 }
58296 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58297 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58298 }
58299 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58300 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58301 }
58302 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58303 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58304 }
58305 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58306 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58307 }
58308 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58309 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58310 }
58311 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58312 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58313 }
58314 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58315 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58316 }
58317 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58318 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58319 }
58320 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58321 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58322 }
58323 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58324 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58325 }
58326 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58327 return (void *)((wxObject *) ((wxImageHandler *) x));
58328 }
58329 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58330 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58331 }
58332 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58333 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58334 }
58335 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58336 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58337 }
58338 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58339 return (void *)((wxObject *) ((wxEvtHandler *) x));
58340 }
58341 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58342 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58343 }
58344 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58345 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58346 }
58347 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58348 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58349 }
58350 static void *_p_wxImageTo_p_wxObject(void *x) {
58351 return (void *)((wxObject *) ((wxImage *) x));
58352 }
58353 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58354 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58355 }
58356 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58357 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58358 }
58359 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58360 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58361 }
58362 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58363 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58364 }
58365 static void *_p_wxWindowTo_p_wxObject(void *x) {
58366 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58367 }
58368 static void *_p_wxMenuTo_p_wxObject(void *x) {
58369 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58370 }
58371 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58372 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58373 }
58374 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58375 return (void *)((wxObject *) ((wxFileSystem *) x));
58376 }
58377 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58378 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58379 }
58380 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58381 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58382 }
58383 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58384 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58385 }
58386 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58387 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58388 }
58389 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58390 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58391 }
58392 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58393 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58394 }
58395 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58396 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58397 }
58398 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58399 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58400 }
58401 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58402 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58403 }
58404 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58405 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58406 }
58407 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58408 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58409 }
58410 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58411 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58412 }
58413 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58414 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58415 }
58416 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58417 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58418 }
58419 static void *_p_wxControlTo_p_wxWindow(void *x) {
58420 return (void *)((wxWindow *) ((wxControl *) x));
58421 }
58422 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58423 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58424 }
58425 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58426 return (void *)((wxWindow *) ((wxMenuBar *) x));
58427 }
58428 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58429 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58430 }
58431 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58432 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58433 }
58434 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58435 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58436 }
58437 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58438 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58439 }
58440 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58441 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58442 }
58443 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58444 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58445 }
58446 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58447 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58448 }
58449 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58450 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58451 }
58452 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58453 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58454 }
58455 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58456 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58457 }
58458 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58459 return (void *)((wxValidator *) ((wxPyValidator *) x));
58460 }
58461 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58462 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58463 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};
58464 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58465 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58466 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58467 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58468 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58469 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58470 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58471 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58472 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58473 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58474 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58475 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58476 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58477 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58478 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58479 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58480 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58481 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58482 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58483 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58484 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58485 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58486 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58487 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58488 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58489 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58490 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58491 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58492 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58493 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58494 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58495 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58496 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58497 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58498 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58499 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58500 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58501 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58502 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58503 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58504 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58505 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58506 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58507 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58508 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58509 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58510 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58511 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58512 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58513 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58514 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58515 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58516 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58517 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58518 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58519 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58520 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58521 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58522 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58523 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58524 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58525 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58526 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58527 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58528 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58529 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58530 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58531 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58532 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58533 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58534 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58535 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58536 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58537 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58538 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58539 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58540 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58541 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58542 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58543 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58544 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58545 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58546 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58547 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58548 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58549 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58550 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58551 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58552 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58553 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58554 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58555 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58556 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58557 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58558 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58559 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58560 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58561 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58562 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58563 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58564 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58565 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58566 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58567 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58568 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58569 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58570 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58571 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58572 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58573 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58574 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58575 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58576 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58577 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58578 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58579 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58580 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58581 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58582 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58583 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58584 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58585 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58586 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58587 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58588 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58589 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58590 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58591 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58592 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58593 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58594 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58595 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58596
58597 static swig_type_info *swig_type_initial[] = {
58598 &_swigt__p_buffer,
58599 &_swigt__p_char,
58600 &_swigt__p_form_ops_t,
58601 &_swigt__p_int,
58602 &_swigt__p_long,
58603 &_swigt__p_unsigned_char,
58604 &_swigt__p_unsigned_int,
58605 &_swigt__p_unsigned_long,
58606 &_swigt__p_wxANIHandler,
58607 &_swigt__p_wxAcceleratorEntry,
58608 &_swigt__p_wxAcceleratorTable,
58609 &_swigt__p_wxActivateEvent,
58610 &_swigt__p_wxAppTraits,
58611 &_swigt__p_wxArrayString,
58612 &_swigt__p_wxBMPHandler,
58613 &_swigt__p_wxBitmap,
58614 &_swigt__p_wxBoxSizer,
58615 &_swigt__p_wxButton,
58616 &_swigt__p_wxCURHandler,
58617 &_swigt__p_wxCaret,
58618 &_swigt__p_wxChildFocusEvent,
58619 &_swigt__p_wxClipboardTextEvent,
58620 &_swigt__p_wxCloseEvent,
58621 &_swigt__p_wxColour,
58622 &_swigt__p_wxCommandEvent,
58623 &_swigt__p_wxContextMenuEvent,
58624 &_swigt__p_wxControl,
58625 &_swigt__p_wxControlWithItems,
58626 &_swigt__p_wxCursor,
58627 &_swigt__p_wxDC,
58628 &_swigt__p_wxDateEvent,
58629 &_swigt__p_wxDateTime,
58630 &_swigt__p_wxDisplayChangedEvent,
58631 &_swigt__p_wxDouble,
58632 &_swigt__p_wxDropFilesEvent,
58633 &_swigt__p_wxDuplexMode,
58634 &_swigt__p_wxEraseEvent,
58635 &_swigt__p_wxEvent,
58636 &_swigt__p_wxEventLoop,
58637 &_swigt__p_wxEventLoopActivator,
58638 &_swigt__p_wxEvtHandler,
58639 &_swigt__p_wxFSFile,
58640 &_swigt__p_wxFileSystem,
58641 &_swigt__p_wxFileSystemHandler,
58642 &_swigt__p_wxFlexGridSizer,
58643 &_swigt__p_wxFocusEvent,
58644 &_swigt__p_wxFont,
58645 &_swigt__p_wxFrame,
58646 &_swigt__p_wxGBPosition,
58647 &_swigt__p_wxGBSizerItem,
58648 &_swigt__p_wxGBSpan,
58649 &_swigt__p_wxGIFHandler,
58650 &_swigt__p_wxGridBagSizer,
58651 &_swigt__p_wxGridSizer,
58652 &_swigt__p_wxHelpEvent__Origin,
58653 &_swigt__p_wxICOHandler,
58654 &_swigt__p_wxIconizeEvent,
58655 &_swigt__p_wxIdleEvent,
58656 &_swigt__p_wxImage,
58657 &_swigt__p_wxImageHandler,
58658 &_swigt__p_wxImageHistogram,
58659 &_swigt__p_wxImage_HSVValue,
58660 &_swigt__p_wxImage_RGBValue,
58661 &_swigt__p_wxIndividualLayoutConstraint,
58662 &_swigt__p_wxInitDialogEvent,
58663 &_swigt__p_wxInputStream,
58664 &_swigt__p_wxInternetFSHandler,
58665 &_swigt__p_wxItemContainer,
58666 &_swigt__p_wxJPEGHandler,
58667 &_swigt__p_wxKeyEvent,
58668 &_swigt__p_wxLayoutConstraints,
58669 &_swigt__p_wxMaximizeEvent,
58670 &_swigt__p_wxMemoryFSHandler,
58671 &_swigt__p_wxMenu,
58672 &_swigt__p_wxMenuBar,
58673 &_swigt__p_wxMenuBarBase,
58674 &_swigt__p_wxMenuEvent,
58675 &_swigt__p_wxMenuItem,
58676 &_swigt__p_wxMouseCaptureChangedEvent,
58677 &_swigt__p_wxMouseCaptureLostEvent,
58678 &_swigt__p_wxMouseEvent,
58679 &_swigt__p_wxMoveEvent,
58680 &_swigt__p_wxNavigationKeyEvent,
58681 &_swigt__p_wxNcPaintEvent,
58682 &_swigt__p_wxNotifyEvent,
58683 &_swigt__p_wxObject,
58684 &_swigt__p_wxOutputStream,
58685 &_swigt__p_wxPCXHandler,
58686 &_swigt__p_wxPNGHandler,
58687 &_swigt__p_wxPNMHandler,
58688 &_swigt__p_wxPaintEvent,
58689 &_swigt__p_wxPaletteChangedEvent,
58690 &_swigt__p_wxPaperSize,
58691 &_swigt__p_wxPoint,
58692 &_swigt__p_wxPoint2D,
58693 &_swigt__p_wxPropagateOnce,
58694 &_swigt__p_wxPropagationDisabler,
58695 &_swigt__p_wxPyApp,
58696 &_swigt__p_wxPyCommandEvent,
58697 &_swigt__p_wxPyDropTarget,
58698 &_swigt__p_wxPyEvent,
58699 &_swigt__p_wxPyFileSystemHandler,
58700 &_swigt__p_wxPyImageHandler,
58701 &_swigt__p_wxPyInputStream,
58702 &_swigt__p_wxPySizer,
58703 &_swigt__p_wxPyValidator,
58704 &_swigt__p_wxQuantize,
58705 &_swigt__p_wxQueryNewPaletteEvent,
58706 &_swigt__p_wxRealPoint,
58707 &_swigt__p_wxRect,
58708 &_swigt__p_wxRect2D,
58709 &_swigt__p_wxRegion,
58710 &_swigt__p_wxScrollEvent,
58711 &_swigt__p_wxScrollWinEvent,
58712 &_swigt__p_wxSetCursorEvent,
58713 &_swigt__p_wxShowEvent,
58714 &_swigt__p_wxSize,
58715 &_swigt__p_wxSizeEvent,
58716 &_swigt__p_wxSizer,
58717 &_swigt__p_wxSizerItem,
58718 &_swigt__p_wxStaticBox,
58719 &_swigt__p_wxStaticBoxSizer,
58720 &_swigt__p_wxStdDialogButtonSizer,
58721 &_swigt__p_wxSysColourChangedEvent,
58722 &_swigt__p_wxTGAHandler,
58723 &_swigt__p_wxTIFFHandler,
58724 &_swigt__p_wxToolTip,
58725 &_swigt__p_wxUpdateUIEvent,
58726 &_swigt__p_wxValidator,
58727 &_swigt__p_wxVisualAttributes,
58728 &_swigt__p_wxWindow,
58729 &_swigt__p_wxWindowCreateEvent,
58730 &_swigt__p_wxWindowDestroyEvent,
58731 &_swigt__p_wxXPMHandler,
58732 &_swigt__p_wxZipFSHandler,
58733 };
58734
58735 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58736 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58737 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58738 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58739 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58740 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58741 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58742 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58743 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58744 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58745 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58746 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58747 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58748 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58749 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}};
58750 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58751 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}};
58752 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58753 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}};
58754 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58755 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58756 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58757 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58758 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58759 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}};
58760 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58761 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}};
58762 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58763 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58764 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58765 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58766 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58767 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58768 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58769 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58770 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58771 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58772 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}};
58773 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58774 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58775 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}};
58776 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58777 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58778 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}};
58779 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}};
58780 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58781 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58782 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
58783 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
58784 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
58785 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
58786 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
58787 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
58788 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}};
58789 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
58790 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}};
58791 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58792 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
58793 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
58794 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}};
58795 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
58796 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
58797 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
58798 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
58799 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
58800 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
58801 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58802 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}};
58803 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
58804 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58805 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
58806 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58807 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58808 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
58809 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
58810 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
58811 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58812 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
58813 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58814 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
58815 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
58816 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
58817 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
58818 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58819 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
58820 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}};
58821 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
58822 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
58823 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
58824 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
58825 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
58826 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58827 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
58828 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
58829 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
58830 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
58831 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
58832 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
58833 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
58834 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
58835 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
58836 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
58837 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
58838 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
58839 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
58840 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
58841 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
58842 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
58843 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
58844 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
58845 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
58846 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
58847 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
58848 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
58849 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
58850 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
58851 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
58852 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
58853 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}};
58854 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}};
58855 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
58856 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
58857 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
58858 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58859 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
58860 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
58861 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
58862 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
58863 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}};
58864 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
58865 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}};
58866 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
58867 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
58868 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
58869 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
58870
58871 static swig_cast_info *swig_cast_initial[] = {
58872 _swigc__p_buffer,
58873 _swigc__p_char,
58874 _swigc__p_form_ops_t,
58875 _swigc__p_int,
58876 _swigc__p_long,
58877 _swigc__p_unsigned_char,
58878 _swigc__p_unsigned_int,
58879 _swigc__p_unsigned_long,
58880 _swigc__p_wxANIHandler,
58881 _swigc__p_wxAcceleratorEntry,
58882 _swigc__p_wxAcceleratorTable,
58883 _swigc__p_wxActivateEvent,
58884 _swigc__p_wxAppTraits,
58885 _swigc__p_wxArrayString,
58886 _swigc__p_wxBMPHandler,
58887 _swigc__p_wxBitmap,
58888 _swigc__p_wxBoxSizer,
58889 _swigc__p_wxButton,
58890 _swigc__p_wxCURHandler,
58891 _swigc__p_wxCaret,
58892 _swigc__p_wxChildFocusEvent,
58893 _swigc__p_wxClipboardTextEvent,
58894 _swigc__p_wxCloseEvent,
58895 _swigc__p_wxColour,
58896 _swigc__p_wxCommandEvent,
58897 _swigc__p_wxContextMenuEvent,
58898 _swigc__p_wxControl,
58899 _swigc__p_wxControlWithItems,
58900 _swigc__p_wxCursor,
58901 _swigc__p_wxDC,
58902 _swigc__p_wxDateEvent,
58903 _swigc__p_wxDateTime,
58904 _swigc__p_wxDisplayChangedEvent,
58905 _swigc__p_wxDouble,
58906 _swigc__p_wxDropFilesEvent,
58907 _swigc__p_wxDuplexMode,
58908 _swigc__p_wxEraseEvent,
58909 _swigc__p_wxEvent,
58910 _swigc__p_wxEventLoop,
58911 _swigc__p_wxEventLoopActivator,
58912 _swigc__p_wxEvtHandler,
58913 _swigc__p_wxFSFile,
58914 _swigc__p_wxFileSystem,
58915 _swigc__p_wxFileSystemHandler,
58916 _swigc__p_wxFlexGridSizer,
58917 _swigc__p_wxFocusEvent,
58918 _swigc__p_wxFont,
58919 _swigc__p_wxFrame,
58920 _swigc__p_wxGBPosition,
58921 _swigc__p_wxGBSizerItem,
58922 _swigc__p_wxGBSpan,
58923 _swigc__p_wxGIFHandler,
58924 _swigc__p_wxGridBagSizer,
58925 _swigc__p_wxGridSizer,
58926 _swigc__p_wxHelpEvent__Origin,
58927 _swigc__p_wxICOHandler,
58928 _swigc__p_wxIconizeEvent,
58929 _swigc__p_wxIdleEvent,
58930 _swigc__p_wxImage,
58931 _swigc__p_wxImageHandler,
58932 _swigc__p_wxImageHistogram,
58933 _swigc__p_wxImage_HSVValue,
58934 _swigc__p_wxImage_RGBValue,
58935 _swigc__p_wxIndividualLayoutConstraint,
58936 _swigc__p_wxInitDialogEvent,
58937 _swigc__p_wxInputStream,
58938 _swigc__p_wxInternetFSHandler,
58939 _swigc__p_wxItemContainer,
58940 _swigc__p_wxJPEGHandler,
58941 _swigc__p_wxKeyEvent,
58942 _swigc__p_wxLayoutConstraints,
58943 _swigc__p_wxMaximizeEvent,
58944 _swigc__p_wxMemoryFSHandler,
58945 _swigc__p_wxMenu,
58946 _swigc__p_wxMenuBar,
58947 _swigc__p_wxMenuBarBase,
58948 _swigc__p_wxMenuEvent,
58949 _swigc__p_wxMenuItem,
58950 _swigc__p_wxMouseCaptureChangedEvent,
58951 _swigc__p_wxMouseCaptureLostEvent,
58952 _swigc__p_wxMouseEvent,
58953 _swigc__p_wxMoveEvent,
58954 _swigc__p_wxNavigationKeyEvent,
58955 _swigc__p_wxNcPaintEvent,
58956 _swigc__p_wxNotifyEvent,
58957 _swigc__p_wxObject,
58958 _swigc__p_wxOutputStream,
58959 _swigc__p_wxPCXHandler,
58960 _swigc__p_wxPNGHandler,
58961 _swigc__p_wxPNMHandler,
58962 _swigc__p_wxPaintEvent,
58963 _swigc__p_wxPaletteChangedEvent,
58964 _swigc__p_wxPaperSize,
58965 _swigc__p_wxPoint,
58966 _swigc__p_wxPoint2D,
58967 _swigc__p_wxPropagateOnce,
58968 _swigc__p_wxPropagationDisabler,
58969 _swigc__p_wxPyApp,
58970 _swigc__p_wxPyCommandEvent,
58971 _swigc__p_wxPyDropTarget,
58972 _swigc__p_wxPyEvent,
58973 _swigc__p_wxPyFileSystemHandler,
58974 _swigc__p_wxPyImageHandler,
58975 _swigc__p_wxPyInputStream,
58976 _swigc__p_wxPySizer,
58977 _swigc__p_wxPyValidator,
58978 _swigc__p_wxQuantize,
58979 _swigc__p_wxQueryNewPaletteEvent,
58980 _swigc__p_wxRealPoint,
58981 _swigc__p_wxRect,
58982 _swigc__p_wxRect2D,
58983 _swigc__p_wxRegion,
58984 _swigc__p_wxScrollEvent,
58985 _swigc__p_wxScrollWinEvent,
58986 _swigc__p_wxSetCursorEvent,
58987 _swigc__p_wxShowEvent,
58988 _swigc__p_wxSize,
58989 _swigc__p_wxSizeEvent,
58990 _swigc__p_wxSizer,
58991 _swigc__p_wxSizerItem,
58992 _swigc__p_wxStaticBox,
58993 _swigc__p_wxStaticBoxSizer,
58994 _swigc__p_wxStdDialogButtonSizer,
58995 _swigc__p_wxSysColourChangedEvent,
58996 _swigc__p_wxTGAHandler,
58997 _swigc__p_wxTIFFHandler,
58998 _swigc__p_wxToolTip,
58999 _swigc__p_wxUpdateUIEvent,
59000 _swigc__p_wxValidator,
59001 _swigc__p_wxVisualAttributes,
59002 _swigc__p_wxWindow,
59003 _swigc__p_wxWindowCreateEvent,
59004 _swigc__p_wxWindowDestroyEvent,
59005 _swigc__p_wxXPMHandler,
59006 _swigc__p_wxZipFSHandler,
59007 };
59008
59009
59010 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59011
59012 static swig_const_info swig_const_table[] = {
59013 {0, 0, 0, 0.0, 0, 0}};
59014
59015 #ifdef __cplusplus
59016 }
59017 #endif
59018 /* -----------------------------------------------------------------------------
59019 * Type initialization:
59020 * This problem is tough by the requirement that no dynamic
59021 * memory is used. Also, since swig_type_info structures store pointers to
59022 * swig_cast_info structures and swig_cast_info structures store pointers back
59023 * to swig_type_info structures, we need some lookup code at initialization.
59024 * The idea is that swig generates all the structures that are needed.
59025 * The runtime then collects these partially filled structures.
59026 * The SWIG_InitializeModule function takes these initial arrays out of
59027 * swig_module, and does all the lookup, filling in the swig_module.types
59028 * array with the correct data and linking the correct swig_cast_info
59029 * structures together.
59030 *
59031 * The generated swig_type_info structures are assigned staticly to an initial
59032 * array. We just loop though that array, and handle each type individually.
59033 * First we lookup if this type has been already loaded, and if so, use the
59034 * loaded structure instead of the generated one. Then we have to fill in the
59035 * cast linked list. The cast data is initially stored in something like a
59036 * two-dimensional array. Each row corresponds to a type (there are the same
59037 * number of rows as there are in the swig_type_initial array). Each entry in
59038 * a column is one of the swig_cast_info structures for that type.
59039 * The cast_initial array is actually an array of arrays, because each row has
59040 * a variable number of columns. So to actually build the cast linked list,
59041 * we find the array of casts associated with the type, and loop through it
59042 * adding the casts to the list. The one last trick we need to do is making
59043 * sure the type pointer in the swig_cast_info struct is correct.
59044 *
59045 * First off, we lookup the cast->type name to see if it is already loaded.
59046 * There are three cases to handle:
59047 * 1) If the cast->type has already been loaded AND the type we are adding
59048 * casting info to has not been loaded (it is in this module), THEN we
59049 * replace the cast->type pointer with the type pointer that has already
59050 * been loaded.
59051 * 2) If BOTH types (the one we are adding casting info to, and the
59052 * cast->type) are loaded, THEN the cast info has already been loaded by
59053 * the previous module so we just ignore it.
59054 * 3) Finally, if cast->type has not already been loaded, then we add that
59055 * swig_cast_info to the linked list (because the cast->type) pointer will
59056 * be correct.
59057 * ----------------------------------------------------------------------------- */
59058
59059 #ifdef __cplusplus
59060 extern "C" {
59061 #if 0
59062 } /* c-mode */
59063 #endif
59064 #endif
59065
59066 #if 0
59067 #define SWIGRUNTIME_DEBUG
59068 #endif
59069
59070 SWIGRUNTIME void
59071 SWIG_InitializeModule(void *clientdata) {
59072 size_t i;
59073 swig_module_info *module_head;
59074 static int init_run = 0;
59075
59076 clientdata = clientdata;
59077
59078 if (init_run) return;
59079 init_run = 1;
59080
59081 /* Initialize the swig_module */
59082 swig_module.type_initial = swig_type_initial;
59083 swig_module.cast_initial = swig_cast_initial;
59084
59085 /* Try and load any already created modules */
59086 module_head = SWIG_GetModule(clientdata);
59087 if (module_head) {
59088 swig_module.next = module_head->next;
59089 module_head->next = &swig_module;
59090 } else {
59091 /* This is the first module loaded */
59092 swig_module.next = &swig_module;
59093 SWIG_SetModule(clientdata, &swig_module);
59094 }
59095
59096 /* Now work on filling in swig_module.types */
59097 #ifdef SWIGRUNTIME_DEBUG
59098 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59099 #endif
59100 for (i = 0; i < swig_module.size; ++i) {
59101 swig_type_info *type = 0;
59102 swig_type_info *ret;
59103 swig_cast_info *cast;
59104
59105 #ifdef SWIGRUNTIME_DEBUG
59106 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59107 #endif
59108
59109 /* if there is another module already loaded */
59110 if (swig_module.next != &swig_module) {
59111 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59112 }
59113 if (type) {
59114 /* Overwrite clientdata field */
59115 #ifdef SWIGRUNTIME_DEBUG
59116 printf("SWIG_InitializeModule: found type %s\n", type->name);
59117 #endif
59118 if (swig_module.type_initial[i]->clientdata) {
59119 type->clientdata = swig_module.type_initial[i]->clientdata;
59120 #ifdef SWIGRUNTIME_DEBUG
59121 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59122 #endif
59123 }
59124 } else {
59125 type = swig_module.type_initial[i];
59126 }
59127
59128 /* Insert casting types */
59129 cast = swig_module.cast_initial[i];
59130 while (cast->type) {
59131 /* Don't need to add information already in the list */
59132 ret = 0;
59133 #ifdef SWIGRUNTIME_DEBUG
59134 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59135 #endif
59136 if (swig_module.next != &swig_module) {
59137 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59138 #ifdef SWIGRUNTIME_DEBUG
59139 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59140 #endif
59141 }
59142 if (ret) {
59143 if (type == swig_module.type_initial[i]) {
59144 #ifdef SWIGRUNTIME_DEBUG
59145 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59146 #endif
59147 cast->type = ret;
59148 ret = 0;
59149 } else {
59150 /* Check for casting already in the list */
59151 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59152 #ifdef SWIGRUNTIME_DEBUG
59153 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59154 #endif
59155 if (!ocast) ret = 0;
59156 }
59157 }
59158
59159 if (!ret) {
59160 #ifdef SWIGRUNTIME_DEBUG
59161 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59162 #endif
59163 if (type->cast) {
59164 type->cast->prev = cast;
59165 cast->next = type->cast;
59166 }
59167 type->cast = cast;
59168 }
59169 cast++;
59170 }
59171 /* Set entry in modules->types array equal to the type */
59172 swig_module.types[i] = type;
59173 }
59174 swig_module.types[i] = 0;
59175
59176 #ifdef SWIGRUNTIME_DEBUG
59177 printf("**** SWIG_InitializeModule: Cast List ******\n");
59178 for (i = 0; i < swig_module.size; ++i) {
59179 int j = 0;
59180 swig_cast_info *cast = swig_module.cast_initial[i];
59181 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59182 while (cast->type) {
59183 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59184 cast++;
59185 ++j;
59186 }
59187 printf("---- Total casts: %d\n",j);
59188 }
59189 printf("**** SWIG_InitializeModule: Cast List ******\n");
59190 #endif
59191 }
59192
59193 /* This function will propagate the clientdata field of type to
59194 * any new swig_type_info structures that have been added into the list
59195 * of equivalent types. It is like calling
59196 * SWIG_TypeClientData(type, clientdata) a second time.
59197 */
59198 SWIGRUNTIME void
59199 SWIG_PropagateClientData(void) {
59200 size_t i;
59201 swig_cast_info *equiv;
59202 static int init_run = 0;
59203
59204 if (init_run) return;
59205 init_run = 1;
59206
59207 for (i = 0; i < swig_module.size; i++) {
59208 if (swig_module.types[i]->clientdata) {
59209 equiv = swig_module.types[i]->cast;
59210 while (equiv) {
59211 if (!equiv->converter) {
59212 if (equiv->type && !equiv->type->clientdata)
59213 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59214 }
59215 equiv = equiv->next;
59216 }
59217 }
59218 }
59219 }
59220
59221 #ifdef __cplusplus
59222 #if 0
59223 {
59224 /* c-mode */
59225 #endif
59226 }
59227 #endif
59228
59229
59230
59231 #ifdef __cplusplus
59232 extern "C" {
59233 #endif
59234
59235 /* Python-specific SWIG API */
59236 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59237 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59238 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59239
59240 /* -----------------------------------------------------------------------------
59241 * global variable support code.
59242 * ----------------------------------------------------------------------------- */
59243
59244 typedef struct swig_globalvar {
59245 char *name; /* Name of global variable */
59246 PyObject *(*get_attr)(void); /* Return the current value */
59247 int (*set_attr)(PyObject *); /* Set the value */
59248 struct swig_globalvar *next;
59249 } swig_globalvar;
59250
59251 typedef struct swig_varlinkobject {
59252 PyObject_HEAD
59253 swig_globalvar *vars;
59254 } swig_varlinkobject;
59255
59256 SWIGINTERN PyObject *
59257 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59258 return PyString_FromString("<Swig global variables>");
59259 }
59260
59261 SWIGINTERN PyObject *
59262 swig_varlink_str(swig_varlinkobject *v) {
59263 PyObject *str = PyString_FromString("(");
59264 swig_globalvar *var;
59265 for (var = v->vars; var; var=var->next) {
59266 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59267 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59268 }
59269 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59270 return str;
59271 }
59272
59273 SWIGINTERN int
59274 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59275 PyObject *str = swig_varlink_str(v);
59276 fprintf(fp,"Swig global variables ");
59277 fprintf(fp,"%s\n", PyString_AsString(str));
59278 Py_DECREF(str);
59279 return 0;
59280 }
59281
59282 SWIGINTERN void
59283 swig_varlink_dealloc(swig_varlinkobject *v) {
59284 swig_globalvar *var = v->vars;
59285 while (var) {
59286 swig_globalvar *n = var->next;
59287 free(var->name);
59288 free(var);
59289 var = n;
59290 }
59291 }
59292
59293 SWIGINTERN PyObject *
59294 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59295 PyObject *res = NULL;
59296 swig_globalvar *var = v->vars;
59297 while (var) {
59298 if (strcmp(var->name,n) == 0) {
59299 res = (*var->get_attr)();
59300 break;
59301 }
59302 var = var->next;
59303 }
59304 if (res == NULL && !PyErr_Occurred()) {
59305 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59306 }
59307 return res;
59308 }
59309
59310 SWIGINTERN int
59311 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59312 int res = 1;
59313 swig_globalvar *var = v->vars;
59314 while (var) {
59315 if (strcmp(var->name,n) == 0) {
59316 res = (*var->set_attr)(p);
59317 break;
59318 }
59319 var = var->next;
59320 }
59321 if (res == 1 && !PyErr_Occurred()) {
59322 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59323 }
59324 return res;
59325 }
59326
59327 SWIGINTERN PyTypeObject*
59328 swig_varlink_type(void) {
59329 static char varlink__doc__[] = "Swig var link object";
59330 static PyTypeObject varlink_type;
59331 static int type_init = 0;
59332 if (!type_init) {
59333 const PyTypeObject tmp
59334 = {
59335 PyObject_HEAD_INIT(NULL)
59336 0, /* Number of items in variable part (ob_size) */
59337 (char *)"swigvarlink", /* Type name (tp_name) */
59338 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59339 0, /* Itemsize (tp_itemsize) */
59340 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59341 (printfunc) swig_varlink_print, /* Print (tp_print) */
59342 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59343 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59344 0, /* tp_compare */
59345 (reprfunc) swig_varlink_repr, /* tp_repr */
59346 0, /* tp_as_number */
59347 0, /* tp_as_sequence */
59348 0, /* tp_as_mapping */
59349 0, /* tp_hash */
59350 0, /* tp_call */
59351 (reprfunc)swig_varlink_str, /* tp_str */
59352 0, /* tp_getattro */
59353 0, /* tp_setattro */
59354 0, /* tp_as_buffer */
59355 0, /* tp_flags */
59356 varlink__doc__, /* tp_doc */
59357 0, /* tp_traverse */
59358 0, /* tp_clear */
59359 0, /* tp_richcompare */
59360 0, /* tp_weaklistoffset */
59361 #if PY_VERSION_HEX >= 0x02020000
59362 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59363 #endif
59364 #if PY_VERSION_HEX >= 0x02030000
59365 0, /* tp_del */
59366 #endif
59367 #ifdef COUNT_ALLOCS
59368 0,0,0,0 /* tp_alloc -> tp_next */
59369 #endif
59370 };
59371 varlink_type = tmp;
59372 varlink_type.ob_type = &PyType_Type;
59373 type_init = 1;
59374 }
59375 return &varlink_type;
59376 }
59377
59378 /* Create a variable linking object for use later */
59379 SWIGINTERN PyObject *
59380 SWIG_Python_newvarlink(void) {
59381 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59382 if (result) {
59383 result->vars = 0;
59384 }
59385 return ((PyObject*) result);
59386 }
59387
59388 SWIGINTERN void
59389 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59390 swig_varlinkobject *v = (swig_varlinkobject *) p;
59391 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59392 if (gv) {
59393 size_t size = strlen(name)+1;
59394 gv->name = (char *)malloc(size);
59395 if (gv->name) {
59396 strncpy(gv->name,name,size);
59397 gv->get_attr = get_attr;
59398 gv->set_attr = set_attr;
59399 gv->next = v->vars;
59400 }
59401 }
59402 v->vars = gv;
59403 }
59404
59405 SWIGINTERN PyObject *
59406 SWIG_globals() {
59407 static PyObject *_SWIG_globals = 0;
59408 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59409 return _SWIG_globals;
59410 }
59411
59412 /* -----------------------------------------------------------------------------
59413 * constants/methods manipulation
59414 * ----------------------------------------------------------------------------- */
59415
59416 /* Install Constants */
59417 SWIGINTERN void
59418 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59419 PyObject *obj = 0;
59420 size_t i;
59421 for (i = 0; constants[i].type; ++i) {
59422 switch(constants[i].type) {
59423 case SWIG_PY_POINTER:
59424 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59425 break;
59426 case SWIG_PY_BINARY:
59427 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59428 break;
59429 default:
59430 obj = 0;
59431 break;
59432 }
59433 if (obj) {
59434 PyDict_SetItemString(d, constants[i].name, obj);
59435 Py_DECREF(obj);
59436 }
59437 }
59438 }
59439
59440 /* -----------------------------------------------------------------------------*/
59441 /* Fix SwigMethods to carry the callback ptrs when needed */
59442 /* -----------------------------------------------------------------------------*/
59443
59444 SWIGINTERN void
59445 SWIG_Python_FixMethods(PyMethodDef *methods,
59446 swig_const_info *const_table,
59447 swig_type_info **types,
59448 swig_type_info **types_initial) {
59449 size_t i;
59450 for (i = 0; methods[i].ml_name; ++i) {
59451 const char *c = methods[i].ml_doc;
59452 if (c && (c = strstr(c, "swig_ptr: "))) {
59453 int j;
59454 swig_const_info *ci = 0;
59455 const char *name = c + 10;
59456 for (j = 0; const_table[j].type; ++j) {
59457 if (strncmp(const_table[j].name, name,
59458 strlen(const_table[j].name)) == 0) {
59459 ci = &(const_table[j]);
59460 break;
59461 }
59462 }
59463 if (ci) {
59464 size_t shift = (ci->ptype) - types;
59465 swig_type_info *ty = types_initial[shift];
59466 size_t ldoc = (c - methods[i].ml_doc);
59467 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59468 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59469 if (ndoc) {
59470 char *buff = ndoc;
59471 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59472 if (ptr) {
59473 strncpy(buff, methods[i].ml_doc, ldoc);
59474 buff += ldoc;
59475 strncpy(buff, "swig_ptr: ", 10);
59476 buff += 10;
59477 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59478 methods[i].ml_doc = ndoc;
59479 }
59480 }
59481 }
59482 }
59483 }
59484 }
59485
59486 #ifdef __cplusplus
59487 }
59488 #endif
59489
59490 /* -----------------------------------------------------------------------------*
59491 * Partial Init method
59492 * -----------------------------------------------------------------------------*/
59493
59494 #ifdef __cplusplus
59495 extern "C"
59496 #endif
59497 SWIGEXPORT void SWIG_init(void) {
59498 PyObject *m, *d;
59499
59500 /* Fix SwigMethods to carry the callback ptrs when needed */
59501 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59502
59503 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59504 d = PyModule_GetDict(m);
59505
59506 SWIG_InitializeModule(0);
59507 SWIG_InstallConstants(d,swig_const_table);
59508
59509
59510
59511 #ifndef wxPyUSE_EXPORT
59512 // Make our API structure a CObject so other modules can import it
59513 // from this module.
59514 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59515 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59516 Py_XDECREF(cobj);
59517 #endif
59518
59519 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59520 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59521 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59522 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59523 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59524 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59525 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59526 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59527 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59528 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59529 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59530 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59531 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59532 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59533 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59534 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59535 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59536 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59537 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59538 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59539 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59540 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59541 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59542 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59543 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59544 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59545 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59546 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59547 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59548 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59549 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59550 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59551 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59552 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59553 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59554 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59555 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59556 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59557 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59558 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59559 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59560 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59561 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59562 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59563 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59564 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59565 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59566 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59567 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59568 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59569 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59570 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59571 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59572 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59573 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59574 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59575 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59576 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59577 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59578 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59579 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59580 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59581 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59582 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59583 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59584 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59585 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59586 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59587 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59588 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59589 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59590 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59591 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59592 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59593 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59594 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59595 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59596 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59597 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59598 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59599 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59600 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59601 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59602 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59603 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59604 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59605 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59606 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59607 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59608 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59609 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59610 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59611 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59612 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59613 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59614 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59615 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59616 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59617 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59618 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59619 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59620 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59621 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59622 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59623 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59624 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59625 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59626 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59627 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59628 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59629 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59630 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59631 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59632 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59633 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59634 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59635 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59636 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59637 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59638 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59639 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59640 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59641 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59642 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59643 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59644 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59645 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59646 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59647 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59648 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59649 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59650 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59651 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59652 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59653 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59654 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59655 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59656 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59657 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59658 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59659 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59660 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59661 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59662 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59663 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59664 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59665 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59666 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59667 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59668 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59669 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59670 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59671 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59672 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59673 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59674 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59675 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59676 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59677 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59678 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59679 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59680 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59681 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59682 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59683 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59684 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59685 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59686 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59687 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59688 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59689 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59690 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59691 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59692 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59693 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59694 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59695 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59696 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59697 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59698 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59699 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59700 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59701 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59702 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59703 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59704 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59705 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59706 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59707 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59708 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59709 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59710 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59711 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59712 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59713 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59714 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59715 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59716 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59717 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59718 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59719 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59720 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59721 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59722 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59723 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59724 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59725 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59726 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59727 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59728 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59729 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59730 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59731 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59732 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59733 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59734 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59735 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59736 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59737 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59738 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59739 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59740 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59741 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59742 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59743 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59744 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59745 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59746 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59747 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59748 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59749 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59750 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59751 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59752 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59753 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59754 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59755 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59756 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59757 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59758 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59759 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59760 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59761 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59762 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59763 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59764 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59765 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59766 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59767 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59768 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59769 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59770 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59771 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59772 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59773 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59774 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59775 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59776 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59777 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59778 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59779 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59780 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59781 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
59782 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
59783 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
59784 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
59785 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
59786 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
59787 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
59788 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
59789 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
59790 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
59791 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
59792 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
59793 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
59794 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
59795 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
59796 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
59797 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
59798 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
59799 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
59800 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
59801 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
59802 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
59803 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
59804 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
59805 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
59806 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
59807 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
59808 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
59809 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
59810 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
59811 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
59812 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
59813 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
59814 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
59815 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
59816 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
59817 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
59818 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
59819 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
59820 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
59821 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
59822 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
59823 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
59824 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
59825 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
59826 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
59827 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
59828 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
59829 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
59830 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
59831 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
59832 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
59833 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
59834 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
59835 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
59836 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
59837 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
59838 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
59839 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
59840 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
59841 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
59842 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
59843 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
59844 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
59845 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
59846 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
59847 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
59848 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
59849 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
59850 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
59851 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
59852 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
59853 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
59854 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
59855 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
59856 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
59857 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
59858 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
59859 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
59860 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
59861 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
59862 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
59863 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
59864 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
59865 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
59866 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
59867 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
59868 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
59869 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
59870 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
59871 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
59872 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
59873 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
59874 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
59875 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
59876 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
59877 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
59878 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
59879 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
59880 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
59881 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
59882 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
59883 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
59884 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
59885 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
59886 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
59887 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
59888 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
59889 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
59890 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
59891 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
59892 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
59893 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
59894 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
59895 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
59896 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
59897 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
59898 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
59899 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
59900 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
59901 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
59902 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
59903 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
59904 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
59905 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
59906 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
59907 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
59908 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
59909 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
59910 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
59911 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
59912 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
59913 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
59914 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
59915 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
59916 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
59917 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
59918 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
59919 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
59920 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
59921 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
59922 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
59923 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
59924 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
59925 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
59926 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
59927 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
59928 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
59929 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
59930 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
59931 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
59932 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
59933 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
59934 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
59935 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
59936 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
59937 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
59938 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
59939 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
59940 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
59941 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
59942 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
59943 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
59944 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
59945 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
59946 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
59947 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
59948 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
59949 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
59950 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
59951 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
59952 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
59953 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
59954 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
59955 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
59956 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
59957 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
59958 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
59959 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
59960 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
59961 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
59962 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
59963 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
59964 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
59965 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
59966 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
59967 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
59968 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
59969 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
59970 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
59971 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
59972 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
59973 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
59974 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
59975 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
59976 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
59977 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
59978 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
59979 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
59980 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
59981 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
59982 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
59983 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
59984 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
59985 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
59986 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
59987 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
59988 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
59989 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
59990 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
59991 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
59992 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
59993 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
59994 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
59995 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
59996 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
59997 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
59998 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
59999 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60000 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60001 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60002 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60003 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60004 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60005 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60006 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60007 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60008 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60009 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60010 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60011 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60012 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60013 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60014 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60015 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60016 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60017 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60018 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60019 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60020 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60021 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60022 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60023 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60024 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60025 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60026 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60027 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60028 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60029 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60030 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60031 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60032 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60033 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60034 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60035 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60036 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60037 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60038 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60039 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60040 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60041 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60042 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60043 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60044 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60045 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60046 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60047 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60048 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60049 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60050 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60051 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60052 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60053 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60054 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60055 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60056 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60057 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60058 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60059 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60060 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60061 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60062 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60063 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60064 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60065 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60066 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60067 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60068 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60069 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60070 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60071 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60072 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60073 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60074 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60075 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60076 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60077 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60078 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60079 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60080 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60081 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60082 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60083 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60084 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60085 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60086 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60087 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60088 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60089 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60090 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60091 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60092 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60093 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60094 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60095 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60096 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60097 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60098 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60099 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60100 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60101 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60102 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60103 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60104 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60105 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60106 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60107 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60108 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60109 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60110 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60111 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60112 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60113 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60114 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60115 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60116 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60117 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60118 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60119 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60120 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60121 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60122 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60123 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60124 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60125 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60126 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60127 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60128 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60129 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60130 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60131 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60132 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60133 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60134 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60135 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60136 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60137 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60138 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60139 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60140 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60141 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60142 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60143 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60144 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60145 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60146 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60147 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60148 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60149 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60150 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60151 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60152 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60153 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60154 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60155 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60156 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60157 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60158 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60159 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60160 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60161 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60162 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60163 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60164 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60165 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60166 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60167 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60168 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60169 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60170 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60171 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60172 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60173 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60174 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60175 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60176 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60177 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60178 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60179 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60180 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60181 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60182 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60183 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60184
60185 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60186
60187
60188 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60189
60190 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60191 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60192 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60193 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60194 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60195 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60196 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60197 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60198 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60199 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60200 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60201 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60202 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60203 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60204 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60205 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60206 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60207 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60208 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60209 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60210 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60211 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60212 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60213 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60214 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60215 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60216 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60217 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60218 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60219 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60220 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60221 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60222 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60223 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60224 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60225 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60226 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60227 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60228 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60229 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60230 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60231 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60232 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60233 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60234 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60235 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60236 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60237 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60238 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60239 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60240 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60241 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60242 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60243 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60244 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60245 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60246 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60247 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60248 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60249 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60250 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60251 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60252 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60253 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60254 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60255 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60256 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60257 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60258 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60259 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60260 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60261 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60262 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60263 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60264 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60265 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60266 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60267 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60268 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60269 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60270 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60271 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60272 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60273 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60274 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60275 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60276 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60277 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60278 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60279 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60280 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60281 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60282 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60283 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60284 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60285 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60286 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60287 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60288 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60289 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60290 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60291 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60292 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60293 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60294 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60295 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60296 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60297 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60298 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60299 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60300 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60301 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60302 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60303 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60304 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60305 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60306 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60307 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60308 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60309 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60310 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60311 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60312 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60313 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60314 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60315 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60316 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60317 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60318 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60319 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60320 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60321 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60322 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60323 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60324 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60325 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60326 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60327 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60328 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60329 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60330 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60331 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60332 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60333 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60334 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60335 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60336 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60337 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60338 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60339 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60340 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60341 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60342 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60343 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60344 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60345 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60346 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60347 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60348 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60349 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60350 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60351 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60352 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60353 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60354 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60355 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60356 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60357 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60358 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60359 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60360 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60361 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60362 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60363 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60364 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60365 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60366 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60367 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60368 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60369 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60370 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60371 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60372 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60373 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60374 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60375 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60376 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60377 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60378 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60379 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60380 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60381 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60382 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60383 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60384 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60385 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60386 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60387 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60388 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60389 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60390 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60391 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60392 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60393 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60394 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60395 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60396 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60397 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60398 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60399 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60400 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60401 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60402 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60403 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60404
60405 // Initialize threading, some globals and such
60406 __wxPyPreStart(d);
60407
60408
60409 // Although these are defined in __version__ they need to be here too so
60410 // that an assert can be done to ensure that the wxPython and the wxWindows
60411 // versions match.
60412 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60413 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60414 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60415
60416 }
60417
wxWidgets (Impactor)