]> 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
fixed Clear() for GTK+ 2.4+
[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 /* for raw pointers */
989 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
990 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
991 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
992 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
993 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
994 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
995 #define swig_owntype int
996
997 /* for raw packed data */
998 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
999 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1000
1001 /* for class or struct pointers */
1002 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1003 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1004
1005 /* for C or C++ function pointers */
1006 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1007 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1008
1009 /* for C++ member pointers, ie, member methods */
1010 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1011 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1012
1013
1014 /* Runtime API */
1015
1016 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1017 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1018 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1019
1020 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1021 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1022 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1023 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1024 #define SWIG_fail goto fail
1025
1026
1027 /* Runtime API implementation */
1028
1029 /* Error manipulation */
1030
1031 SWIGINTERN void
1032 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1033 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1034 PyErr_SetObject(errtype, obj);
1035 Py_DECREF(obj);
1036 SWIG_PYTHON_THREAD_END_BLOCK;
1037 }
1038
1039 SWIGINTERN void
1040 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1041 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1042 PyErr_SetString(errtype, (char *) msg);
1043 SWIG_PYTHON_THREAD_END_BLOCK;
1044 }
1045
1046 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1047
1048 /* Set a constant value */
1049
1050 SWIGINTERN void
1051 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1052 PyDict_SetItemString(d, (char*) name, obj);
1053 Py_DECREF(obj);
1054 }
1055
1056 /* Append a value to the result obj */
1057
1058 SWIGINTERN PyObject*
1059 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1060 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1061 if (!result) {
1062 result = obj;
1063 } else if (result == Py_None) {
1064 Py_DECREF(result);
1065 result = obj;
1066 } else {
1067 if (!PyList_Check(result)) {
1068 PyObject *o2 = result;
1069 result = PyList_New(1);
1070 PyList_SetItem(result, 0, o2);
1071 }
1072 PyList_Append(result,obj);
1073 Py_DECREF(obj);
1074 }
1075 return result;
1076 #else
1077 PyObject* o2;
1078 PyObject* o3;
1079 if (!result) {
1080 result = obj;
1081 } else if (result == Py_None) {
1082 Py_DECREF(result);
1083 result = obj;
1084 } else {
1085 if (!PyTuple_Check(result)) {
1086 o2 = result;
1087 result = PyTuple_New(1);
1088 PyTuple_SET_ITEM(result, 0, o2);
1089 }
1090 o3 = PyTuple_New(1);
1091 PyTuple_SET_ITEM(o3, 0, obj);
1092 o2 = result;
1093 result = PySequence_Concat(o2, o3);
1094 Py_DECREF(o2);
1095 Py_DECREF(o3);
1096 }
1097 return result;
1098 #endif
1099 }
1100
1101 /* Unpack the argument tuple */
1102
1103 SWIGINTERN int
1104 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1105 {
1106 if (!args) {
1107 if (!min && !max) {
1108 return 1;
1109 } else {
1110 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1111 name, (min == max ? "" : "at least "), min);
1112 return 0;
1113 }
1114 }
1115 if (!PyTuple_Check(args)) {
1116 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1117 return 0;
1118 } else {
1119 register int l = PyTuple_GET_SIZE(args);
1120 if (l < min) {
1121 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122 name, (min == max ? "" : "at least "), min, l);
1123 return 0;
1124 } else if (l > max) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at most "), max, l);
1127 return 0;
1128 } else {
1129 register int i;
1130 for (i = 0; i < l; ++i) {
1131 objs[i] = PyTuple_GET_ITEM(args, i);
1132 }
1133 for (; l < max; ++l) {
1134 objs[l] = 0;
1135 }
1136 return i + 1;
1137 }
1138 }
1139 }
1140
1141 /* A functor is a function object with one single object argument */
1142 #if PY_VERSION_HEX >= 0x02020000
1143 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1144 #else
1145 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1146 #endif
1147
1148 /*
1149 Helper for static pointer initialization for both C and C++ code, for example
1150 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1151 */
1152 #ifdef __cplusplus
1153 #define SWIG_STATIC_POINTER(var) var
1154 #else
1155 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1156 #endif
1157
1158 /* -----------------------------------------------------------------------------
1159 * Pointer declarations
1160 * ----------------------------------------------------------------------------- */
1161
1162 /* Flags for new pointer objects */
1163 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1164 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1165
1166 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1167
1168 #ifdef __cplusplus
1169 extern "C" {
1170 #if 0
1171 } /* cc-mode */
1172 #endif
1173 #endif
1174
1175 /* How to access Py_None */
1176 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1177 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1178 # ifndef SWIG_PYTHON_BUILD_NONE
1179 # define SWIG_PYTHON_BUILD_NONE
1180 # endif
1181 # endif
1182 #endif
1183
1184 #ifdef SWIG_PYTHON_BUILD_NONE
1185 # ifdef Py_None
1186 # undef Py_None
1187 # define Py_None SWIG_Py_None()
1188 # endif
1189 SWIGRUNTIMEINLINE PyObject *
1190 _SWIG_Py_None(void)
1191 {
1192 PyObject *none = Py_BuildValue("");
1193 Py_DECREF(none);
1194 return none;
1195 }
1196 SWIGRUNTIME PyObject *
1197 SWIG_Py_None(void)
1198 {
1199 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1200 return none;
1201 }
1202 #endif
1203
1204 /* The python void return value */
1205
1206 SWIGRUNTIMEINLINE PyObject *
1207 SWIG_Py_Void(void)
1208 {
1209 PyObject *none = Py_None;
1210 Py_INCREF(none);
1211 return none;
1212 }
1213
1214 /* PySwigClientData */
1215
1216 typedef struct {
1217 PyObject *klass;
1218 PyObject *newraw;
1219 PyObject *newargs;
1220 PyObject *destroy;
1221 int delargs;
1222 int implicitconv;
1223 } PySwigClientData;
1224
1225 SWIGRUNTIMEINLINE int
1226 SWIG_Python_CheckImplicit(swig_type_info *ty)
1227 {
1228 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1229 return data ? data->implicitconv : 0;
1230 }
1231
1232 SWIGRUNTIMEINLINE PyObject *
1233 SWIG_Python_ExceptionType(swig_type_info *desc) {
1234 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1235 PyObject *klass = data ? data->klass : 0;
1236 return (klass ? klass : PyExc_RuntimeError);
1237 }
1238
1239
1240 SWIGRUNTIME PySwigClientData *
1241 PySwigClientData_New(PyObject* obj)
1242 {
1243 if (!obj) {
1244 return 0;
1245 } else {
1246 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1247 /* the klass element */
1248 data->klass = obj;
1249 Py_INCREF(data->klass);
1250 /* the newraw method and newargs arguments used to create a new raw instance */
1251 if (PyClass_Check(obj)) {
1252 data->newraw = 0;
1253 data->newargs = obj;
1254 Py_INCREF(obj);
1255 } else {
1256 #if (PY_VERSION_HEX < 0x02020000)
1257 data->newraw = 0;
1258 #else
1259 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1260 #endif
1261 if (data->newraw) {
1262 Py_INCREF(data->newraw);
1263 data->newargs = PyTuple_New(1);
1264 PyTuple_SetItem(data->newargs, 0, obj);
1265 } else {
1266 data->newargs = obj;
1267 }
1268 Py_INCREF(data->newargs);
1269 }
1270 /* the destroy method, aka as the C++ delete method */
1271 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1272 if (PyErr_Occurred()) {
1273 PyErr_Clear();
1274 data->destroy = 0;
1275 }
1276 if (data->destroy) {
1277 int flags;
1278 Py_INCREF(data->destroy);
1279 flags = PyCFunction_GET_FLAGS(data->destroy);
1280 #ifdef METH_O
1281 data->delargs = !(flags & (METH_O));
1282 #else
1283 data->delargs = 0;
1284 #endif
1285 } else {
1286 data->delargs = 0;
1287 }
1288 data->implicitconv = 0;
1289 return data;
1290 }
1291 }
1292
1293 SWIGRUNTIME void
1294 PySwigClientData_Del(PySwigClientData* data)
1295 {
1296 Py_XDECREF(data->newraw);
1297 Py_XDECREF(data->newargs);
1298 Py_XDECREF(data->destroy);
1299 }
1300
1301 /* =============== PySwigObject =====================*/
1302
1303 typedef struct {
1304 PyObject_HEAD
1305 void *ptr;
1306 swig_type_info *ty;
1307 int own;
1308 PyObject *next;
1309 } PySwigObject;
1310
1311 SWIGRUNTIME PyObject *
1312 PySwigObject_long(PySwigObject *v)
1313 {
1314 return PyLong_FromVoidPtr(v->ptr);
1315 }
1316
1317 SWIGRUNTIME PyObject *
1318 PySwigObject_format(const char* fmt, PySwigObject *v)
1319 {
1320 PyObject *res = NULL;
1321 PyObject *args = PyTuple_New(1);
1322 if (args) {
1323 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1324 PyObject *ofmt = PyString_FromString(fmt);
1325 if (ofmt) {
1326 res = PyString_Format(ofmt,args);
1327 Py_DECREF(ofmt);
1328 }
1329 Py_DECREF(args);
1330 }
1331 }
1332 return res;
1333 }
1334
1335 SWIGRUNTIME PyObject *
1336 PySwigObject_oct(PySwigObject *v)
1337 {
1338 return PySwigObject_format("%o",v);
1339 }
1340
1341 SWIGRUNTIME PyObject *
1342 PySwigObject_hex(PySwigObject *v)
1343 {
1344 return PySwigObject_format("%x",v);
1345 }
1346
1347 SWIGRUNTIME PyObject *
1348 #ifdef METH_NOARGS
1349 PySwigObject_repr(PySwigObject *v)
1350 #else
1351 PySwigObject_repr(PySwigObject *v, PyObject *args)
1352 #endif
1353 {
1354 const char *name = SWIG_TypePrettyName(v->ty);
1355 PyObject *hex = PySwigObject_hex(v);
1356 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1357 Py_DECREF(hex);
1358 if (v->next) {
1359 #ifdef METH_NOARGS
1360 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1361 #else
1362 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1363 #endif
1364 PyString_ConcatAndDel(&repr,nrep);
1365 }
1366 return repr;
1367 }
1368
1369 SWIGRUNTIME int
1370 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1371 {
1372 #ifdef METH_NOARGS
1373 PyObject *repr = PySwigObject_repr(v);
1374 #else
1375 PyObject *repr = PySwigObject_repr(v, NULL);
1376 #endif
1377 if (repr) {
1378 fputs(PyString_AsString(repr), fp);
1379 Py_DECREF(repr);
1380 return 0;
1381 } else {
1382 return 1;
1383 }
1384 }
1385
1386 SWIGRUNTIME PyObject *
1387 PySwigObject_str(PySwigObject *v)
1388 {
1389 char result[SWIG_BUFFER_SIZE];
1390 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1391 PyString_FromString(result) : 0;
1392 }
1393
1394 SWIGRUNTIME int
1395 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1396 {
1397 void *i = v->ptr;
1398 void *j = w->ptr;
1399 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1400 }
1401
1402 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1403
1404 SWIGRUNTIME PyTypeObject*
1405 PySwigObject_type(void) {
1406 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1407 return type;
1408 }
1409
1410 SWIGRUNTIMEINLINE int
1411 PySwigObject_Check(PyObject *op) {
1412 return ((op)->ob_type == PySwigObject_type())
1413 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1414 }
1415
1416 SWIGRUNTIME PyObject *
1417 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1418
1419 SWIGRUNTIME void
1420 PySwigObject_dealloc(PyObject *v)
1421 {
1422 PySwigObject *sobj = (PySwigObject *) v;
1423 PyObject *next = sobj->next;
1424 if (sobj->own) {
1425 swig_type_info *ty = sobj->ty;
1426 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1427 PyObject *destroy = data ? data->destroy : 0;
1428 if (destroy) {
1429 /* destroy is always a VARARGS method */
1430 PyObject *res;
1431 if (data->delargs) {
1432 /* we need to create a temporal object to carry the destroy operation */
1433 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1434 res = SWIG_Python_CallFunctor(destroy, tmp);
1435 Py_DECREF(tmp);
1436 } else {
1437 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1438 PyObject *mself = PyCFunction_GET_SELF(destroy);
1439 res = ((*meth)(mself, v));
1440 }
1441 Py_XDECREF(res);
1442 } else {
1443 const char *name = SWIG_TypePrettyName(ty);
1444 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1445 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1446 #endif
1447 }
1448 }
1449 Py_XDECREF(next);
1450 PyObject_DEL(v);
1451 }
1452
1453 SWIGRUNTIME PyObject*
1454 PySwigObject_append(PyObject* v, PyObject* next)
1455 {
1456 PySwigObject *sobj = (PySwigObject *) v;
1457 #ifndef METH_O
1458 PyObject *tmp = 0;
1459 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1460 next = tmp;
1461 #endif
1462 if (!PySwigObject_Check(next)) {
1463 return NULL;
1464 }
1465 sobj->next = next;
1466 Py_INCREF(next);
1467 return SWIG_Py_Void();
1468 }
1469
1470 SWIGRUNTIME PyObject*
1471 #ifdef METH_NOARGS
1472 PySwigObject_next(PyObject* v)
1473 #else
1474 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1475 #endif
1476 {
1477 PySwigObject *sobj = (PySwigObject *) v;
1478 if (sobj->next) {
1479 Py_INCREF(sobj->next);
1480 return sobj->next;
1481 } else {
1482 return SWIG_Py_Void();
1483 }
1484 }
1485
1486 SWIGINTERN PyObject*
1487 #ifdef METH_NOARGS
1488 PySwigObject_disown(PyObject *v)
1489 #else
1490 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1491 #endif
1492 {
1493 PySwigObject *sobj = (PySwigObject *)v;
1494 sobj->own = 0;
1495 return SWIG_Py_Void();
1496 }
1497
1498 SWIGINTERN PyObject*
1499 #ifdef METH_NOARGS
1500 PySwigObject_acquire(PyObject *v)
1501 #else
1502 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1503 #endif
1504 {
1505 PySwigObject *sobj = (PySwigObject *)v;
1506 sobj->own = SWIG_POINTER_OWN;
1507 return SWIG_Py_Void();
1508 }
1509
1510 SWIGINTERN PyObject*
1511 PySwigObject_own(PyObject *v, PyObject *args)
1512 {
1513 PyObject *val = 0;
1514 #if (PY_VERSION_HEX < 0x02020000)
1515 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1516 #else
1517 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1518 #endif
1519 {
1520 return NULL;
1521 }
1522 else
1523 {
1524 PySwigObject *sobj = (PySwigObject *)v;
1525 PyObject *obj = PyBool_FromLong(sobj->own);
1526 if (val) {
1527 #ifdef METH_NOARGS
1528 if (PyObject_IsTrue(val)) {
1529 PySwigObject_acquire(v);
1530 } else {
1531 PySwigObject_disown(v);
1532 }
1533 #else
1534 if (PyObject_IsTrue(val)) {
1535 PySwigObject_acquire(v,args);
1536 } else {
1537 PySwigObject_disown(v,args);
1538 }
1539 #endif
1540 }
1541 return obj;
1542 }
1543 }
1544
1545 #ifdef METH_O
1546 static PyMethodDef
1547 swigobject_methods[] = {
1548 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1549 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1550 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1551 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1552 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1553 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1554 {0, 0, 0, 0}
1555 };
1556 #else
1557 static PyMethodDef
1558 swigobject_methods[] = {
1559 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1560 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1561 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1562 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1563 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1564 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1565 {0, 0, 0, 0}
1566 };
1567 #endif
1568
1569 #if PY_VERSION_HEX < 0x02020000
1570 SWIGINTERN PyObject *
1571 PySwigObject_getattr(PySwigObject *sobj,char *name)
1572 {
1573 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1574 }
1575 #endif
1576
1577 SWIGRUNTIME PyTypeObject*
1578 _PySwigObject_type(void) {
1579 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1580
1581 static PyNumberMethods PySwigObject_as_number = {
1582 (binaryfunc)0, /*nb_add*/
1583 (binaryfunc)0, /*nb_subtract*/
1584 (binaryfunc)0, /*nb_multiply*/
1585 (binaryfunc)0, /*nb_divide*/
1586 (binaryfunc)0, /*nb_remainder*/
1587 (binaryfunc)0, /*nb_divmod*/
1588 (ternaryfunc)0,/*nb_power*/
1589 (unaryfunc)0, /*nb_negative*/
1590 (unaryfunc)0, /*nb_positive*/
1591 (unaryfunc)0, /*nb_absolute*/
1592 (inquiry)0, /*nb_nonzero*/
1593 0, /*nb_invert*/
1594 0, /*nb_lshift*/
1595 0, /*nb_rshift*/
1596 0, /*nb_and*/
1597 0, /*nb_xor*/
1598 0, /*nb_or*/
1599 (coercion)0, /*nb_coerce*/
1600 (unaryfunc)PySwigObject_long, /*nb_int*/
1601 (unaryfunc)PySwigObject_long, /*nb_long*/
1602 (unaryfunc)0, /*nb_float*/
1603 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1604 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1605 #if PY_VERSION_HEX >= 0x02020000
1606 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1607 #elif PY_VERSION_HEX >= 0x02000000
1608 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1609 #endif
1610 };
1611
1612 static PyTypeObject pyswigobject_type;
1613 static int type_init = 0;
1614 if (!type_init) {
1615 const PyTypeObject tmp
1616 = {
1617 PyObject_HEAD_INIT(NULL)
1618 0, /* ob_size */
1619 (char *)"PySwigObject", /* tp_name */
1620 sizeof(PySwigObject), /* tp_basicsize */
1621 0, /* tp_itemsize */
1622 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1623 (printfunc)PySwigObject_print, /* tp_print */
1624 #if PY_VERSION_HEX < 0x02020000
1625 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1626 #else
1627 (getattrfunc)0, /* tp_getattr */
1628 #endif
1629 (setattrfunc)0, /* tp_setattr */
1630 (cmpfunc)PySwigObject_compare, /* tp_compare */
1631 (reprfunc)PySwigObject_repr, /* tp_repr */
1632 &PySwigObject_as_number, /* tp_as_number */
1633 0, /* tp_as_sequence */
1634 0, /* tp_as_mapping */
1635 (hashfunc)0, /* tp_hash */
1636 (ternaryfunc)0, /* tp_call */
1637 (reprfunc)PySwigObject_str, /* tp_str */
1638 PyObject_GenericGetAttr, /* tp_getattro */
1639 0, /* tp_setattro */
1640 0, /* tp_as_buffer */
1641 Py_TPFLAGS_DEFAULT, /* tp_flags */
1642 swigobject_doc, /* tp_doc */
1643 0, /* tp_traverse */
1644 0, /* tp_clear */
1645 0, /* tp_richcompare */
1646 0, /* tp_weaklistoffset */
1647 #if PY_VERSION_HEX >= 0x02020000
1648 0, /* tp_iter */
1649 0, /* tp_iternext */
1650 swigobject_methods, /* tp_methods */
1651 0, /* tp_members */
1652 0, /* tp_getset */
1653 0, /* tp_base */
1654 0, /* tp_dict */
1655 0, /* tp_descr_get */
1656 0, /* tp_descr_set */
1657 0, /* tp_dictoffset */
1658 0, /* tp_init */
1659 0, /* tp_alloc */
1660 0, /* tp_new */
1661 0, /* tp_free */
1662 0, /* tp_is_gc */
1663 0, /* tp_bases */
1664 0, /* tp_mro */
1665 0, /* tp_cache */
1666 0, /* tp_subclasses */
1667 0, /* tp_weaklist */
1668 #endif
1669 #if PY_VERSION_HEX >= 0x02030000
1670 0, /* tp_del */
1671 #endif
1672 #ifdef COUNT_ALLOCS
1673 0,0,0,0 /* tp_alloc -> tp_next */
1674 #endif
1675 };
1676 pyswigobject_type = tmp;
1677 pyswigobject_type.ob_type = &PyType_Type;
1678 type_init = 1;
1679 }
1680 return &pyswigobject_type;
1681 }
1682
1683 SWIGRUNTIME PyObject *
1684 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1685 {
1686 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1687 if (sobj) {
1688 sobj->ptr = ptr;
1689 sobj->ty = ty;
1690 sobj->own = own;
1691 sobj->next = 0;
1692 }
1693 return (PyObject *)sobj;
1694 }
1695
1696 /* -----------------------------------------------------------------------------
1697 * Implements a simple Swig Packed type, and use it instead of string
1698 * ----------------------------------------------------------------------------- */
1699
1700 typedef struct {
1701 PyObject_HEAD
1702 void *pack;
1703 swig_type_info *ty;
1704 size_t size;
1705 } PySwigPacked;
1706
1707 SWIGRUNTIME int
1708 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1709 {
1710 char result[SWIG_BUFFER_SIZE];
1711 fputs("<Swig Packed ", fp);
1712 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1713 fputs("at ", fp);
1714 fputs(result, fp);
1715 }
1716 fputs(v->ty->name,fp);
1717 fputs(">", fp);
1718 return 0;
1719 }
1720
1721 SWIGRUNTIME PyObject *
1722 PySwigPacked_repr(PySwigPacked *v)
1723 {
1724 char result[SWIG_BUFFER_SIZE];
1725 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1726 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1727 } else {
1728 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1729 }
1730 }
1731
1732 SWIGRUNTIME PyObject *
1733 PySwigPacked_str(PySwigPacked *v)
1734 {
1735 char result[SWIG_BUFFER_SIZE];
1736 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1737 return PyString_FromFormat("%s%s", result, v->ty->name);
1738 } else {
1739 return PyString_FromString(v->ty->name);
1740 }
1741 }
1742
1743 SWIGRUNTIME int
1744 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1745 {
1746 size_t i = v->size;
1747 size_t j = w->size;
1748 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1749 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1750 }
1751
1752 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1753
1754 SWIGRUNTIME PyTypeObject*
1755 PySwigPacked_type(void) {
1756 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1757 return type;
1758 }
1759
1760 SWIGRUNTIMEINLINE int
1761 PySwigPacked_Check(PyObject *op) {
1762 return ((op)->ob_type == _PySwigPacked_type())
1763 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1764 }
1765
1766 SWIGRUNTIME void
1767 PySwigPacked_dealloc(PyObject *v)
1768 {
1769 if (PySwigPacked_Check(v)) {
1770 PySwigPacked *sobj = (PySwigPacked *) v;
1771 free(sobj->pack);
1772 }
1773 PyObject_DEL(v);
1774 }
1775
1776 SWIGRUNTIME PyTypeObject*
1777 _PySwigPacked_type(void) {
1778 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1779 static PyTypeObject pyswigpacked_type;
1780 static int type_init = 0;
1781 if (!type_init) {
1782 const PyTypeObject tmp
1783 = {
1784 PyObject_HEAD_INIT(NULL)
1785 0, /* ob_size */
1786 (char *)"PySwigPacked", /* tp_name */
1787 sizeof(PySwigPacked), /* tp_basicsize */
1788 0, /* tp_itemsize */
1789 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1790 (printfunc)PySwigPacked_print, /* tp_print */
1791 (getattrfunc)0, /* tp_getattr */
1792 (setattrfunc)0, /* tp_setattr */
1793 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1794 (reprfunc)PySwigPacked_repr, /* tp_repr */
1795 0, /* tp_as_number */
1796 0, /* tp_as_sequence */
1797 0, /* tp_as_mapping */
1798 (hashfunc)0, /* tp_hash */
1799 (ternaryfunc)0, /* tp_call */
1800 (reprfunc)PySwigPacked_str, /* tp_str */
1801 PyObject_GenericGetAttr, /* tp_getattro */
1802 0, /* tp_setattro */
1803 0, /* tp_as_buffer */
1804 Py_TPFLAGS_DEFAULT, /* tp_flags */
1805 swigpacked_doc, /* tp_doc */
1806 0, /* tp_traverse */
1807 0, /* tp_clear */
1808 0, /* tp_richcompare */
1809 0, /* tp_weaklistoffset */
1810 #if PY_VERSION_HEX >= 0x02020000
1811 0, /* tp_iter */
1812 0, /* tp_iternext */
1813 0, /* tp_methods */
1814 0, /* tp_members */
1815 0, /* tp_getset */
1816 0, /* tp_base */
1817 0, /* tp_dict */
1818 0, /* tp_descr_get */
1819 0, /* tp_descr_set */
1820 0, /* tp_dictoffset */
1821 0, /* tp_init */
1822 0, /* tp_alloc */
1823 0, /* tp_new */
1824 0, /* tp_free */
1825 0, /* tp_is_gc */
1826 0, /* tp_bases */
1827 0, /* tp_mro */
1828 0, /* tp_cache */
1829 0, /* tp_subclasses */
1830 0, /* tp_weaklist */
1831 #endif
1832 #if PY_VERSION_HEX >= 0x02030000
1833 0, /* tp_del */
1834 #endif
1835 #ifdef COUNT_ALLOCS
1836 0,0,0,0 /* tp_alloc -> tp_next */
1837 #endif
1838 };
1839 pyswigpacked_type = tmp;
1840 pyswigpacked_type.ob_type = &PyType_Type;
1841 type_init = 1;
1842 }
1843 return &pyswigpacked_type;
1844 }
1845
1846 SWIGRUNTIME PyObject *
1847 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1848 {
1849 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1850 if (sobj) {
1851 void *pack = malloc(size);
1852 if (pack) {
1853 memcpy(pack, ptr, size);
1854 sobj->pack = pack;
1855 sobj->ty = ty;
1856 sobj->size = size;
1857 } else {
1858 PyObject_DEL((PyObject *) sobj);
1859 sobj = 0;
1860 }
1861 }
1862 return (PyObject *) sobj;
1863 }
1864
1865 SWIGRUNTIME swig_type_info *
1866 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1867 {
1868 if (PySwigPacked_Check(obj)) {
1869 PySwigPacked *sobj = (PySwigPacked *)obj;
1870 if (sobj->size != size) return 0;
1871 memcpy(ptr, sobj->pack, size);
1872 return sobj->ty;
1873 } else {
1874 return 0;
1875 }
1876 }
1877
1878 /* -----------------------------------------------------------------------------
1879 * pointers/data manipulation
1880 * ----------------------------------------------------------------------------- */
1881
1882 SWIGRUNTIMEINLINE PyObject *
1883 _SWIG_This(void)
1884 {
1885 return PyString_FromString("this");
1886 }
1887
1888 SWIGRUNTIME PyObject *
1889 SWIG_This(void)
1890 {
1891 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1892 return swig_this;
1893 }
1894
1895 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1896
1897 SWIGRUNTIME PySwigObject *
1898 SWIG_Python_GetSwigThis(PyObject *pyobj)
1899 {
1900 if (PySwigObject_Check(pyobj)) {
1901 return (PySwigObject *) pyobj;
1902 } else {
1903 PyObject *obj = 0;
1904 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1905 if (PyInstance_Check(pyobj)) {
1906 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1907 } else {
1908 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1909 if (dictptr != NULL) {
1910 PyObject *dict = *dictptr;
1911 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1912 } else {
1913 #ifdef PyWeakref_CheckProxy
1914 if (PyWeakref_CheckProxy(pyobj)) {
1915 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1916 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1917 }
1918 #endif
1919 obj = PyObject_GetAttr(pyobj,SWIG_This());
1920 if (obj) {
1921 Py_DECREF(obj);
1922 } else {
1923 if (PyErr_Occurred()) PyErr_Clear();
1924 return 0;
1925 }
1926 }
1927 }
1928 #else
1929 obj = PyObject_GetAttr(pyobj,SWIG_This());
1930 if (obj) {
1931 Py_DECREF(obj);
1932 } else {
1933 if (PyErr_Occurred()) PyErr_Clear();
1934 return 0;
1935 }
1936 #endif
1937 if (obj && !PySwigObject_Check(obj)) {
1938 /* a PyObject is called 'this', try to get the 'real this'
1939 PySwigObject from it */
1940 return SWIG_Python_GetSwigThis(obj);
1941 }
1942 return (PySwigObject *)obj;
1943 }
1944 }
1945
1946 /* Acquire a pointer value */
1947
1948 SWIGRUNTIME int
1949 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1950 if (own) {
1951 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1952 if (sobj) {
1953 int oldown = sobj->own;
1954 sobj->own = own;
1955 return oldown;
1956 }
1957 }
1958 return 0;
1959 }
1960
1961 /* Convert a pointer value */
1962
1963 SWIGRUNTIME int
1964 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1965 if (!obj) return SWIG_ERROR;
1966 if (obj == Py_None) {
1967 if (ptr) *ptr = 0;
1968 return SWIG_OK;
1969 } else {
1970 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1971 while (sobj) {
1972 void *vptr = sobj->ptr;
1973 if (ty) {
1974 swig_type_info *to = sobj->ty;
1975 if (to == ty) {
1976 /* no type cast needed */
1977 if (ptr) *ptr = vptr;
1978 break;
1979 } else {
1980 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1981 if (!tc) {
1982 sobj = (PySwigObject *)sobj->next;
1983 } else {
1984 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1985 break;
1986 }
1987 }
1988 } else {
1989 if (ptr) *ptr = vptr;
1990 break;
1991 }
1992 }
1993 if (sobj) {
1994 if (own) *own = sobj->own;
1995 if (flags & SWIG_POINTER_DISOWN) {
1996 sobj->own = 0;
1997 }
1998 return SWIG_OK;
1999 } else {
2000 int res = SWIG_ERROR;
2001 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2002 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2003 if (data && !data->implicitconv) {
2004 PyObject *klass = data->klass;
2005 if (klass) {
2006 PyObject *impconv;
2007 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2008 impconv = SWIG_Python_CallFunctor(klass, obj);
2009 data->implicitconv = 0;
2010 if (PyErr_Occurred()) {
2011 PyErr_Clear();
2012 impconv = 0;
2013 }
2014 if (impconv) {
2015 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2016 if (iobj) {
2017 void *vptr;
2018 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2019 if (SWIG_IsOK(res)) {
2020 if (ptr) {
2021 *ptr = vptr;
2022 /* transfer the ownership to 'ptr' */
2023 iobj->own = 0;
2024 res = SWIG_AddCast(res);
2025 res = SWIG_AddNewMask(res);
2026 } else {
2027 res = SWIG_AddCast(res);
2028 }
2029 }
2030 }
2031 Py_DECREF(impconv);
2032 }
2033 }
2034 }
2035 }
2036 return res;
2037 }
2038 }
2039 }
2040
2041 /* Convert a function ptr value */
2042
2043 SWIGRUNTIME int
2044 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2045 if (!PyCFunction_Check(obj)) {
2046 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2047 } else {
2048 void *vptr = 0;
2049
2050 /* here we get the method pointer for callbacks */
2051 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2052 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2053 if (desc) {
2054 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2055 if (!desc) return SWIG_ERROR;
2056 }
2057 if (ty) {
2058 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2059 if (!tc) return SWIG_ERROR;
2060 *ptr = SWIG_TypeCast(tc,vptr);
2061 } else {
2062 *ptr = vptr;
2063 }
2064 return SWIG_OK;
2065 }
2066 }
2067
2068 /* Convert a packed value value */
2069
2070 SWIGRUNTIME int
2071 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2072 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2073 if (!to) return SWIG_ERROR;
2074 if (ty) {
2075 if (to != ty) {
2076 /* check type cast? */
2077 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2078 if (!tc) return SWIG_ERROR;
2079 }
2080 }
2081 return SWIG_OK;
2082 }
2083
2084 /* -----------------------------------------------------------------------------
2085 * Create a new pointer object
2086 * ----------------------------------------------------------------------------- */
2087
2088 /*
2089 Create a new instance object, whitout calling __init__, and set the
2090 'this' attribute.
2091 */
2092
2093 SWIGRUNTIME PyObject*
2094 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2095 {
2096 #if (PY_VERSION_HEX >= 0x02020000)
2097 PyObject *inst = 0;
2098 PyObject *newraw = data->newraw;
2099 if (newraw) {
2100 inst = PyObject_Call(newraw, data->newargs, NULL);
2101 if (inst) {
2102 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2103 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2104 if (dictptr != NULL) {
2105 PyObject *dict = *dictptr;
2106 if (dict == NULL) {
2107 dict = PyDict_New();
2108 *dictptr = dict;
2109 PyDict_SetItem(dict, SWIG_This(), swig_this);
2110 }
2111 }
2112 #else
2113 PyObject *key = SWIG_This();
2114 PyObject_SetAttr(inst, key, swig_this);
2115 #endif
2116 }
2117 } else {
2118 PyObject *dict = PyDict_New();
2119 PyDict_SetItem(dict, SWIG_This(), swig_this);
2120 inst = PyInstance_NewRaw(data->newargs, dict);
2121 Py_DECREF(dict);
2122 }
2123 return inst;
2124 #else
2125 #if (PY_VERSION_HEX >= 0x02010000)
2126 PyObject *inst;
2127 PyObject *dict = PyDict_New();
2128 PyDict_SetItem(dict, SWIG_This(), swig_this);
2129 inst = PyInstance_NewRaw(data->newargs, dict);
2130 Py_DECREF(dict);
2131 return (PyObject *) inst;
2132 #else
2133 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2134 if (inst == NULL) {
2135 return NULL;
2136 }
2137 inst->in_class = (PyClassObject *)data->newargs;
2138 Py_INCREF(inst->in_class);
2139 inst->in_dict = PyDict_New();
2140 if (inst->in_dict == NULL) {
2141 Py_DECREF(inst);
2142 return NULL;
2143 }
2144 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2145 inst->in_weakreflist = NULL;
2146 #endif
2147 #ifdef Py_TPFLAGS_GC
2148 PyObject_GC_Init(inst);
2149 #endif
2150 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2151 return (PyObject *) inst;
2152 #endif
2153 #endif
2154 }
2155
2156 SWIGRUNTIME void
2157 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2158 {
2159 PyObject *dict;
2160 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2161 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2162 if (dictptr != NULL) {
2163 dict = *dictptr;
2164 if (dict == NULL) {
2165 dict = PyDict_New();
2166 *dictptr = dict;
2167 }
2168 PyDict_SetItem(dict, SWIG_This(), swig_this);
2169 return;
2170 }
2171 #endif
2172 dict = PyObject_GetAttrString(inst, "__dict__");
2173 PyDict_SetItem(dict, SWIG_This(), swig_this);
2174 Py_DECREF(dict);
2175 }
2176
2177
2178 SWIGINTERN PyObject *
2179 SWIG_Python_InitShadowInstance(PyObject *args) {
2180 PyObject *obj[2];
2181 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2182 return NULL;
2183 } else {
2184 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2185 if (sthis) {
2186 PySwigObject_append((PyObject*) sthis, obj[1]);
2187 } else {
2188 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2189 }
2190 return SWIG_Py_Void();
2191 }
2192 }
2193
2194 /* Create a new pointer object */
2195
2196 SWIGRUNTIME PyObject *
2197 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2198 if (!ptr) {
2199 return SWIG_Py_Void();
2200 } else {
2201 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2202 PyObject *robj = PySwigObject_New(ptr, type, own);
2203 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2204 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2205 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2206 if (inst) {
2207 Py_DECREF(robj);
2208 robj = inst;
2209 }
2210 }
2211 return robj;
2212 }
2213 }
2214
2215 /* Create a new packed object */
2216
2217 SWIGRUNTIMEINLINE PyObject *
2218 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2219 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2220 }
2221
2222 /* -----------------------------------------------------------------------------*
2223 * Get type list
2224 * -----------------------------------------------------------------------------*/
2225
2226 #ifdef SWIG_LINK_RUNTIME
2227 void *SWIG_ReturnGlobalTypeList(void *);
2228 #endif
2229
2230 SWIGRUNTIME swig_module_info *
2231 SWIG_Python_GetModule(void) {
2232 static void *type_pointer = (void *)0;
2233 /* first check if module already created */
2234 if (!type_pointer) {
2235 #ifdef SWIG_LINK_RUNTIME
2236 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2237 #else
2238 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2239 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2240 if (PyErr_Occurred()) {
2241 PyErr_Clear();
2242 type_pointer = (void *)0;
2243 }
2244 #endif
2245 }
2246 return (swig_module_info *) type_pointer;
2247 }
2248
2249 #if PY_MAJOR_VERSION < 2
2250 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2251 is copied out of Python/modsupport.c in python version 2.3.4 */
2252 SWIGINTERN int
2253 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2254 {
2255 PyObject *dict;
2256 if (!PyModule_Check(m)) {
2257 PyErr_SetString(PyExc_TypeError,
2258 "PyModule_AddObject() needs module as first arg");
2259 return SWIG_ERROR;
2260 }
2261 if (!o) {
2262 PyErr_SetString(PyExc_TypeError,
2263 "PyModule_AddObject() needs non-NULL value");
2264 return SWIG_ERROR;
2265 }
2266
2267 dict = PyModule_GetDict(m);
2268 if (dict == NULL) {
2269 /* Internal error -- modules must have a dict! */
2270 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2271 PyModule_GetName(m));
2272 return SWIG_ERROR;
2273 }
2274 if (PyDict_SetItemString(dict, name, o))
2275 return SWIG_ERROR;
2276 Py_DECREF(o);
2277 return SWIG_OK;
2278 }
2279 #endif
2280
2281 SWIGRUNTIME void
2282 SWIG_Python_DestroyModule(void *vptr)
2283 {
2284 swig_module_info *swig_module = (swig_module_info *) vptr;
2285 swig_type_info **types = swig_module->types;
2286 size_t i;
2287 for (i =0; i < swig_module->size; ++i) {
2288 swig_type_info *ty = types[i];
2289 if (ty->owndata) {
2290 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2291 if (data) PySwigClientData_Del(data);
2292 }
2293 }
2294 Py_DECREF(SWIG_This());
2295 }
2296
2297 SWIGRUNTIME void
2298 SWIG_Python_SetModule(swig_module_info *swig_module) {
2299 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2300
2301 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2302 swig_empty_runtime_method_table);
2303 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2304 if (pointer && module) {
2305 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2306 } else {
2307 Py_XDECREF(pointer);
2308 }
2309 }
2310
2311 /* The python cached type query */
2312 SWIGRUNTIME PyObject *
2313 SWIG_Python_TypeCache() {
2314 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2315 return cache;
2316 }
2317
2318 SWIGRUNTIME swig_type_info *
2319 SWIG_Python_TypeQuery(const char *type)
2320 {
2321 PyObject *cache = SWIG_Python_TypeCache();
2322 PyObject *key = PyString_FromString(type);
2323 PyObject *obj = PyDict_GetItem(cache, key);
2324 swig_type_info *descriptor;
2325 if (obj) {
2326 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2327 } else {
2328 swig_module_info *swig_module = SWIG_Python_GetModule();
2329 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2330 if (descriptor) {
2331 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2332 PyDict_SetItem(cache, key, obj);
2333 Py_DECREF(obj);
2334 }
2335 }
2336 Py_DECREF(key);
2337 return descriptor;
2338 }
2339
2340 /*
2341 For backward compatibility only
2342 */
2343 #define SWIG_POINTER_EXCEPTION 0
2344 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2345 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2346
2347 SWIGRUNTIME int
2348 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2349 {
2350 if (PyErr_Occurred()) {
2351 PyObject *type = 0;
2352 PyObject *value = 0;
2353 PyObject *traceback = 0;
2354 PyErr_Fetch(&type, &value, &traceback);
2355 if (value) {
2356 PyObject *old_str = PyObject_Str(value);
2357 Py_XINCREF(type);
2358 PyErr_Clear();
2359 if (infront) {
2360 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2361 } else {
2362 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2363 }
2364 Py_DECREF(old_str);
2365 }
2366 return 1;
2367 } else {
2368 return 0;
2369 }
2370 }
2371
2372 SWIGRUNTIME int
2373 SWIG_Python_ArgFail(int argnum)
2374 {
2375 if (PyErr_Occurred()) {
2376 /* add information about failing argument */
2377 char mesg[256];
2378 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2379 return SWIG_Python_AddErrMesg(mesg, 1);
2380 } else {
2381 return 0;
2382 }
2383 }
2384
2385 SWIGRUNTIMEINLINE const char *
2386 PySwigObject_GetDesc(PyObject *self)
2387 {
2388 PySwigObject *v = (PySwigObject *)self;
2389 swig_type_info *ty = v ? v->ty : 0;
2390 return ty ? ty->str : (char*)"";
2391 }
2392
2393 SWIGRUNTIME void
2394 SWIG_Python_TypeError(const char *type, PyObject *obj)
2395 {
2396 if (type) {
2397 #if defined(SWIG_COBJECT_TYPES)
2398 if (obj && PySwigObject_Check(obj)) {
2399 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2400 if (otype) {
2401 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2402 type, otype);
2403 return;
2404 }
2405 } else
2406 #endif
2407 {
2408 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2409 if (otype) {
2410 PyObject *str = PyObject_Str(obj);
2411 const char *cstr = str ? PyString_AsString(str) : 0;
2412 if (cstr) {
2413 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2414 type, otype, cstr);
2415 } else {
2416 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2417 type, otype);
2418 }
2419 Py_XDECREF(str);
2420 return;
2421 }
2422 }
2423 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2424 } else {
2425 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2426 }
2427 }
2428
2429
2430 /* Convert a pointer value, signal an exception on a type mismatch */
2431 SWIGRUNTIME void *
2432 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2433 void *result;
2434 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2435 PyErr_Clear();
2436 if (flags & SWIG_POINTER_EXCEPTION) {
2437 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2438 SWIG_Python_ArgFail(argnum);
2439 }
2440 }
2441 return result;
2442 }
2443
2444
2445 #ifdef __cplusplus
2446 #if 0
2447 { /* cc-mode */
2448 #endif
2449 }
2450 #endif
2451
2452
2453
2454 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2455
2456 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2457
2458
2459
2460 /* -------- TYPES TABLE (BEGIN) -------- */
2461
2462 #define SWIGTYPE_p_buffer swig_types[0]
2463 #define SWIGTYPE_p_char swig_types[1]
2464 #define SWIGTYPE_p_form_ops_t swig_types[2]
2465 #define SWIGTYPE_p_int swig_types[3]
2466 #define SWIGTYPE_p_long swig_types[4]
2467 #define SWIGTYPE_p_unsigned_char swig_types[5]
2468 #define SWIGTYPE_p_unsigned_int swig_types[6]
2469 #define SWIGTYPE_p_unsigned_long swig_types[7]
2470 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2471 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2472 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2473 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2474 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2475 #define SWIGTYPE_p_wxArrayString swig_types[13]
2476 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2477 #define SWIGTYPE_p_wxBitmap swig_types[15]
2478 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2479 #define SWIGTYPE_p_wxButton swig_types[17]
2480 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2481 #define SWIGTYPE_p_wxCaret swig_types[19]
2482 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2483 #define SWIGTYPE_p_wxCloseEvent swig_types[21]
2484 #define SWIGTYPE_p_wxColour swig_types[22]
2485 #define SWIGTYPE_p_wxCommandEvent swig_types[23]
2486 #define SWIGTYPE_p_wxContextMenuEvent swig_types[24]
2487 #define SWIGTYPE_p_wxControl swig_types[25]
2488 #define SWIGTYPE_p_wxControlWithItems swig_types[26]
2489 #define SWIGTYPE_p_wxCursor swig_types[27]
2490 #define SWIGTYPE_p_wxDC swig_types[28]
2491 #define SWIGTYPE_p_wxDateEvent swig_types[29]
2492 #define SWIGTYPE_p_wxDateTime swig_types[30]
2493 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[31]
2494 #define SWIGTYPE_p_wxDropFilesEvent swig_types[32]
2495 #define SWIGTYPE_p_wxDuplexMode swig_types[33]
2496 #define SWIGTYPE_p_wxEraseEvent swig_types[34]
2497 #define SWIGTYPE_p_wxEvent swig_types[35]
2498 #define SWIGTYPE_p_wxEventLoop swig_types[36]
2499 #define SWIGTYPE_p_wxEventLoopActivator swig_types[37]
2500 #define SWIGTYPE_p_wxEvtHandler swig_types[38]
2501 #define SWIGTYPE_p_wxFSFile swig_types[39]
2502 #define SWIGTYPE_p_wxFileSystem swig_types[40]
2503 #define SWIGTYPE_p_wxFileSystemHandler swig_types[41]
2504 #define SWIGTYPE_p_wxFlexGridSizer swig_types[42]
2505 #define SWIGTYPE_p_wxFocusEvent swig_types[43]
2506 #define SWIGTYPE_p_wxFont swig_types[44]
2507 #define SWIGTYPE_p_wxFrame swig_types[45]
2508 #define SWIGTYPE_p_wxGBPosition swig_types[46]
2509 #define SWIGTYPE_p_wxGBSizerItem swig_types[47]
2510 #define SWIGTYPE_p_wxGBSpan swig_types[48]
2511 #define SWIGTYPE_p_wxGIFHandler swig_types[49]
2512 #define SWIGTYPE_p_wxGridBagSizer swig_types[50]
2513 #define SWIGTYPE_p_wxGridSizer swig_types[51]
2514 #define SWIGTYPE_p_wxICOHandler swig_types[52]
2515 #define SWIGTYPE_p_wxIconizeEvent swig_types[53]
2516 #define SWIGTYPE_p_wxIdleEvent swig_types[54]
2517 #define SWIGTYPE_p_wxImage swig_types[55]
2518 #define SWIGTYPE_p_wxImageHandler swig_types[56]
2519 #define SWIGTYPE_p_wxImageHistogram swig_types[57]
2520 #define SWIGTYPE_p_wxImage_HSVValue swig_types[58]
2521 #define SWIGTYPE_p_wxImage_RGBValue swig_types[59]
2522 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[60]
2523 #define SWIGTYPE_p_wxInitDialogEvent swig_types[61]
2524 #define SWIGTYPE_p_wxInputStream swig_types[62]
2525 #define SWIGTYPE_p_wxInternetFSHandler swig_types[63]
2526 #define SWIGTYPE_p_wxItemContainer swig_types[64]
2527 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
2528 #define SWIGTYPE_p_wxKeyEvent swig_types[66]
2529 #define SWIGTYPE_p_wxLayoutConstraints swig_types[67]
2530 #define SWIGTYPE_p_wxMaximizeEvent swig_types[68]
2531 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
2532 #define SWIGTYPE_p_wxMenu swig_types[70]
2533 #define SWIGTYPE_p_wxMenuBar swig_types[71]
2534 #define SWIGTYPE_p_wxMenuBarBase swig_types[72]
2535 #define SWIGTYPE_p_wxMenuEvent swig_types[73]
2536 #define SWIGTYPE_p_wxMenuItem swig_types[74]
2537 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[75]
2538 #define SWIGTYPE_p_wxMouseEvent swig_types[76]
2539 #define SWIGTYPE_p_wxMoveEvent swig_types[77]
2540 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[78]
2541 #define SWIGTYPE_p_wxNcPaintEvent swig_types[79]
2542 #define SWIGTYPE_p_wxNotifyEvent swig_types[80]
2543 #define SWIGTYPE_p_wxObject swig_types[81]
2544 #define SWIGTYPE_p_wxOutputStream swig_types[82]
2545 #define SWIGTYPE_p_wxPCXHandler swig_types[83]
2546 #define SWIGTYPE_p_wxPNGHandler swig_types[84]
2547 #define SWIGTYPE_p_wxPNMHandler swig_types[85]
2548 #define SWIGTYPE_p_wxPaintEvent swig_types[86]
2549 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[87]
2550 #define SWIGTYPE_p_wxPaperSize swig_types[88]
2551 #define SWIGTYPE_p_wxPoint swig_types[89]
2552 #define SWIGTYPE_p_wxPoint2D swig_types[90]
2553 #define SWIGTYPE_p_wxPropagateOnce swig_types[91]
2554 #define SWIGTYPE_p_wxPropagationDisabler swig_types[92]
2555 #define SWIGTYPE_p_wxPyApp swig_types[93]
2556 #define SWIGTYPE_p_wxPyCommandEvent swig_types[94]
2557 #define SWIGTYPE_p_wxPyDropTarget swig_types[95]
2558 #define SWIGTYPE_p_wxPyEvent swig_types[96]
2559 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[97]
2560 #define SWIGTYPE_p_wxPyImageHandler swig_types[98]
2561 #define SWIGTYPE_p_wxPyInputStream swig_types[99]
2562 #define SWIGTYPE_p_wxPySizer swig_types[100]
2563 #define SWIGTYPE_p_wxPyValidator swig_types[101]
2564 #define SWIGTYPE_p_wxQuantize swig_types[102]
2565 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[103]
2566 #define SWIGTYPE_p_wxRealPoint swig_types[104]
2567 #define SWIGTYPE_p_wxRect swig_types[105]
2568 #define SWIGTYPE_p_wxRegion swig_types[106]
2569 #define SWIGTYPE_p_wxScrollEvent swig_types[107]
2570 #define SWIGTYPE_p_wxScrollWinEvent swig_types[108]
2571 #define SWIGTYPE_p_wxSetCursorEvent swig_types[109]
2572 #define SWIGTYPE_p_wxShowEvent swig_types[110]
2573 #define SWIGTYPE_p_wxSize swig_types[111]
2574 #define SWIGTYPE_p_wxSizeEvent swig_types[112]
2575 #define SWIGTYPE_p_wxSizer swig_types[113]
2576 #define SWIGTYPE_p_wxSizerItem swig_types[114]
2577 #define SWIGTYPE_p_wxStaticBox swig_types[115]
2578 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[116]
2579 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[117]
2580 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[118]
2581 #define SWIGTYPE_p_wxTIFFHandler swig_types[119]
2582 #define SWIGTYPE_p_wxToolTip swig_types[120]
2583 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[121]
2584 #define SWIGTYPE_p_wxValidator swig_types[122]
2585 #define SWIGTYPE_p_wxVisualAttributes swig_types[123]
2586 #define SWIGTYPE_p_wxWindow swig_types[124]
2587 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[125]
2588 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[126]
2589 #define SWIGTYPE_p_wxXPMHandler swig_types[127]
2590 #define SWIGTYPE_p_wxZipFSHandler swig_types[128]
2591 static swig_type_info *swig_types[130];
2592 static swig_module_info swig_module = {swig_types, 129, 0, 0, 0, 0};
2593 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2594 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2595
2596 /* -------- TYPES TABLE (END) -------- */
2597
2598 #if (PY_VERSION_HEX <= 0x02000000)
2599 # if !defined(SWIG_PYTHON_CLASSIC)
2600 # error "This python version requires to use swig with the '-classic' option"
2601 # endif
2602 #endif
2603 #if (PY_VERSION_HEX <= 0x02020000)
2604 # error "This python version requires to use swig with the '-nomodern' option"
2605 #endif
2606 #if (PY_VERSION_HEX <= 0x02020000)
2607 # error "This python version requires to use swig with the '-nomodernargs' option"
2608 #endif
2609 #ifndef METH_O
2610 # error "This python version requires to use swig with the '-nofastunpack' option"
2611 #endif
2612
2613 /*-----------------------------------------------
2614 @(target):= _core_.so
2615 ------------------------------------------------*/
2616 #define SWIG_init init_core_
2617
2618 #define SWIG_name "_core_"
2619
2620 #define SWIGVERSION 0x010329
2621
2622
2623 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2624 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2625
2626
2627 #include <stdexcept>
2628
2629
2630 namespace swig {
2631 class PyObject_ptr {
2632 protected:
2633 PyObject *_obj;
2634
2635 public:
2636 PyObject_ptr() :_obj(0)
2637 {
2638 }
2639
2640 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2641 {
2642 Py_XINCREF(_obj);
2643 }
2644
2645 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2646 {
2647 if (initial_ref) Py_XINCREF(_obj);
2648 }
2649
2650 PyObject_ptr & operator=(const PyObject_ptr& item)
2651 {
2652 Py_XINCREF(item._obj);
2653 Py_XDECREF(_obj);
2654 _obj = item._obj;
2655 return *this;
2656 }
2657
2658 ~PyObject_ptr()
2659 {
2660 Py_XDECREF(_obj);
2661 }
2662
2663 operator PyObject *() const
2664 {
2665 return _obj;
2666 }
2667
2668 PyObject *operator->() const
2669 {
2670 return _obj;
2671 }
2672 };
2673 }
2674
2675
2676 namespace swig {
2677 struct PyObject_var : PyObject_ptr {
2678 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2679
2680 PyObject_var & operator = (PyObject* obj)
2681 {
2682 Py_XDECREF(_obj);
2683 _obj = obj;
2684 return *this;
2685 }
2686 };
2687 }
2688
2689
2690 #include "wx/wxPython/wxPython_int.h"
2691 #include "wx/wxPython/pyclasses.h"
2692
2693
2694 #ifndef wxPyUSE_EXPORT
2695 // Helper functions for dealing with SWIG objects and such. These are
2696 // located here so they know about the SWIG types and functions declared
2697 // in the wrapper code.
2698
2699 #include <wx/hashmap.h>
2700 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2701
2702
2703 // Maintains a hashmap of className to swig_type_info pointers. Given the
2704 // name of a class either looks up the type info in the cache, or scans the
2705 // SWIG tables for it.
2706 extern PyObject* wxPyPtrTypeMap;
2707 static
2708 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2709
2710 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2711
2712 if (typeInfoCache == NULL)
2713 typeInfoCache = new wxPyTypeInfoHashMap;
2714
2715 wxString name(className);
2716 swig_type_info* swigType = (*typeInfoCache)[name];
2717
2718 if (! swigType) {
2719 // it wasn't in the cache, so look it up from SWIG
2720 name.Append(wxT(" *"));
2721 swigType = SWIG_TypeQuery(name.mb_str());
2722
2723 // if it still wasn't found, try looking for a mapped name
2724 if (!swigType) {
2725 PyObject* item;
2726 name = className;
2727
2728 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2729 (char*)(const char*)name.mbc_str())) != NULL) {
2730 name = wxString(PyString_AsString(item), *wxConvCurrent);
2731 name.Append(wxT(" *"));
2732 swigType = SWIG_TypeQuery(name.mb_str());
2733 }
2734 }
2735 if (swigType) {
2736 // and add it to the map if found
2737 (*typeInfoCache)[className] = swigType;
2738 }
2739 }
2740 return swigType;
2741 }
2742
2743
2744 // Check if a class name is a type known to SWIG
2745 bool wxPyCheckSwigType(const wxChar* className) {
2746
2747 swig_type_info* swigType = wxPyFindSwigType(className);
2748 return swigType != NULL;
2749 }
2750
2751
2752 // Given a pointer to a C++ object and a class name, construct a Python proxy
2753 // object for it.
2754 PyObject* wxPyConstructObject(void* ptr,
2755 const wxChar* className,
2756 int setThisOwn) {
2757
2758 swig_type_info* swigType = wxPyFindSwigType(className);
2759 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2760
2761 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2762 }
2763
2764
2765 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2766 // Ensures that the proxy object is of the specified (or derived) type. If
2767 // not able to perform the conversion then a Python exception is set and the
2768 // error should be handled properly in the caller. Returns True on success.
2769 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2770 const wxChar* className) {
2771
2772 swig_type_info* swigType = wxPyFindSwigType(className);
2773 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2774
2775 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2776 }
2777
2778
2779
2780 // Make a SWIGified pointer object suitable for a .this attribute
2781 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2782
2783 PyObject* robj = NULL;
2784
2785 swig_type_info* swigType = wxPyFindSwigType(className);
2786 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2787
2788 robj = PySwigObject_New(ptr, swigType, 0);
2789 return robj;
2790 }
2791
2792
2793 // Python's PyInstance_Check does not return True for instances of new-style
2794 // classes. This should get close enough for both new and old classes but I
2795 // should re-evaluate the need for doing instance checks...
2796 bool wxPyInstance_Check(PyObject* obj) {
2797 return PyObject_HasAttrString(obj, "__class__") != 0;
2798 }
2799
2800
2801 // This one checks if the object is an instance of a SWIG proxy class (it has
2802 // a .this attribute, and the .this attribute is a PySwigObject.)
2803 bool wxPySwigInstance_Check(PyObject* obj) {
2804 static PyObject* this_str = NULL;
2805 if (this_str == NULL)
2806 this_str = PyString_FromString("this");
2807
2808 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2809 if (this_attr) {
2810 bool retval = (PySwigObject_Check(this_attr) != 0);
2811 Py_DECREF(this_attr);
2812 return retval;
2813 }
2814
2815 PyErr_Clear();
2816 return false;
2817 }
2818
2819
2820 // Export a C API in a struct. Other modules will be able to load this from
2821 // the wx._core_ module and will then have safe access to these functions,
2822 // even if they are located in another shared library.
2823 static wxPyCoreAPI API = {
2824
2825 wxPyCheckSwigType,
2826 wxPyConstructObject,
2827 wxPyConvertSwigPtr,
2828 wxPyMakeSwigPtr,
2829
2830 wxPyBeginAllowThreads,
2831 wxPyEndAllowThreads,
2832 wxPyBeginBlockThreads,
2833 wxPyEndBlockThreads,
2834
2835 wxPy_ConvertList,
2836
2837 wxString_in_helper,
2838 Py2wxString,
2839 wx2PyString,
2840
2841 byte_LIST_helper,
2842 int_LIST_helper,
2843 long_LIST_helper,
2844 string_LIST_helper,
2845 wxPoint_LIST_helper,
2846 wxBitmap_LIST_helper,
2847 wxString_LIST_helper,
2848 wxAcceleratorEntry_LIST_helper,
2849
2850 wxSize_helper,
2851 wxPoint_helper,
2852 wxRealPoint_helper,
2853 wxRect_helper,
2854 wxColour_helper,
2855 wxPoint2D_helper,
2856
2857 wxPySimple_typecheck,
2858 wxColour_typecheck,
2859
2860 wxPyCBH_setCallbackInfo,
2861 wxPyCBH_findCallback,
2862 wxPyCBH_callCallback,
2863 wxPyCBH_callCallbackObj,
2864 wxPyCBH_delete,
2865
2866 wxPyMake_wxObject,
2867 wxPyMake_wxSizer,
2868 wxPyPtrTypeMap_Add,
2869 wxPy2int_seq_helper,
2870 wxPy4int_seq_helper,
2871 wxArrayString2PyList_helper,
2872 wxArrayInt2PyList_helper,
2873
2874 wxPyClientData_dtor,
2875 wxPyUserData_dtor,
2876 wxPyOORClientData_dtor,
2877
2878 wxPyCBInputStream_create,
2879 wxPyCBInputStream_copy,
2880
2881 wxPyInstance_Check,
2882 wxPySwigInstance_Check,
2883
2884 wxPyCheckForApp
2885
2886 };
2887
2888 #endif
2889
2890
2891 #if !WXWIN_COMPATIBILITY_2_4
2892 #define wxHIDE_READONLY 0
2893 #endif
2894
2895
2896 #define SWIG_From_long PyInt_FromLong
2897
2898
2899 SWIGINTERNINLINE PyObject *
2900 SWIG_From_int (int value)
2901 {
2902 return SWIG_From_long (value);
2903 }
2904
2905 static const wxString wxPyEmptyString(wxEmptyString);
2906 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2907 return self->GetClassInfo()->GetClassName();
2908 }
2909 SWIGINTERN void wxObject_Destroy(wxObject *self){
2910 delete self;
2911 }
2912
2913 #ifndef __WXMAC__
2914 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2915 #endif
2916
2917
2918 #include <limits.h>
2919 #ifndef LLONG_MIN
2920 # define LLONG_MIN LONG_LONG_MIN
2921 #endif
2922 #ifndef LLONG_MAX
2923 # define LLONG_MAX LONG_LONG_MAX
2924 #endif
2925 #ifndef ULLONG_MAX
2926 # define ULLONG_MAX ULONG_LONG_MAX
2927 #endif
2928
2929
2930 SWIGINTERN int
2931 SWIG_AsVal_long (PyObject* obj, long* val)
2932 {
2933 if (PyNumber_Check(obj)) {
2934 if (val) *val = PyInt_AsLong(obj);
2935 return SWIG_OK;
2936 }
2937 return SWIG_TypeError;
2938 }
2939
2940
2941 SWIGINTERN int
2942 SWIG_AsVal_int (PyObject * obj, int *val)
2943 {
2944 long v;
2945 int res = SWIG_AsVal_long (obj, &v);
2946 if (SWIG_IsOK(res)) {
2947 if ((v < INT_MIN || v > INT_MAX)) {
2948 return SWIG_OverflowError;
2949 } else {
2950 if (val) *val = static_cast< int >(v);
2951 }
2952 }
2953 return res;
2954 }
2955
2956 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
2957 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2958 PyObject* tup = PyTuple_New(2);
2959 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2960 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2961 wxPyEndBlockThreads(blocked);
2962 return tup;
2963 }
2964
2965 SWIGINTERN int
2966 SWIG_AsVal_double (PyObject *obj, double* val)
2967 {
2968 if (PyNumber_Check(obj)) {
2969 if (val) *val = PyFloat_AsDouble(obj);
2970 return SWIG_OK;
2971 }
2972 return SWIG_TypeError;
2973 }
2974
2975
2976 #define SWIG_From_double PyFloat_FromDouble
2977
2978 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
2979 self->x = x;
2980 self->y = y;
2981 }
2982 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
2983 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2984 PyObject* tup = PyTuple_New(2);
2985 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
2986 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
2987 wxPyEndBlockThreads(blocked);
2988 return tup;
2989 }
2990 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
2991 self->x = x;
2992 self->y = y;
2993 }
2994 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
2995 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2996 PyObject* tup = PyTuple_New(2);
2997 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
2998 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
2999 wxPyEndBlockThreads(blocked);
3000 return tup;
3001 }
3002 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3003 self->x = x;
3004 self->y = y;
3005 self->width = width;
3006 self->height = height;
3007 }
3008 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3010 PyObject* tup = PyTuple_New(4);
3011 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3012 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3013 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3014 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3015 wxPyEndBlockThreads(blocked);
3016 return tup;
3017 }
3018
3019 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3020 wxRegion reg1(*r1);
3021 wxRegion reg2(*r2);
3022 wxRect dest(0,0,0,0);
3023 PyObject* obj;
3024
3025 reg1.Intersect(reg2);
3026 dest = reg1.GetBox();
3027
3028 if (dest != wxRect(0,0,0,0)) {
3029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3030 wxRect* newRect = new wxRect(dest);
3031 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3032 wxPyEndBlockThreads(blocked);
3033 return obj;
3034 }
3035 Py_INCREF(Py_None);
3036 return Py_None;
3037 }
3038
3039 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3040 self->m_x = x;
3041 self->m_y = y;
3042 }
3043 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3044 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3045 PyObject* tup = PyTuple_New(2);
3046 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3047 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3048 wxPyEndBlockThreads(blocked);
3049 return tup;
3050 }
3051
3052 #include "wx/wxPython/pyistream.h"
3053
3054 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3055 wxInputStream* wxis = wxPyCBInputStream::create(p);
3056 if (wxis)
3057 return new wxPyInputStream(wxis);
3058 else
3059 return NULL;
3060 }
3061
3062 SWIGINTERN swig_type_info*
3063 SWIG_pchar_descriptor()
3064 {
3065 static int init = 0;
3066 static swig_type_info* info = 0;
3067 if (!init) {
3068 info = SWIG_TypeQuery("_p_char");
3069 init = 1;
3070 }
3071 return info;
3072 }
3073
3074
3075 SWIGINTERNINLINE PyObject *
3076 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3077 {
3078 if (carray) {
3079 if (size > INT_MAX) {
3080 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3081 return pchar_descriptor ?
3082 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3083 } else {
3084 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3085 }
3086 } else {
3087 return SWIG_Py_Void();
3088 }
3089 }
3090
3091
3092 SWIGINTERNINLINE PyObject *
3093 SWIG_From_char (char c)
3094 {
3095 return SWIG_FromCharPtrAndSize(&c,1);
3096 }
3097
3098
3099 SWIGINTERNINLINE PyObject*
3100 SWIG_From_unsigned_SS_long (unsigned long value)
3101 {
3102 return (value > LONG_MAX) ?
3103 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3104 }
3105
3106
3107 SWIGINTERNINLINE PyObject *
3108 SWIG_From_size_t (size_t value)
3109 {
3110 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3111 }
3112
3113
3114 SWIGINTERN int
3115 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3116 {
3117 if (PyString_Check(obj)) {
3118 char *cstr; int len;
3119 PyString_AsStringAndSize(obj, &cstr, &len);
3120 if (cptr) {
3121 if (alloc) {
3122 /*
3123 In python the user should not be able to modify the inner
3124 string representation. To warranty that, if you define
3125 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3126 buffer is always returned.
3127
3128 The default behavior is just to return the pointer value,
3129 so, be careful.
3130 */
3131 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3132 if (*alloc != SWIG_OLDOBJ)
3133 #else
3134 if (*alloc == SWIG_NEWOBJ)
3135 #endif
3136 {
3137 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3138 *alloc = SWIG_NEWOBJ;
3139 }
3140 else {
3141 *cptr = cstr;
3142 *alloc = SWIG_OLDOBJ;
3143 }
3144 } else {
3145 *cptr = PyString_AsString(obj);
3146 }
3147 }
3148 if (psize) *psize = len + 1;
3149 return SWIG_OK;
3150 } else {
3151 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3152 if (pchar_descriptor) {
3153 void* vptr = 0;
3154 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3155 if (cptr) *cptr = (char *) vptr;
3156 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3157 if (alloc) *alloc = SWIG_OLDOBJ;
3158 return SWIG_OK;
3159 }
3160 }
3161 }
3162 return SWIG_TypeError;
3163 }
3164
3165
3166 SWIGINTERN int
3167 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3168 {
3169 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3170 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3171 if (SWIG_IsOK(res)) {
3172 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3173 if (csize <= size) {
3174 if (val) {
3175 if (csize) memcpy(val, cptr, csize*sizeof(char));
3176 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3177 }
3178 if (alloc == SWIG_NEWOBJ) {
3179 delete[] cptr;
3180 res = SWIG_DelNewMask(res);
3181 }
3182 return res;
3183 }
3184 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3185 }
3186 return SWIG_TypeError;
3187 }
3188
3189
3190 SWIGINTERN int
3191 SWIG_AsVal_char (PyObject * obj, char *val)
3192 {
3193 int res = SWIG_AsCharArray(obj, val, 1);
3194 if (!SWIG_IsOK(res)) {
3195 long v;
3196 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3197 if (SWIG_IsOK(res)) {
3198 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3199 if (val) *val = static_cast< char >(v);
3200 } else {
3201 res = SWIG_OverflowError;
3202 }
3203 }
3204 }
3205 return res;
3206 }
3207
3208 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3209 // We use only strings for the streams, not unicode
3210 PyObject* str = PyObject_Str(obj);
3211 if (! str) {
3212 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3213 return;
3214 }
3215 self->Write(PyString_AS_STRING(str),
3216 PyString_GET_SIZE(str));
3217 Py_DECREF(str);
3218 }
3219
3220 #include "wx/wxPython/pyistream.h"
3221
3222
3223 class wxPyFileSystemHandler : public wxFileSystemHandler
3224 {
3225 public:
3226 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3227
3228 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3229 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3230 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3231 DEC_PYCALLBACK_STRING__pure(FindNext);
3232
3233 wxString GetProtocol(const wxString& location) {
3234 return wxFileSystemHandler::GetProtocol(location);
3235 }
3236
3237 wxString GetLeftLocation(const wxString& location) {
3238 return wxFileSystemHandler::GetLeftLocation(location);
3239 }
3240
3241 wxString GetAnchor(const wxString& location) {
3242 return wxFileSystemHandler::GetAnchor(location);
3243 }
3244
3245 wxString GetRightLocation(const wxString& location) {
3246 return wxFileSystemHandler::GetRightLocation(location);
3247 }
3248
3249 wxString GetMimeTypeFromExt(const wxString& location) {
3250 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3251 }
3252
3253 PYPRIVATE;
3254 };
3255
3256
3257 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3258 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3259 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3260 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3261
3262
3263 SWIGINTERN int
3264 SWIG_AsVal_bool (PyObject *obj, bool *val)
3265 {
3266 if (obj == Py_True) {
3267 if (val) *val = true;
3268 return SWIG_OK;
3269 } else if (obj == Py_False) {
3270 if (val) *val = false;
3271 return SWIG_OK;
3272 } else {
3273 long v = 0;
3274 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3275 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3276 return res;
3277 }
3278 }
3279
3280 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3281 wxFileName fname = wxFileSystem::URLToFileName(url);
3282 return fname.GetFullPath();
3283 }
3284
3285 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3286 wxImage& image,
3287 long type) {
3288 wxMemoryFSHandler::AddFile(filename, image, type);
3289 }
3290
3291 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3292 const wxBitmap& bitmap,
3293 long type) {
3294 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3295 }
3296
3297 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3298 PyObject* data) {
3299 if (! PyString_Check(data)) {
3300 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3301 "Expected string object"));
3302 return;
3303 }
3304
3305 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3306 void* ptr = (void*)PyString_AsString(data);
3307 size_t size = PyString_Size(data);
3308 wxPyEndBlockThreads(blocked);
3309
3310 wxMemoryFSHandler::AddFile(filename, ptr, size);
3311 }
3312
3313
3314 #include "wx/wxPython/pyistream.h"
3315
3316
3317 SWIGINTERN int
3318 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3319 {
3320 long v = 0;
3321 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3322 return SWIG_TypeError;
3323 }
3324 else if (val)
3325 *val = (unsigned long)v;
3326 return SWIG_OK;
3327 }
3328
3329
3330 SWIGINTERN int
3331 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3332 {
3333 unsigned long v;
3334 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3335 if (SWIG_IsOK(res)) {
3336 if ((v > UCHAR_MAX)) {
3337 return SWIG_OverflowError;
3338 } else {
3339 if (val) *val = static_cast< unsigned char >(v);
3340 }
3341 }
3342 return res;
3343 }
3344
3345
3346 SWIGINTERNINLINE PyObject *
3347 SWIG_From_unsigned_SS_char (unsigned char value)
3348 {
3349 return SWIG_From_unsigned_SS_long (value);
3350 }
3351
3352 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3353 wxImageHistogramEntry e = (*self)[key];
3354 return e.value;
3355 }
3356 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3357 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3358 wxImageHistogramEntry e = (*self)[key];
3359 return e.value;
3360 }
3361 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3362 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3363 colour.Green(),
3364 colour.Blue());
3365 wxImageHistogramEntry e = (*self)[key];
3366 return e.value;
3367 }
3368
3369 typedef unsigned char* buffer;
3370
3371
3372 // Pull the nested class out to the top level for SWIG's sake
3373 #define wxImage_RGBValue wxImage::RGBValue
3374 #define wxImage_HSVValue wxImage::HSVValue
3375
3376 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3377 if (width > 0 && height > 0)
3378 return new wxImage(width, height, clear);
3379 else
3380 return new wxImage;
3381 }
3382 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3383 return new wxImage(bitmap.ConvertToImage());
3384 }
3385 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3386 if (DATASIZE != width*height*3) {
3387 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3388 return NULL;
3389 }
3390
3391 // Copy the source data so the wxImage can clean it up later
3392 buffer copy = (buffer)malloc(DATASIZE);
3393 if (copy == NULL) {
3394 wxPyBLOCK_THREADS(PyErr_NoMemory());
3395 return NULL;
3396 }
3397 memcpy(copy, data, DATASIZE);
3398 return new wxImage(width, height, copy, false);
3399 }
3400 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3401 if (DATASIZE != width*height*3) {
3402 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3403 return NULL;
3404 }
3405 if (ALPHASIZE != width*height) {
3406 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3407 return NULL;
3408 }
3409
3410 // Copy the source data so the wxImage can clean it up later
3411 buffer dcopy = (buffer)malloc(DATASIZE);
3412 if (dcopy == NULL) {
3413 wxPyBLOCK_THREADS(PyErr_NoMemory());
3414 return NULL;
3415 }
3416 memcpy(dcopy, data, DATASIZE);
3417
3418 buffer acopy = (buffer)malloc(ALPHASIZE);
3419 if (acopy == NULL) {
3420 wxPyBLOCK_THREADS(PyErr_NoMemory());
3421 return NULL;
3422 }
3423 memcpy(acopy, alpha, ALPHASIZE);
3424
3425 return new wxImage(width, height, dcopy, acopy, false);
3426 }
3427 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3428 wxSize size(self->GetWidth(), self->GetHeight());
3429 return size;
3430 }
3431 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3432 buffer data = self->GetData();
3433 int len = self->GetWidth() * self->GetHeight() * 3;
3434 PyObject* rv;
3435 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3436 return rv;
3437 }
3438 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3439 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3440 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3441 return;
3442 }
3443 buffer copy = (buffer)malloc(DATASIZE);
3444 if (copy == NULL) {
3445 wxPyBLOCK_THREADS(PyErr_NoMemory());
3446 return;
3447 }
3448 memcpy(copy, data, DATASIZE);
3449 self->SetData(copy, false);
3450 // wxImage takes ownership of copy...
3451 }
3452 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3453 buffer data = self->GetData();
3454 int len = self->GetWidth() * self->GetHeight() * 3;
3455 PyObject* rv;
3456 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3457 return rv;
3458 }
3459 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3460 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3461 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3462 return;
3463 }
3464 self->SetData(data, true);
3465 }
3466 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3467 buffer data = self->GetAlpha();
3468 if (! data) {
3469 RETURN_NONE();
3470 } else {
3471 int len = self->GetWidth() * self->GetHeight();
3472 PyObject* rv;
3473 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3474 return rv;
3475 }
3476 }
3477 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3478 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3479 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3480 return;
3481 }
3482 buffer acopy = (buffer)malloc(ALPHASIZE);
3483 if (acopy == NULL) {
3484 wxPyBLOCK_THREADS(PyErr_NoMemory());
3485 return;
3486 }
3487 memcpy(acopy, alpha, ALPHASIZE);
3488 self->SetAlpha(acopy, false);
3489 // wxImage takes ownership of acopy...
3490 }
3491 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3492 buffer data = self->GetAlpha();
3493 int len = self->GetWidth() * self->GetHeight();
3494 PyObject* rv;
3495 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3496 return rv;
3497 }
3498 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3499 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3500 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3501 return;
3502 }
3503 self->SetAlpha(alpha, true);
3504 }
3505 SWIGINTERN PyObject *wxImage_GetHandlers(){
3506 wxList& list = wxImage::GetHandlers();
3507 return wxPy_ConvertList(&list);
3508 }
3509 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3510 wxBitmap bitmap(*self, depth);
3511 return bitmap;
3512 }
3513 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3514 wxImage mono = self->ConvertToMono( red, green, blue );
3515 wxBitmap bitmap( mono, 1 );
3516 return bitmap;
3517 }
3518 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3519 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3520 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3521 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3522 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3523 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3524 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3525 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3526 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3527 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3528 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3529 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3530 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3531 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3532 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3533
3534 #include <wx/quantize.h>
3535
3536 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3537 return wxQuantize::Quantize(src, dest,
3538 //NULL, // palette
3539 desiredNoColours,
3540 NULL, // eightBitData
3541 flags);
3542 }
3543 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3544 if (PyCallable_Check(func)) {
3545 self->Connect(id, lastId, eventType,
3546 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3547 new wxPyCallback(func));
3548 }
3549 else if (func == Py_None) {
3550 self->Disconnect(id, lastId, eventType,
3551 (wxObjectEventFunction)
3552 &wxPyCallback::EventThunker);
3553 }
3554 else {
3555 wxPyBLOCK_THREADS(
3556 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3557 }
3558 }
3559 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3560 return self->Disconnect(id, lastId, eventType,
3561 (wxObjectEventFunction)
3562 &wxPyCallback::EventThunker);
3563 }
3564 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3565 if (_self && _self != Py_None) {
3566 self->SetClientObject(new wxPyOORClientData(_self, incref));
3567 }
3568 else {
3569 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3570 if (data) {
3571 self->SetClientObject(NULL); // This will delete it too
3572 }
3573 }
3574 }
3575
3576 #if ! wxUSE_HOTKEY
3577 #define wxEVT_HOTKEY -9999
3578 #endif
3579
3580 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3581 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3582 if (data) {
3583 Py_INCREF(data->m_obj);
3584 return data->m_obj;
3585 } else {
3586 Py_INCREF(Py_None);
3587 return Py_None;
3588 }
3589 }
3590 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3591 wxPyClientData* data = new wxPyClientData(clientData);
3592 self->SetClientObject(data);
3593 }
3594 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3595 #if wxUSE_UNICODE
3596 return self->GetUnicodeKey();
3597 #else
3598 return 0;
3599 #endif
3600 }
3601
3602 SWIGINTERNINLINE PyObject *
3603 SWIG_From_unsigned_SS_int (unsigned int value)
3604 {
3605 return SWIG_From_unsigned_SS_long (value);
3606 }
3607
3608
3609 SWIGINTERN int
3610 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3611 {
3612 unsigned long v;
3613 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3614 if (SWIG_IsOK(res)) {
3615 if ((v > UINT_MAX)) {
3616 return SWIG_OverflowError;
3617 } else {
3618 if (val) *val = static_cast< unsigned int >(v);
3619 }
3620 }
3621 return res;
3622 }
3623
3624 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3625 self->m_size = size;
3626 }
3627 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3628 int count = self->GetNumberOfFiles();
3629 wxString* files = self->GetFiles();
3630 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3631 PyObject* list = PyList_New(count);
3632
3633 if (!list) {
3634 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3635 wxPyEndBlockThreads(blocked);
3636 return NULL;
3637 }
3638
3639 for (int i=0; i<count; i++) {
3640 PyList_SetItem(list, i, wx2PyString(files[i]));
3641 }
3642 wxPyEndBlockThreads(blocked);
3643 return list;
3644 }
3645
3646
3647 SWIGINTERN wxPyApp *new_wxPyApp(){
3648 wxPythonApp = new wxPyApp();
3649 return wxPythonApp;
3650 }
3651
3652 void wxApp_CleanUp() {
3653 __wxPyCleanup();
3654 }
3655
3656
3657 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3658
3659
3660
3661
3662
3663 SWIGINTERNINLINE PyObject *
3664 SWIG_FromCharPtr(const char *cptr)
3665 {
3666 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3667 }
3668
3669
3670 #if 0 // #ifdef __WXMAC__
3671
3672 // A dummy class that raises an exception if used...
3673 class wxEventLoop
3674 {
3675 public:
3676 wxEventLoop() { wxPyRaiseNotImplemented(); }
3677 int Run() { return 0; }
3678 void Exit(int rc = 0) {}
3679 bool Pending() const { return false; }
3680 bool Dispatch() { return false; }
3681 bool IsRunning() const { return false; }
3682 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3683 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3684 };
3685
3686 #else
3687
3688 #include <wx/evtloop.h>
3689
3690 #endif
3691
3692
3693
3694 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3695 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3696 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3697 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3698 wxWindowList& list = self->GetChildren();
3699 return wxPy_ConvertList(&list);
3700 }
3701 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3702 #if wxUSE_HOTKEY
3703 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3704 #else
3705 return false;
3706 #endif
3707 }
3708 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3709
3710
3711
3712 return false;
3713
3714 }
3715 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3716 return wxPyGetWinHandle(self);
3717 }
3718 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3719 self->AssociateHandle((WXWidget)handle);
3720 }
3721
3722 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3723 return wxWindow::FindWindowById(id, parent);
3724 }
3725
3726 wxWindow* wxFindWindowByName( const wxString& name,
3727 const wxWindow *parent = NULL ) {
3728 return wxWindow::FindWindowByName(name, parent);
3729 }
3730
3731 wxWindow* wxFindWindowByLabel( const wxString& label,
3732 const wxWindow *parent = NULL ) {
3733 return wxWindow::FindWindowByLabel(label, parent);
3734 }
3735
3736
3737 #ifdef __WXMSW__
3738 #include <wx/msw/private.h> // to get wxGetWindowId
3739 #endif
3740
3741
3742 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3743 #ifdef __WXMSW__
3744 WXHWND hWnd = (WXHWND)_hWnd;
3745 long id = wxGetWindowId(hWnd);
3746 wxWindow* win = new wxWindow;
3747 if (parent)
3748 parent->AddChild(win);
3749 win->SetEventHandler(win);
3750 win->SetHWND(hWnd);
3751 win->SetId(id);
3752 win->SubclassWin(hWnd);
3753 win->AdoptAttributesFromHWND();
3754 win->SetupColours();
3755 return win;
3756 #else
3757 wxPyRaiseNotImplemented();
3758 return NULL;
3759 #endif
3760 }
3761
3762
3763 PyObject* GetTopLevelWindows() {
3764 return wxPy_ConvertList(&wxTopLevelWindows);
3765 }
3766
3767
3768 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3769 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3771
3772 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3773
3774
3775 SWIGINTERNINLINE int
3776 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3777 {
3778 unsigned long v;
3779 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3780 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3781 return res;
3782 }
3783
3784 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3785 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3786 wxMenuItemList& list = self->GetMenuItems();
3787 return wxPy_ConvertList(&list);
3788 }
3789 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3790 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3791 static const wxString wxPyControlNameStr(wxControlNameStr);
3792 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3793 if (clientData) {
3794 wxPyClientData* data = new wxPyClientData(clientData);
3795 return self->Append(item, data);
3796 } else
3797 return self->Append(item);
3798 }
3799 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3800 if (clientData) {
3801 wxPyClientData* data = new wxPyClientData(clientData);
3802 return self->Insert(item, pos, data);
3803 } else
3804 return self->Insert(item, pos);
3805 }
3806 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3807 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3808 if (data) {
3809 Py_INCREF(data->m_obj);
3810 return data->m_obj;
3811 } else {
3812 Py_INCREF(Py_None);
3813 return Py_None;
3814 }
3815 }
3816 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
3817 wxPyClientData* data = new wxPyClientData(clientData);
3818 self->SetClientObject(n, data);
3819 }
3820
3821
3822 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3823 wxPyUserData* data = NULL;
3824 if ( userData ) {
3825 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3826 data = new wxPyUserData(userData);
3827 wxPyEndBlockThreads(blocked);
3828 }
3829 return new wxSizerItem(window, proportion, flag, border, data);
3830 }
3831 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3832 wxPyUserData* data = NULL;
3833 if ( userData ) {
3834 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3835 data = new wxPyUserData(userData);
3836 wxPyEndBlockThreads(blocked);
3837 }
3838 return new wxSizerItem(width, height, proportion, flag, border, data);
3839 }
3840 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3841 wxPyUserData* data = NULL;
3842 if ( userData ) {
3843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3844 data = new wxPyUserData(userData);
3845 wxPyEndBlockThreads(blocked);
3846 }
3847 return new wxSizerItem(sizer, proportion, flag, border, data);
3848 }
3849
3850 #include <float.h>
3851
3852
3853 SWIGINTERN int
3854 SWIG_AsVal_float (PyObject * obj, float *val)
3855 {
3856 double v;
3857 int res = SWIG_AsVal_double (obj, &v);
3858 if (SWIG_IsOK(res)) {
3859 if ((v < -FLT_MAX || v > FLT_MAX)) {
3860 return SWIG_OverflowError;
3861 } else {
3862 if (val) *val = static_cast< float >(v);
3863 }
3864 }
3865 return res;
3866 }
3867
3868
3869 SWIGINTERNINLINE PyObject *
3870 SWIG_From_float (float value)
3871 {
3872 return SWIG_From_double (value);
3873 }
3874
3875 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3876 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3877 if (data) {
3878 Py_INCREF(data->m_obj);
3879 return data->m_obj;
3880 } else {
3881 Py_INCREF(Py_None);
3882 return Py_None;
3883 }
3884 }
3885 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3886 wxPyUserData* data = NULL;
3887 if ( userData ) {
3888 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3889 data = new wxPyUserData(userData);
3890 wxPyEndBlockThreads(blocked);
3891 }
3892 self->SetUserData(data);
3893 }
3894
3895 // Figure out the type of the sizer item
3896
3897 struct wxPySizerItemInfo {
3898 wxPySizerItemInfo()
3899 : window(NULL), sizer(NULL), gotSize(false),
3900 size(wxDefaultSize), gotPos(false), pos(-1)
3901 {}
3902
3903 wxWindow* window;
3904 wxSizer* sizer;
3905 bool gotSize;
3906 wxSize size;
3907 bool gotPos;
3908 int pos;
3909 };
3910
3911 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
3912
3913 wxPySizerItemInfo info;
3914 wxSize size;
3915 wxSize* sizePtr = &size;
3916
3917 // Find out what the type of the item is
3918 // try wxWindow
3919 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
3920 PyErr_Clear();
3921 info.window = NULL;
3922
3923 // try wxSizer
3924 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
3925 PyErr_Clear();
3926 info.sizer = NULL;
3927
3928 // try wxSize or (w,h)
3929 if ( checkSize && wxSize_helper(item, &sizePtr)) {
3930 info.size = *sizePtr;
3931 info.gotSize = true;
3932 }
3933
3934 // or a single int
3935 if (checkIdx && PyInt_Check(item)) {
3936 info.pos = PyInt_AsLong(item);
3937 info.gotPos = true;
3938 }
3939 }
3940 }
3941
3942 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
3943 // no expected type, figure out what kind of error message to generate
3944 if ( !checkSize && !checkIdx )
3945 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
3946 else if ( checkSize && !checkIdx )
3947 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
3948 else if ( !checkSize && checkIdx)
3949 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
3950 else
3951 // can this one happen?
3952 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
3953 }
3954
3955 return info;
3956 }
3957
3958 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3959 if (!self->GetClientObject())
3960 self->SetClientObject(new wxPyOORClientData(_self));
3961 }
3962 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3963
3964 wxPyUserData* data = NULL;
3965 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3966 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3967 if ( userData && (info.window || info.sizer || info.gotSize) )
3968 data = new wxPyUserData(userData);
3969 if ( info.sizer )
3970 PyObject_SetAttrString(item,"thisown",Py_False);
3971 wxPyEndBlockThreads(blocked);
3972
3973 // Now call the real Add method if a valid item type was found
3974 if ( info.window )
3975 return self->Add(info.window, proportion, flag, border, data);
3976 else if ( info.sizer )
3977 return self->Add(info.sizer, proportion, flag, border, data);
3978 else if (info.gotSize)
3979 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3980 proportion, flag, border, data);
3981 else
3982 return NULL;
3983 }
3984 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3985
3986 wxPyUserData* data = NULL;
3987 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3988 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3989 if ( userData && (info.window || info.sizer || info.gotSize) )
3990 data = new wxPyUserData(userData);
3991 if ( info.sizer )
3992 PyObject_SetAttrString(item,"thisown",Py_False);
3993 wxPyEndBlockThreads(blocked);
3994
3995 // Now call the real Insert method if a valid item type was found
3996 if ( info.window )
3997 return self->Insert(before, info.window, proportion, flag, border, data);
3998 else if ( info.sizer )
3999 return self->Insert(before, info.sizer, proportion, flag, border, data);
4000 else if (info.gotSize)
4001 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4002 proportion, flag, border, data);
4003 else
4004 return NULL;
4005 }
4006 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4007
4008 wxPyUserData* data = NULL;
4009 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4010 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4011 if ( userData && (info.window || info.sizer || info.gotSize) )
4012 data = new wxPyUserData(userData);
4013 if ( info.sizer )
4014 PyObject_SetAttrString(item,"thisown",Py_False);
4015 wxPyEndBlockThreads(blocked);
4016
4017 // Now call the real Prepend method if a valid item type was found
4018 if ( info.window )
4019 return self->Prepend(info.window, proportion, flag, border, data);
4020 else if ( info.sizer )
4021 return self->Prepend(info.sizer, proportion, flag, border, data);
4022 else if (info.gotSize)
4023 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4024 proportion, flag, border, data);
4025 else
4026 return NULL;
4027 }
4028 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4029 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4030 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4031 wxPyEndBlockThreads(blocked);
4032 if ( info.window )
4033 return self->Remove(info.window);
4034 else if ( info.sizer )
4035 return self->Remove(info.sizer);
4036 else if ( info.gotPos )
4037 return self->Remove(info.pos);
4038 else
4039 return false;
4040 }
4041 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4042 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4043 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4044 wxPyEndBlockThreads(blocked);
4045 if ( info.window )
4046 return self->Detach(info.window);
4047 else if ( info.sizer )
4048 return self->Detach(info.sizer);
4049 else if ( info.gotPos )
4050 return self->Detach(info.pos);
4051 else
4052 return false;
4053 }
4054 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4055 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4056 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4057 wxPyEndBlockThreads(blocked);
4058 if ( info.window )
4059 return self->GetItem(info.window);
4060 else if ( info.sizer )
4061 return self->GetItem(info.sizer);
4062 else if ( info.gotPos )
4063 return self->GetItem(info.pos);
4064 else
4065 return NULL;
4066 }
4067 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4068 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4069 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4070 wxPyEndBlockThreads(blocked);
4071 if ( info.window )
4072 self->SetItemMinSize(info.window, size);
4073 else if ( info.sizer )
4074 self->SetItemMinSize(info.sizer, size);
4075 else if ( info.gotPos )
4076 self->SetItemMinSize(info.pos, size);
4077 }
4078 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4079 wxSizerItemList& list = self->GetChildren();
4080 return wxPy_ConvertList(&list);
4081 }
4082 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4083 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4084 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4085 wxPyEndBlockThreads(blocked);
4086 if ( info.window )
4087 return self->Show(info.window, show, recursive);
4088 else if ( info.sizer )
4089 return self->Show(info.sizer, show, recursive);
4090 else if ( info.gotPos )
4091 return self->Show(info.pos, show);
4092 else
4093 return false;
4094 }
4095 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4096 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4097 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4098 wxPyEndBlockThreads(blocked);
4099 if ( info.window )
4100 return self->IsShown(info.window);
4101 else if ( info.sizer )
4102 return self->IsShown(info.sizer);
4103 else if ( info.gotPos )
4104 return self->IsShown(info.pos);
4105 else
4106 return false;
4107 }
4108
4109 // See pyclasses.h
4110 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4111 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4112 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4113
4114
4115
4116
4117 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4118 {
4119 if (source == Py_None) {
4120 **obj = wxGBPosition(-1,-1);
4121 return true;
4122 }
4123 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4124 }
4125
4126 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4127 {
4128 if (source == Py_None) {
4129 **obj = wxGBSpan(-1,-1);
4130 return true;
4131 }
4132 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4133 }
4134
4135
4136 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4137 self->SetRow(row);
4138 self->SetCol(col);
4139 }
4140 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4141 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4142 PyObject* tup = PyTuple_New(2);
4143 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4144 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4145 wxPyEndBlockThreads(blocked);
4146 return tup;
4147 }
4148 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4149 self->SetRowspan(rowspan);
4150 self->SetColspan(colspan);
4151 }
4152 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4153 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4154 PyObject* tup = PyTuple_New(2);
4155 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4156 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4157 wxPyEndBlockThreads(blocked);
4158 return tup;
4159 }
4160 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4161 wxPyUserData* data = NULL;
4162 if ( userData ) {
4163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4164 data = new wxPyUserData(userData);
4165 wxPyEndBlockThreads(blocked);
4166 }
4167 return new wxGBSizerItem(window, pos, span, flag, border, data);
4168 }
4169 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4170 wxPyUserData* data = NULL;
4171 if ( userData ) {
4172 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4173 data = new wxPyUserData(userData);
4174 wxPyEndBlockThreads(blocked);
4175 }
4176 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4177 }
4178 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4179 wxPyUserData* data = NULL;
4180 if ( userData ) {
4181 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4182 data = new wxPyUserData(userData);
4183 wxPyEndBlockThreads(blocked);
4184 }
4185 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4186 }
4187 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4188 int row, col;
4189 self->GetEndPos(row, col);
4190 return wxGBPosition(row, col);
4191 }
4192 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4193
4194 wxPyUserData* data = NULL;
4195 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4196 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4197 if ( userData && (info.window || info.sizer || info.gotSize) )
4198 data = new wxPyUserData(userData);
4199 if ( info.sizer )
4200 PyObject_SetAttrString(item,"thisown",Py_False);
4201 wxPyEndBlockThreads(blocked);
4202
4203 // Now call the real Add method if a valid item type was found
4204 if ( info.window )
4205 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4206 else if ( info.sizer )
4207 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4208 else if (info.gotSize)
4209 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4210 pos, span, flag, border, data);
4211 return NULL;
4212 }
4213
4214
4215 #ifdef __cplusplus
4216 extern "C" {
4217 #endif
4218 SWIGINTERN int EmptyString_set(PyObject *) {
4219 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4220 return 1;
4221 }
4222
4223
4224 SWIGINTERN PyObject *EmptyString_get(void) {
4225 PyObject *pyobj = 0;
4226
4227 {
4228 #if wxUSE_UNICODE
4229 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4230 #else
4231 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4232 #endif
4233 }
4234 return pyobj;
4235 }
4236
4237
4238 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4239 PyObject *resultobj = 0;
4240 wxObject *arg1 = (wxObject *) 0 ;
4241 wxString result;
4242 void *argp1 = 0 ;
4243 int res1 = 0 ;
4244 PyObject *swig_obj[1] ;
4245
4246 if (!args) SWIG_fail;
4247 swig_obj[0] = args;
4248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4249 if (!SWIG_IsOK(res1)) {
4250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4251 }
4252 arg1 = reinterpret_cast< wxObject * >(argp1);
4253 {
4254 PyThreadState* __tstate = wxPyBeginAllowThreads();
4255 result = wxObject_GetClassName(arg1);
4256 wxPyEndAllowThreads(__tstate);
4257 if (PyErr_Occurred()) SWIG_fail;
4258 }
4259 {
4260 #if wxUSE_UNICODE
4261 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4262 #else
4263 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4264 #endif
4265 }
4266 return resultobj;
4267 fail:
4268 return NULL;
4269 }
4270
4271
4272 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4273 PyObject *resultobj = 0;
4274 wxObject *arg1 = (wxObject *) 0 ;
4275 void *argp1 = 0 ;
4276 int res1 = 0 ;
4277 PyObject *swig_obj[1] ;
4278
4279 if (!args) SWIG_fail;
4280 swig_obj[0] = args;
4281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4282 if (!SWIG_IsOK(res1)) {
4283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4284 }
4285 arg1 = reinterpret_cast< wxObject * >(argp1);
4286 {
4287 PyThreadState* __tstate = wxPyBeginAllowThreads();
4288 wxObject_Destroy(arg1);
4289 wxPyEndAllowThreads(__tstate);
4290 if (PyErr_Occurred()) SWIG_fail;
4291 }
4292 resultobj = SWIG_Py_Void();
4293 return resultobj;
4294 fail:
4295 return NULL;
4296 }
4297
4298
4299 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4300 PyObject *obj;
4301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4302 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4303 return SWIG_Py_Void();
4304 }
4305
4306 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4307 PyObject *resultobj = 0;
4308 wxSize *arg1 = (wxSize *) 0 ;
4309 int arg2 ;
4310 void *argp1 = 0 ;
4311 int res1 = 0 ;
4312 int val2 ;
4313 int ecode2 = 0 ;
4314 PyObject *swig_obj[2] ;
4315
4316 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4317 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4318 if (!SWIG_IsOK(res1)) {
4319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4320 }
4321 arg1 = reinterpret_cast< wxSize * >(argp1);
4322 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4323 if (!SWIG_IsOK(ecode2)) {
4324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4325 }
4326 arg2 = static_cast< int >(val2);
4327 if (arg1) (arg1)->x = arg2;
4328
4329 resultobj = SWIG_Py_Void();
4330 return resultobj;
4331 fail:
4332 return NULL;
4333 }
4334
4335
4336 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4337 PyObject *resultobj = 0;
4338 wxSize *arg1 = (wxSize *) 0 ;
4339 int result;
4340 void *argp1 = 0 ;
4341 int res1 = 0 ;
4342 PyObject *swig_obj[1] ;
4343
4344 if (!args) SWIG_fail;
4345 swig_obj[0] = args;
4346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4347 if (!SWIG_IsOK(res1)) {
4348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4349 }
4350 arg1 = reinterpret_cast< wxSize * >(argp1);
4351 result = (int) ((arg1)->x);
4352 resultobj = SWIG_From_int(static_cast< int >(result));
4353 return resultobj;
4354 fail:
4355 return NULL;
4356 }
4357
4358
4359 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4360 PyObject *resultobj = 0;
4361 wxSize *arg1 = (wxSize *) 0 ;
4362 int arg2 ;
4363 void *argp1 = 0 ;
4364 int res1 = 0 ;
4365 int val2 ;
4366 int ecode2 = 0 ;
4367 PyObject *swig_obj[2] ;
4368
4369 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4371 if (!SWIG_IsOK(res1)) {
4372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4373 }
4374 arg1 = reinterpret_cast< wxSize * >(argp1);
4375 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4376 if (!SWIG_IsOK(ecode2)) {
4377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4378 }
4379 arg2 = static_cast< int >(val2);
4380 if (arg1) (arg1)->y = arg2;
4381
4382 resultobj = SWIG_Py_Void();
4383 return resultobj;
4384 fail:
4385 return NULL;
4386 }
4387
4388
4389 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4390 PyObject *resultobj = 0;
4391 wxSize *arg1 = (wxSize *) 0 ;
4392 int result;
4393 void *argp1 = 0 ;
4394 int res1 = 0 ;
4395 PyObject *swig_obj[1] ;
4396
4397 if (!args) SWIG_fail;
4398 swig_obj[0] = args;
4399 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4400 if (!SWIG_IsOK(res1)) {
4401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4402 }
4403 arg1 = reinterpret_cast< wxSize * >(argp1);
4404 result = (int) ((arg1)->y);
4405 resultobj = SWIG_From_int(static_cast< int >(result));
4406 return resultobj;
4407 fail:
4408 return NULL;
4409 }
4410
4411
4412 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4413 PyObject *resultobj = 0;
4414 int arg1 = (int) 0 ;
4415 int arg2 = (int) 0 ;
4416 wxSize *result = 0 ;
4417 int val1 ;
4418 int ecode1 = 0 ;
4419 int val2 ;
4420 int ecode2 = 0 ;
4421 PyObject * obj0 = 0 ;
4422 PyObject * obj1 = 0 ;
4423 char * kwnames[] = {
4424 (char *) "w",(char *) "h", NULL
4425 };
4426
4427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4428 if (obj0) {
4429 ecode1 = SWIG_AsVal_int(obj0, &val1);
4430 if (!SWIG_IsOK(ecode1)) {
4431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4432 }
4433 arg1 = static_cast< int >(val1);
4434 }
4435 if (obj1) {
4436 ecode2 = SWIG_AsVal_int(obj1, &val2);
4437 if (!SWIG_IsOK(ecode2)) {
4438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4439 }
4440 arg2 = static_cast< int >(val2);
4441 }
4442 {
4443 PyThreadState* __tstate = wxPyBeginAllowThreads();
4444 result = (wxSize *)new wxSize(arg1,arg2);
4445 wxPyEndAllowThreads(__tstate);
4446 if (PyErr_Occurred()) SWIG_fail;
4447 }
4448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4449 return resultobj;
4450 fail:
4451 return NULL;
4452 }
4453
4454
4455 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4456 PyObject *resultobj = 0;
4457 wxSize *arg1 = (wxSize *) 0 ;
4458 void *argp1 = 0 ;
4459 int res1 = 0 ;
4460 PyObject *swig_obj[1] ;
4461
4462 if (!args) SWIG_fail;
4463 swig_obj[0] = args;
4464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4465 if (!SWIG_IsOK(res1)) {
4466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4467 }
4468 arg1 = reinterpret_cast< wxSize * >(argp1);
4469 {
4470 PyThreadState* __tstate = wxPyBeginAllowThreads();
4471 delete arg1;
4472
4473 wxPyEndAllowThreads(__tstate);
4474 if (PyErr_Occurred()) SWIG_fail;
4475 }
4476 resultobj = SWIG_Py_Void();
4477 return resultobj;
4478 fail:
4479 return NULL;
4480 }
4481
4482
4483 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4484 PyObject *resultobj = 0;
4485 wxSize *arg1 = (wxSize *) 0 ;
4486 wxSize *arg2 = 0 ;
4487 bool result;
4488 void *argp1 = 0 ;
4489 int res1 = 0 ;
4490 wxSize temp2 ;
4491 PyObject * obj0 = 0 ;
4492 PyObject * obj1 = 0 ;
4493 char * kwnames[] = {
4494 (char *) "self",(char *) "sz", NULL
4495 };
4496
4497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4499 if (!SWIG_IsOK(res1)) {
4500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4501 }
4502 arg1 = reinterpret_cast< wxSize * >(argp1);
4503 {
4504 arg2 = &temp2;
4505 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4506 }
4507 {
4508 PyThreadState* __tstate = wxPyBeginAllowThreads();
4509 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
4510 wxPyEndAllowThreads(__tstate);
4511 if (PyErr_Occurred()) SWIG_fail;
4512 }
4513 {
4514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4515 }
4516 return resultobj;
4517 fail:
4518 return NULL;
4519 }
4520
4521
4522 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4523 PyObject *resultobj = 0;
4524 wxSize *arg1 = (wxSize *) 0 ;
4525 wxSize *arg2 = 0 ;
4526 bool result;
4527 void *argp1 = 0 ;
4528 int res1 = 0 ;
4529 wxSize temp2 ;
4530 PyObject * obj0 = 0 ;
4531 PyObject * obj1 = 0 ;
4532 char * kwnames[] = {
4533 (char *) "self",(char *) "sz", NULL
4534 };
4535
4536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4538 if (!SWIG_IsOK(res1)) {
4539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4540 }
4541 arg1 = reinterpret_cast< wxSize * >(argp1);
4542 {
4543 arg2 = &temp2;
4544 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4545 }
4546 {
4547 PyThreadState* __tstate = wxPyBeginAllowThreads();
4548 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
4549 wxPyEndAllowThreads(__tstate);
4550 if (PyErr_Occurred()) SWIG_fail;
4551 }
4552 {
4553 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4562 PyObject *resultobj = 0;
4563 wxSize *arg1 = (wxSize *) 0 ;
4564 wxSize *arg2 = 0 ;
4565 wxSize result;
4566 void *argp1 = 0 ;
4567 int res1 = 0 ;
4568 wxSize temp2 ;
4569 PyObject * obj0 = 0 ;
4570 PyObject * obj1 = 0 ;
4571 char * kwnames[] = {
4572 (char *) "self",(char *) "sz", NULL
4573 };
4574
4575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4577 if (!SWIG_IsOK(res1)) {
4578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4579 }
4580 arg1 = reinterpret_cast< wxSize * >(argp1);
4581 {
4582 arg2 = &temp2;
4583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4584 }
4585 {
4586 PyThreadState* __tstate = wxPyBeginAllowThreads();
4587 result = (arg1)->operator +((wxSize const &)*arg2);
4588 wxPyEndAllowThreads(__tstate);
4589 if (PyErr_Occurred()) SWIG_fail;
4590 }
4591 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj = 0;
4600 wxSize *arg1 = (wxSize *) 0 ;
4601 wxSize *arg2 = 0 ;
4602 wxSize result;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 wxSize temp2 ;
4606 PyObject * obj0 = 0 ;
4607 PyObject * obj1 = 0 ;
4608 char * kwnames[] = {
4609 (char *) "self",(char *) "sz", NULL
4610 };
4611
4612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4614 if (!SWIG_IsOK(res1)) {
4615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4616 }
4617 arg1 = reinterpret_cast< wxSize * >(argp1);
4618 {
4619 arg2 = &temp2;
4620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4621 }
4622 {
4623 PyThreadState* __tstate = wxPyBeginAllowThreads();
4624 result = (arg1)->operator -((wxSize const &)*arg2);
4625 wxPyEndAllowThreads(__tstate);
4626 if (PyErr_Occurred()) SWIG_fail;
4627 }
4628 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4629 return resultobj;
4630 fail:
4631 return NULL;
4632 }
4633
4634
4635 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4636 PyObject *resultobj = 0;
4637 wxSize *arg1 = (wxSize *) 0 ;
4638 wxSize *arg2 = 0 ;
4639 void *argp1 = 0 ;
4640 int res1 = 0 ;
4641 wxSize temp2 ;
4642 PyObject * obj0 = 0 ;
4643 PyObject * obj1 = 0 ;
4644 char * kwnames[] = {
4645 (char *) "self",(char *) "sz", NULL
4646 };
4647
4648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4650 if (!SWIG_IsOK(res1)) {
4651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4652 }
4653 arg1 = reinterpret_cast< wxSize * >(argp1);
4654 {
4655 arg2 = &temp2;
4656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4657 }
4658 {
4659 PyThreadState* __tstate = wxPyBeginAllowThreads();
4660 (arg1)->IncTo((wxSize const &)*arg2);
4661 wxPyEndAllowThreads(__tstate);
4662 if (PyErr_Occurred()) SWIG_fail;
4663 }
4664 resultobj = SWIG_Py_Void();
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = 0;
4673 wxSize *arg1 = (wxSize *) 0 ;
4674 wxSize *arg2 = 0 ;
4675 void *argp1 = 0 ;
4676 int res1 = 0 ;
4677 wxSize temp2 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "self",(char *) "sz", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4688 }
4689 arg1 = reinterpret_cast< wxSize * >(argp1);
4690 {
4691 arg2 = &temp2;
4692 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4693 }
4694 {
4695 PyThreadState* __tstate = wxPyBeginAllowThreads();
4696 (arg1)->DecTo((wxSize const &)*arg2);
4697 wxPyEndAllowThreads(__tstate);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 resultobj = SWIG_Py_Void();
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
4707 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4708 PyObject *resultobj = 0;
4709 wxSize *arg1 = (wxSize *) 0 ;
4710 int arg2 ;
4711 int arg3 ;
4712 void *argp1 = 0 ;
4713 int res1 = 0 ;
4714 int val2 ;
4715 int ecode2 = 0 ;
4716 int val3 ;
4717 int ecode3 = 0 ;
4718 PyObject * obj0 = 0 ;
4719 PyObject * obj1 = 0 ;
4720 PyObject * obj2 = 0 ;
4721 char * kwnames[] = {
4722 (char *) "self",(char *) "w",(char *) "h", NULL
4723 };
4724
4725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4727 if (!SWIG_IsOK(res1)) {
4728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4729 }
4730 arg1 = reinterpret_cast< wxSize * >(argp1);
4731 ecode2 = SWIG_AsVal_int(obj1, &val2);
4732 if (!SWIG_IsOK(ecode2)) {
4733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4734 }
4735 arg2 = static_cast< int >(val2);
4736 ecode3 = SWIG_AsVal_int(obj2, &val3);
4737 if (!SWIG_IsOK(ecode3)) {
4738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4739 }
4740 arg3 = static_cast< int >(val3);
4741 {
4742 PyThreadState* __tstate = wxPyBeginAllowThreads();
4743 (arg1)->Set(arg2,arg3);
4744 wxPyEndAllowThreads(__tstate);
4745 if (PyErr_Occurred()) SWIG_fail;
4746 }
4747 resultobj = SWIG_Py_Void();
4748 return resultobj;
4749 fail:
4750 return NULL;
4751 }
4752
4753
4754 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4755 PyObject *resultobj = 0;
4756 wxSize *arg1 = (wxSize *) 0 ;
4757 int arg2 ;
4758 void *argp1 = 0 ;
4759 int res1 = 0 ;
4760 int val2 ;
4761 int ecode2 = 0 ;
4762 PyObject * obj0 = 0 ;
4763 PyObject * obj1 = 0 ;
4764 char * kwnames[] = {
4765 (char *) "self",(char *) "w", NULL
4766 };
4767
4768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4770 if (!SWIG_IsOK(res1)) {
4771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4772 }
4773 arg1 = reinterpret_cast< wxSize * >(argp1);
4774 ecode2 = SWIG_AsVal_int(obj1, &val2);
4775 if (!SWIG_IsOK(ecode2)) {
4776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4777 }
4778 arg2 = static_cast< int >(val2);
4779 {
4780 PyThreadState* __tstate = wxPyBeginAllowThreads();
4781 (arg1)->SetWidth(arg2);
4782 wxPyEndAllowThreads(__tstate);
4783 if (PyErr_Occurred()) SWIG_fail;
4784 }
4785 resultobj = SWIG_Py_Void();
4786 return resultobj;
4787 fail:
4788 return NULL;
4789 }
4790
4791
4792 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4793 PyObject *resultobj = 0;
4794 wxSize *arg1 = (wxSize *) 0 ;
4795 int arg2 ;
4796 void *argp1 = 0 ;
4797 int res1 = 0 ;
4798 int val2 ;
4799 int ecode2 = 0 ;
4800 PyObject * obj0 = 0 ;
4801 PyObject * obj1 = 0 ;
4802 char * kwnames[] = {
4803 (char *) "self",(char *) "h", NULL
4804 };
4805
4806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",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_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4810 }
4811 arg1 = reinterpret_cast< wxSize * >(argp1);
4812 ecode2 = SWIG_AsVal_int(obj1, &val2);
4813 if (!SWIG_IsOK(ecode2)) {
4814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4815 }
4816 arg2 = static_cast< int >(val2);
4817 {
4818 PyThreadState* __tstate = wxPyBeginAllowThreads();
4819 (arg1)->SetHeight(arg2);
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 resultobj = SWIG_Py_Void();
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4831 PyObject *resultobj = 0;
4832 wxSize *arg1 = (wxSize *) 0 ;
4833 int result;
4834 void *argp1 = 0 ;
4835 int res1 = 0 ;
4836 PyObject *swig_obj[1] ;
4837
4838 if (!args) SWIG_fail;
4839 swig_obj[0] = args;
4840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4841 if (!SWIG_IsOK(res1)) {
4842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4843 }
4844 arg1 = reinterpret_cast< wxSize * >(argp1);
4845 {
4846 PyThreadState* __tstate = wxPyBeginAllowThreads();
4847 result = (int)((wxSize const *)arg1)->GetWidth();
4848 wxPyEndAllowThreads(__tstate);
4849 if (PyErr_Occurred()) SWIG_fail;
4850 }
4851 resultobj = SWIG_From_int(static_cast< int >(result));
4852 return resultobj;
4853 fail:
4854 return NULL;
4855 }
4856
4857
4858 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4859 PyObject *resultobj = 0;
4860 wxSize *arg1 = (wxSize *) 0 ;
4861 int result;
4862 void *argp1 = 0 ;
4863 int res1 = 0 ;
4864 PyObject *swig_obj[1] ;
4865
4866 if (!args) SWIG_fail;
4867 swig_obj[0] = args;
4868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4869 if (!SWIG_IsOK(res1)) {
4870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
4871 }
4872 arg1 = reinterpret_cast< wxSize * >(argp1);
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 result = (int)((wxSize const *)arg1)->GetHeight();
4876 wxPyEndAllowThreads(__tstate);
4877 if (PyErr_Occurred()) SWIG_fail;
4878 }
4879 resultobj = SWIG_From_int(static_cast< int >(result));
4880 return resultobj;
4881 fail:
4882 return NULL;
4883 }
4884
4885
4886 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4887 PyObject *resultobj = 0;
4888 wxSize *arg1 = (wxSize *) 0 ;
4889 bool result;
4890 void *argp1 = 0 ;
4891 int res1 = 0 ;
4892 PyObject *swig_obj[1] ;
4893
4894 if (!args) SWIG_fail;
4895 swig_obj[0] = args;
4896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4897 if (!SWIG_IsOK(res1)) {
4898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
4899 }
4900 arg1 = reinterpret_cast< wxSize * >(argp1);
4901 {
4902 PyThreadState* __tstate = wxPyBeginAllowThreads();
4903 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
4904 wxPyEndAllowThreads(__tstate);
4905 if (PyErr_Occurred()) SWIG_fail;
4906 }
4907 {
4908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4909 }
4910 return resultobj;
4911 fail:
4912 return NULL;
4913 }
4914
4915
4916 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4917 PyObject *resultobj = 0;
4918 wxSize *arg1 = (wxSize *) 0 ;
4919 wxSize *arg2 = 0 ;
4920 void *argp1 = 0 ;
4921 int res1 = 0 ;
4922 wxSize temp2 ;
4923 PyObject * obj0 = 0 ;
4924 PyObject * obj1 = 0 ;
4925 char * kwnames[] = {
4926 (char *) "self",(char *) "size", NULL
4927 };
4928
4929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
4930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4931 if (!SWIG_IsOK(res1)) {
4932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
4933 }
4934 arg1 = reinterpret_cast< wxSize * >(argp1);
4935 {
4936 arg2 = &temp2;
4937 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4938 }
4939 {
4940 PyThreadState* __tstate = wxPyBeginAllowThreads();
4941 (arg1)->SetDefaults((wxSize const &)*arg2);
4942 wxPyEndAllowThreads(__tstate);
4943 if (PyErr_Occurred()) SWIG_fail;
4944 }
4945 resultobj = SWIG_Py_Void();
4946 return resultobj;
4947 fail:
4948 return NULL;
4949 }
4950
4951
4952 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4953 PyObject *resultobj = 0;
4954 wxSize *arg1 = (wxSize *) 0 ;
4955 PyObject *result = 0 ;
4956 void *argp1 = 0 ;
4957 int res1 = 0 ;
4958 PyObject *swig_obj[1] ;
4959
4960 if (!args) SWIG_fail;
4961 swig_obj[0] = args;
4962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4963 if (!SWIG_IsOK(res1)) {
4964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
4965 }
4966 arg1 = reinterpret_cast< wxSize * >(argp1);
4967 {
4968 PyThreadState* __tstate = wxPyBeginAllowThreads();
4969 result = (PyObject *)wxSize_Get(arg1);
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 resultobj = result;
4974 return resultobj;
4975 fail:
4976 return NULL;
4977 }
4978
4979
4980 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4981 PyObject *obj;
4982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4983 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
4984 return SWIG_Py_Void();
4985 }
4986
4987 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4988 return SWIG_Python_InitShadowInstance(args);
4989 }
4990
4991 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4992 PyObject *resultobj = 0;
4993 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4994 double arg2 ;
4995 void *argp1 = 0 ;
4996 int res1 = 0 ;
4997 double val2 ;
4998 int ecode2 = 0 ;
4999 PyObject *swig_obj[2] ;
5000
5001 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5003 if (!SWIG_IsOK(res1)) {
5004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5005 }
5006 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5007 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5008 if (!SWIG_IsOK(ecode2)) {
5009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5010 }
5011 arg2 = static_cast< double >(val2);
5012 if (arg1) (arg1)->x = arg2;
5013
5014 resultobj = SWIG_Py_Void();
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5022 PyObject *resultobj = 0;
5023 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5024 double result;
5025 void *argp1 = 0 ;
5026 int res1 = 0 ;
5027 PyObject *swig_obj[1] ;
5028
5029 if (!args) SWIG_fail;
5030 swig_obj[0] = args;
5031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5032 if (!SWIG_IsOK(res1)) {
5033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5034 }
5035 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5036 result = (double) ((arg1)->x);
5037 resultobj = SWIG_From_double(static_cast< double >(result));
5038 return resultobj;
5039 fail:
5040 return NULL;
5041 }
5042
5043
5044 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5045 PyObject *resultobj = 0;
5046 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5047 double arg2 ;
5048 void *argp1 = 0 ;
5049 int res1 = 0 ;
5050 double val2 ;
5051 int ecode2 = 0 ;
5052 PyObject *swig_obj[2] ;
5053
5054 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5056 if (!SWIG_IsOK(res1)) {
5057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5058 }
5059 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5060 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5061 if (!SWIG_IsOK(ecode2)) {
5062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5063 }
5064 arg2 = static_cast< double >(val2);
5065 if (arg1) (arg1)->y = arg2;
5066
5067 resultobj = SWIG_Py_Void();
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5075 PyObject *resultobj = 0;
5076 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5077 double result;
5078 void *argp1 = 0 ;
5079 int res1 = 0 ;
5080 PyObject *swig_obj[1] ;
5081
5082 if (!args) SWIG_fail;
5083 swig_obj[0] = args;
5084 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5085 if (!SWIG_IsOK(res1)) {
5086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5087 }
5088 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5089 result = (double) ((arg1)->y);
5090 resultobj = SWIG_From_double(static_cast< double >(result));
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5098 PyObject *resultobj = 0;
5099 double arg1 = (double) 0.0 ;
5100 double arg2 = (double) 0.0 ;
5101 wxRealPoint *result = 0 ;
5102 double val1 ;
5103 int ecode1 = 0 ;
5104 double val2 ;
5105 int ecode2 = 0 ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 char * kwnames[] = {
5109 (char *) "x",(char *) "y", NULL
5110 };
5111
5112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5113 if (obj0) {
5114 ecode1 = SWIG_AsVal_double(obj0, &val1);
5115 if (!SWIG_IsOK(ecode1)) {
5116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5117 }
5118 arg1 = static_cast< double >(val1);
5119 }
5120 if (obj1) {
5121 ecode2 = SWIG_AsVal_double(obj1, &val2);
5122 if (!SWIG_IsOK(ecode2)) {
5123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5124 }
5125 arg2 = static_cast< double >(val2);
5126 }
5127 {
5128 PyThreadState* __tstate = wxPyBeginAllowThreads();
5129 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5130 wxPyEndAllowThreads(__tstate);
5131 if (PyErr_Occurred()) SWIG_fail;
5132 }
5133 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5134 return resultobj;
5135 fail:
5136 return NULL;
5137 }
5138
5139
5140 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5141 PyObject *resultobj = 0;
5142 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5143 void *argp1 = 0 ;
5144 int res1 = 0 ;
5145 PyObject *swig_obj[1] ;
5146
5147 if (!args) SWIG_fail;
5148 swig_obj[0] = args;
5149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5150 if (!SWIG_IsOK(res1)) {
5151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5152 }
5153 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5154 {
5155 PyThreadState* __tstate = wxPyBeginAllowThreads();
5156 delete arg1;
5157
5158 wxPyEndAllowThreads(__tstate);
5159 if (PyErr_Occurred()) SWIG_fail;
5160 }
5161 resultobj = SWIG_Py_Void();
5162 return resultobj;
5163 fail:
5164 return NULL;
5165 }
5166
5167
5168 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5169 PyObject *resultobj = 0;
5170 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5171 wxRealPoint *arg2 = 0 ;
5172 bool result;
5173 void *argp1 = 0 ;
5174 int res1 = 0 ;
5175 wxRealPoint temp2 ;
5176 PyObject * obj0 = 0 ;
5177 PyObject * obj1 = 0 ;
5178 char * kwnames[] = {
5179 (char *) "self",(char *) "pt", NULL
5180 };
5181
5182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5184 if (!SWIG_IsOK(res1)) {
5185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5186 }
5187 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5188 {
5189 arg2 = &temp2;
5190 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5191 }
5192 {
5193 PyThreadState* __tstate = wxPyBeginAllowThreads();
5194 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
5195 wxPyEndAllowThreads(__tstate);
5196 if (PyErr_Occurred()) SWIG_fail;
5197 }
5198 {
5199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5200 }
5201 return resultobj;
5202 fail:
5203 return NULL;
5204 }
5205
5206
5207 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5208 PyObject *resultobj = 0;
5209 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5210 wxRealPoint *arg2 = 0 ;
5211 bool result;
5212 void *argp1 = 0 ;
5213 int res1 = 0 ;
5214 wxRealPoint temp2 ;
5215 PyObject * obj0 = 0 ;
5216 PyObject * obj1 = 0 ;
5217 char * kwnames[] = {
5218 (char *) "self",(char *) "pt", NULL
5219 };
5220
5221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5223 if (!SWIG_IsOK(res1)) {
5224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5225 }
5226 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5227 {
5228 arg2 = &temp2;
5229 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5230 }
5231 {
5232 PyThreadState* __tstate = wxPyBeginAllowThreads();
5233 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
5234 wxPyEndAllowThreads(__tstate);
5235 if (PyErr_Occurred()) SWIG_fail;
5236 }
5237 {
5238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5239 }
5240 return resultobj;
5241 fail:
5242 return NULL;
5243 }
5244
5245
5246 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5247 PyObject *resultobj = 0;
5248 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5249 wxRealPoint *arg2 = 0 ;
5250 wxRealPoint result;
5251 void *argp1 = 0 ;
5252 int res1 = 0 ;
5253 wxRealPoint temp2 ;
5254 PyObject * obj0 = 0 ;
5255 PyObject * obj1 = 0 ;
5256 char * kwnames[] = {
5257 (char *) "self",(char *) "pt", NULL
5258 };
5259
5260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5262 if (!SWIG_IsOK(res1)) {
5263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5264 }
5265 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5266 {
5267 arg2 = &temp2;
5268 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5269 }
5270 {
5271 PyThreadState* __tstate = wxPyBeginAllowThreads();
5272 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5273 wxPyEndAllowThreads(__tstate);
5274 if (PyErr_Occurred()) SWIG_fail;
5275 }
5276 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5277 return resultobj;
5278 fail:
5279 return NULL;
5280 }
5281
5282
5283 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5284 PyObject *resultobj = 0;
5285 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5286 wxRealPoint *arg2 = 0 ;
5287 wxRealPoint result;
5288 void *argp1 = 0 ;
5289 int res1 = 0 ;
5290 wxRealPoint temp2 ;
5291 PyObject * obj0 = 0 ;
5292 PyObject * obj1 = 0 ;
5293 char * kwnames[] = {
5294 (char *) "self",(char *) "pt", NULL
5295 };
5296
5297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5299 if (!SWIG_IsOK(res1)) {
5300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5301 }
5302 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5303 {
5304 arg2 = &temp2;
5305 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5306 }
5307 {
5308 PyThreadState* __tstate = wxPyBeginAllowThreads();
5309 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5310 wxPyEndAllowThreads(__tstate);
5311 if (PyErr_Occurred()) SWIG_fail;
5312 }
5313 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5314 return resultobj;
5315 fail:
5316 return NULL;
5317 }
5318
5319
5320 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5321 PyObject *resultobj = 0;
5322 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5323 double arg2 ;
5324 double arg3 ;
5325 void *argp1 = 0 ;
5326 int res1 = 0 ;
5327 double val2 ;
5328 int ecode2 = 0 ;
5329 double val3 ;
5330 int ecode3 = 0 ;
5331 PyObject * obj0 = 0 ;
5332 PyObject * obj1 = 0 ;
5333 PyObject * obj2 = 0 ;
5334 char * kwnames[] = {
5335 (char *) "self",(char *) "x",(char *) "y", NULL
5336 };
5337
5338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5342 }
5343 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5344 ecode2 = SWIG_AsVal_double(obj1, &val2);
5345 if (!SWIG_IsOK(ecode2)) {
5346 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5347 }
5348 arg2 = static_cast< double >(val2);
5349 ecode3 = SWIG_AsVal_double(obj2, &val3);
5350 if (!SWIG_IsOK(ecode3)) {
5351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5352 }
5353 arg3 = static_cast< double >(val3);
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 wxRealPoint_Set(arg1,arg2,arg3);
5357 wxPyEndAllowThreads(__tstate);
5358 if (PyErr_Occurred()) SWIG_fail;
5359 }
5360 resultobj = SWIG_Py_Void();
5361 return resultobj;
5362 fail:
5363 return NULL;
5364 }
5365
5366
5367 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5368 PyObject *resultobj = 0;
5369 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5370 PyObject *result = 0 ;
5371 void *argp1 = 0 ;
5372 int res1 = 0 ;
5373 PyObject *swig_obj[1] ;
5374
5375 if (!args) SWIG_fail;
5376 swig_obj[0] = args;
5377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5378 if (!SWIG_IsOK(res1)) {
5379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5380 }
5381 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5382 {
5383 PyThreadState* __tstate = wxPyBeginAllowThreads();
5384 result = (PyObject *)wxRealPoint_Get(arg1);
5385 wxPyEndAllowThreads(__tstate);
5386 if (PyErr_Occurred()) SWIG_fail;
5387 }
5388 resultobj = result;
5389 return resultobj;
5390 fail:
5391 return NULL;
5392 }
5393
5394
5395 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5396 PyObject *obj;
5397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5398 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5399 return SWIG_Py_Void();
5400 }
5401
5402 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5403 return SWIG_Python_InitShadowInstance(args);
5404 }
5405
5406 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5407 PyObject *resultobj = 0;
5408 wxPoint *arg1 = (wxPoint *) 0 ;
5409 int arg2 ;
5410 void *argp1 = 0 ;
5411 int res1 = 0 ;
5412 int val2 ;
5413 int ecode2 = 0 ;
5414 PyObject *swig_obj[2] ;
5415
5416 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5418 if (!SWIG_IsOK(res1)) {
5419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5420 }
5421 arg1 = reinterpret_cast< wxPoint * >(argp1);
5422 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5423 if (!SWIG_IsOK(ecode2)) {
5424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5425 }
5426 arg2 = static_cast< int >(val2);
5427 if (arg1) (arg1)->x = arg2;
5428
5429 resultobj = SWIG_Py_Void();
5430 return resultobj;
5431 fail:
5432 return NULL;
5433 }
5434
5435
5436 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5437 PyObject *resultobj = 0;
5438 wxPoint *arg1 = (wxPoint *) 0 ;
5439 int result;
5440 void *argp1 = 0 ;
5441 int res1 = 0 ;
5442 PyObject *swig_obj[1] ;
5443
5444 if (!args) SWIG_fail;
5445 swig_obj[0] = args;
5446 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5447 if (!SWIG_IsOK(res1)) {
5448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5449 }
5450 arg1 = reinterpret_cast< wxPoint * >(argp1);
5451 result = (int) ((arg1)->x);
5452 resultobj = SWIG_From_int(static_cast< int >(result));
5453 return resultobj;
5454 fail:
5455 return NULL;
5456 }
5457
5458
5459 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5460 PyObject *resultobj = 0;
5461 wxPoint *arg1 = (wxPoint *) 0 ;
5462 int arg2 ;
5463 void *argp1 = 0 ;
5464 int res1 = 0 ;
5465 int val2 ;
5466 int ecode2 = 0 ;
5467 PyObject *swig_obj[2] ;
5468
5469 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5471 if (!SWIG_IsOK(res1)) {
5472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5473 }
5474 arg1 = reinterpret_cast< wxPoint * >(argp1);
5475 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5476 if (!SWIG_IsOK(ecode2)) {
5477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5478 }
5479 arg2 = static_cast< int >(val2);
5480 if (arg1) (arg1)->y = arg2;
5481
5482 resultobj = SWIG_Py_Void();
5483 return resultobj;
5484 fail:
5485 return NULL;
5486 }
5487
5488
5489 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5490 PyObject *resultobj = 0;
5491 wxPoint *arg1 = (wxPoint *) 0 ;
5492 int result;
5493 void *argp1 = 0 ;
5494 int res1 = 0 ;
5495 PyObject *swig_obj[1] ;
5496
5497 if (!args) SWIG_fail;
5498 swig_obj[0] = args;
5499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5500 if (!SWIG_IsOK(res1)) {
5501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5502 }
5503 arg1 = reinterpret_cast< wxPoint * >(argp1);
5504 result = (int) ((arg1)->y);
5505 resultobj = SWIG_From_int(static_cast< int >(result));
5506 return resultobj;
5507 fail:
5508 return NULL;
5509 }
5510
5511
5512 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5513 PyObject *resultobj = 0;
5514 int arg1 = (int) 0 ;
5515 int arg2 = (int) 0 ;
5516 wxPoint *result = 0 ;
5517 int val1 ;
5518 int ecode1 = 0 ;
5519 int val2 ;
5520 int ecode2 = 0 ;
5521 PyObject * obj0 = 0 ;
5522 PyObject * obj1 = 0 ;
5523 char * kwnames[] = {
5524 (char *) "x",(char *) "y", NULL
5525 };
5526
5527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5528 if (obj0) {
5529 ecode1 = SWIG_AsVal_int(obj0, &val1);
5530 if (!SWIG_IsOK(ecode1)) {
5531 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5532 }
5533 arg1 = static_cast< int >(val1);
5534 }
5535 if (obj1) {
5536 ecode2 = SWIG_AsVal_int(obj1, &val2);
5537 if (!SWIG_IsOK(ecode2)) {
5538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5539 }
5540 arg2 = static_cast< int >(val2);
5541 }
5542 {
5543 PyThreadState* __tstate = wxPyBeginAllowThreads();
5544 result = (wxPoint *)new wxPoint(arg1,arg2);
5545 wxPyEndAllowThreads(__tstate);
5546 if (PyErr_Occurred()) SWIG_fail;
5547 }
5548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 PyObject *resultobj = 0;
5557 wxPoint *arg1 = (wxPoint *) 0 ;
5558 void *argp1 = 0 ;
5559 int res1 = 0 ;
5560 PyObject *swig_obj[1] ;
5561
5562 if (!args) SWIG_fail;
5563 swig_obj[0] = args;
5564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5565 if (!SWIG_IsOK(res1)) {
5566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5567 }
5568 arg1 = reinterpret_cast< wxPoint * >(argp1);
5569 {
5570 PyThreadState* __tstate = wxPyBeginAllowThreads();
5571 delete arg1;
5572
5573 wxPyEndAllowThreads(__tstate);
5574 if (PyErr_Occurred()) SWIG_fail;
5575 }
5576 resultobj = SWIG_Py_Void();
5577 return resultobj;
5578 fail:
5579 return NULL;
5580 }
5581
5582
5583 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5584 PyObject *resultobj = 0;
5585 wxPoint *arg1 = (wxPoint *) 0 ;
5586 wxPoint *arg2 = 0 ;
5587 bool result;
5588 void *argp1 = 0 ;
5589 int res1 = 0 ;
5590 wxPoint temp2 ;
5591 PyObject * obj0 = 0 ;
5592 PyObject * obj1 = 0 ;
5593 char * kwnames[] = {
5594 (char *) "self",(char *) "pt", NULL
5595 };
5596
5597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5599 if (!SWIG_IsOK(res1)) {
5600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5601 }
5602 arg1 = reinterpret_cast< wxPoint * >(argp1);
5603 {
5604 arg2 = &temp2;
5605 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5606 }
5607 {
5608 PyThreadState* __tstate = wxPyBeginAllowThreads();
5609 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
5610 wxPyEndAllowThreads(__tstate);
5611 if (PyErr_Occurred()) SWIG_fail;
5612 }
5613 {
5614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5615 }
5616 return resultobj;
5617 fail:
5618 return NULL;
5619 }
5620
5621
5622 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5623 PyObject *resultobj = 0;
5624 wxPoint *arg1 = (wxPoint *) 0 ;
5625 wxPoint *arg2 = 0 ;
5626 bool result;
5627 void *argp1 = 0 ;
5628 int res1 = 0 ;
5629 wxPoint temp2 ;
5630 PyObject * obj0 = 0 ;
5631 PyObject * obj1 = 0 ;
5632 char * kwnames[] = {
5633 (char *) "self",(char *) "pt", NULL
5634 };
5635
5636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5638 if (!SWIG_IsOK(res1)) {
5639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5640 }
5641 arg1 = reinterpret_cast< wxPoint * >(argp1);
5642 {
5643 arg2 = &temp2;
5644 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5645 }
5646 {
5647 PyThreadState* __tstate = wxPyBeginAllowThreads();
5648 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
5649 wxPyEndAllowThreads(__tstate);
5650 if (PyErr_Occurred()) SWIG_fail;
5651 }
5652 {
5653 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5654 }
5655 return resultobj;
5656 fail:
5657 return NULL;
5658 }
5659
5660
5661 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5662 PyObject *resultobj = 0;
5663 wxPoint *arg1 = (wxPoint *) 0 ;
5664 wxPoint *arg2 = 0 ;
5665 wxPoint result;
5666 void *argp1 = 0 ;
5667 int res1 = 0 ;
5668 wxPoint temp2 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 char * kwnames[] = {
5672 (char *) "self",(char *) "pt", NULL
5673 };
5674
5675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5677 if (!SWIG_IsOK(res1)) {
5678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5679 }
5680 arg1 = reinterpret_cast< wxPoint * >(argp1);
5681 {
5682 arg2 = &temp2;
5683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5684 }
5685 {
5686 PyThreadState* __tstate = wxPyBeginAllowThreads();
5687 result = (arg1)->operator +((wxPoint const &)*arg2);
5688 wxPyEndAllowThreads(__tstate);
5689 if (PyErr_Occurred()) SWIG_fail;
5690 }
5691 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5692 return resultobj;
5693 fail:
5694 return NULL;
5695 }
5696
5697
5698 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5699 PyObject *resultobj = 0;
5700 wxPoint *arg1 = (wxPoint *) 0 ;
5701 wxPoint *arg2 = 0 ;
5702 wxPoint result;
5703 void *argp1 = 0 ;
5704 int res1 = 0 ;
5705 wxPoint temp2 ;
5706 PyObject * obj0 = 0 ;
5707 PyObject * obj1 = 0 ;
5708 char * kwnames[] = {
5709 (char *) "self",(char *) "pt", NULL
5710 };
5711
5712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5714 if (!SWIG_IsOK(res1)) {
5715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5716 }
5717 arg1 = reinterpret_cast< wxPoint * >(argp1);
5718 {
5719 arg2 = &temp2;
5720 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5721 }
5722 {
5723 PyThreadState* __tstate = wxPyBeginAllowThreads();
5724 result = (arg1)->operator -((wxPoint const &)*arg2);
5725 wxPyEndAllowThreads(__tstate);
5726 if (PyErr_Occurred()) SWIG_fail;
5727 }
5728 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5729 return resultobj;
5730 fail:
5731 return NULL;
5732 }
5733
5734
5735 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5736 PyObject *resultobj = 0;
5737 wxPoint *arg1 = (wxPoint *) 0 ;
5738 wxPoint *arg2 = 0 ;
5739 wxPoint *result = 0 ;
5740 void *argp1 = 0 ;
5741 int res1 = 0 ;
5742 wxPoint temp2 ;
5743 PyObject * obj0 = 0 ;
5744 PyObject * obj1 = 0 ;
5745 char * kwnames[] = {
5746 (char *) "self",(char *) "pt", NULL
5747 };
5748
5749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxPoint * >(argp1);
5755 {
5756 arg2 = &temp2;
5757 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5758 }
5759 {
5760 PyThreadState* __tstate = wxPyBeginAllowThreads();
5761 {
5762 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5763 result = (wxPoint *) &_result_ref;
5764 }
5765 wxPyEndAllowThreads(__tstate);
5766 if (PyErr_Occurred()) SWIG_fail;
5767 }
5768 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5769 return resultobj;
5770 fail:
5771 return NULL;
5772 }
5773
5774
5775 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5776 PyObject *resultobj = 0;
5777 wxPoint *arg1 = (wxPoint *) 0 ;
5778 wxPoint *arg2 = 0 ;
5779 wxPoint *result = 0 ;
5780 void *argp1 = 0 ;
5781 int res1 = 0 ;
5782 wxPoint temp2 ;
5783 PyObject * obj0 = 0 ;
5784 PyObject * obj1 = 0 ;
5785 char * kwnames[] = {
5786 (char *) "self",(char *) "pt", NULL
5787 };
5788
5789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5791 if (!SWIG_IsOK(res1)) {
5792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5793 }
5794 arg1 = reinterpret_cast< wxPoint * >(argp1);
5795 {
5796 arg2 = &temp2;
5797 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5798 }
5799 {
5800 PyThreadState* __tstate = wxPyBeginAllowThreads();
5801 {
5802 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5803 result = (wxPoint *) &_result_ref;
5804 }
5805 wxPyEndAllowThreads(__tstate);
5806 if (PyErr_Occurred()) SWIG_fail;
5807 }
5808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5809 return resultobj;
5810 fail:
5811 return NULL;
5812 }
5813
5814
5815 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5816 PyObject *resultobj = 0;
5817 wxPoint *arg1 = (wxPoint *) 0 ;
5818 long arg2 ;
5819 long arg3 ;
5820 void *argp1 = 0 ;
5821 int res1 = 0 ;
5822 long val2 ;
5823 int ecode2 = 0 ;
5824 long val3 ;
5825 int ecode3 = 0 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 PyObject * obj2 = 0 ;
5829 char * kwnames[] = {
5830 (char *) "self",(char *) "x",(char *) "y", NULL
5831 };
5832
5833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5835 if (!SWIG_IsOK(res1)) {
5836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5837 }
5838 arg1 = reinterpret_cast< wxPoint * >(argp1);
5839 ecode2 = SWIG_AsVal_long(obj1, &val2);
5840 if (!SWIG_IsOK(ecode2)) {
5841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5842 }
5843 arg2 = static_cast< long >(val2);
5844 ecode3 = SWIG_AsVal_long(obj2, &val3);
5845 if (!SWIG_IsOK(ecode3)) {
5846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5847 }
5848 arg3 = static_cast< long >(val3);
5849 {
5850 PyThreadState* __tstate = wxPyBeginAllowThreads();
5851 wxPoint_Set(arg1,arg2,arg3);
5852 wxPyEndAllowThreads(__tstate);
5853 if (PyErr_Occurred()) SWIG_fail;
5854 }
5855 resultobj = SWIG_Py_Void();
5856 return resultobj;
5857 fail:
5858 return NULL;
5859 }
5860
5861
5862 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5863 PyObject *resultobj = 0;
5864 wxPoint *arg1 = (wxPoint *) 0 ;
5865 PyObject *result = 0 ;
5866 void *argp1 = 0 ;
5867 int res1 = 0 ;
5868 PyObject *swig_obj[1] ;
5869
5870 if (!args) SWIG_fail;
5871 swig_obj[0] = args;
5872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5873 if (!SWIG_IsOK(res1)) {
5874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5875 }
5876 arg1 = reinterpret_cast< wxPoint * >(argp1);
5877 {
5878 PyThreadState* __tstate = wxPyBeginAllowThreads();
5879 result = (PyObject *)wxPoint_Get(arg1);
5880 wxPyEndAllowThreads(__tstate);
5881 if (PyErr_Occurred()) SWIG_fail;
5882 }
5883 resultobj = result;
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5891 PyObject *obj;
5892 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5893 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
5894 return SWIG_Py_Void();
5895 }
5896
5897 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5898 return SWIG_Python_InitShadowInstance(args);
5899 }
5900
5901 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj = 0;
5903 int arg1 = (int) 0 ;
5904 int arg2 = (int) 0 ;
5905 int arg3 = (int) 0 ;
5906 int arg4 = (int) 0 ;
5907 wxRect *result = 0 ;
5908 int val1 ;
5909 int ecode1 = 0 ;
5910 int val2 ;
5911 int ecode2 = 0 ;
5912 int val3 ;
5913 int ecode3 = 0 ;
5914 int val4 ;
5915 int ecode4 = 0 ;
5916 PyObject * obj0 = 0 ;
5917 PyObject * obj1 = 0 ;
5918 PyObject * obj2 = 0 ;
5919 PyObject * obj3 = 0 ;
5920 char * kwnames[] = {
5921 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
5922 };
5923
5924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5925 if (obj0) {
5926 ecode1 = SWIG_AsVal_int(obj0, &val1);
5927 if (!SWIG_IsOK(ecode1)) {
5928 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
5929 }
5930 arg1 = static_cast< int >(val1);
5931 }
5932 if (obj1) {
5933 ecode2 = SWIG_AsVal_int(obj1, &val2);
5934 if (!SWIG_IsOK(ecode2)) {
5935 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
5936 }
5937 arg2 = static_cast< int >(val2);
5938 }
5939 if (obj2) {
5940 ecode3 = SWIG_AsVal_int(obj2, &val3);
5941 if (!SWIG_IsOK(ecode3)) {
5942 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
5943 }
5944 arg3 = static_cast< int >(val3);
5945 }
5946 if (obj3) {
5947 ecode4 = SWIG_AsVal_int(obj3, &val4);
5948 if (!SWIG_IsOK(ecode4)) {
5949 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
5950 }
5951 arg4 = static_cast< int >(val4);
5952 }
5953 {
5954 PyThreadState* __tstate = wxPyBeginAllowThreads();
5955 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
5956 wxPyEndAllowThreads(__tstate);
5957 if (PyErr_Occurred()) SWIG_fail;
5958 }
5959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj = 0;
5968 wxPoint *arg1 = 0 ;
5969 wxPoint *arg2 = 0 ;
5970 wxRect *result = 0 ;
5971 wxPoint temp1 ;
5972 wxPoint temp2 ;
5973 PyObject * obj0 = 0 ;
5974 PyObject * obj1 = 0 ;
5975 char * kwnames[] = {
5976 (char *) "topLeft",(char *) "bottomRight", NULL
5977 };
5978
5979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
5980 {
5981 arg1 = &temp1;
5982 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
5983 }
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 PyThreadState* __tstate = wxPyBeginAllowThreads();
5990 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
5991 wxPyEndAllowThreads(__tstate);
5992 if (PyErr_Occurred()) SWIG_fail;
5993 }
5994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
5995 return resultobj;
5996 fail:
5997 return NULL;
5998 }
5999
6000
6001 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6002 PyObject *resultobj = 0;
6003 wxPoint *arg1 = 0 ;
6004 wxSize *arg2 = 0 ;
6005 wxRect *result = 0 ;
6006 wxPoint temp1 ;
6007 wxSize temp2 ;
6008 PyObject * obj0 = 0 ;
6009 PyObject * obj1 = 0 ;
6010 char * kwnames[] = {
6011 (char *) "pos",(char *) "size", NULL
6012 };
6013
6014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6015 {
6016 arg1 = &temp1;
6017 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6018 }
6019 {
6020 arg2 = &temp2;
6021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6022 }
6023 {
6024 PyThreadState* __tstate = wxPyBeginAllowThreads();
6025 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6026 wxPyEndAllowThreads(__tstate);
6027 if (PyErr_Occurred()) SWIG_fail;
6028 }
6029 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6030 return resultobj;
6031 fail:
6032 return NULL;
6033 }
6034
6035
6036 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6037 PyObject *resultobj = 0;
6038 wxSize *arg1 = 0 ;
6039 wxRect *result = 0 ;
6040 wxSize temp1 ;
6041 PyObject * obj0 = 0 ;
6042 char * kwnames[] = {
6043 (char *) "size", NULL
6044 };
6045
6046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6047 {
6048 arg1 = &temp1;
6049 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6050 }
6051 {
6052 PyThreadState* __tstate = wxPyBeginAllowThreads();
6053 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6054 wxPyEndAllowThreads(__tstate);
6055 if (PyErr_Occurred()) SWIG_fail;
6056 }
6057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6058 return resultobj;
6059 fail:
6060 return NULL;
6061 }
6062
6063
6064 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6065 PyObject *resultobj = 0;
6066 wxRect *arg1 = (wxRect *) 0 ;
6067 void *argp1 = 0 ;
6068 int res1 = 0 ;
6069 PyObject *swig_obj[1] ;
6070
6071 if (!args) SWIG_fail;
6072 swig_obj[0] = args;
6073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6074 if (!SWIG_IsOK(res1)) {
6075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6076 }
6077 arg1 = reinterpret_cast< wxRect * >(argp1);
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 delete arg1;
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 resultobj = SWIG_Py_Void();
6086 return resultobj;
6087 fail:
6088 return NULL;
6089 }
6090
6091
6092 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6093 PyObject *resultobj = 0;
6094 wxRect *arg1 = (wxRect *) 0 ;
6095 int result;
6096 void *argp1 = 0 ;
6097 int res1 = 0 ;
6098 PyObject *swig_obj[1] ;
6099
6100 if (!args) SWIG_fail;
6101 swig_obj[0] = args;
6102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6105 }
6106 arg1 = reinterpret_cast< wxRect * >(argp1);
6107 {
6108 PyThreadState* __tstate = wxPyBeginAllowThreads();
6109 result = (int)((wxRect const *)arg1)->GetX();
6110 wxPyEndAllowThreads(__tstate);
6111 if (PyErr_Occurred()) SWIG_fail;
6112 }
6113 resultobj = SWIG_From_int(static_cast< int >(result));
6114 return resultobj;
6115 fail:
6116 return NULL;
6117 }
6118
6119
6120 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6121 PyObject *resultobj = 0;
6122 wxRect *arg1 = (wxRect *) 0 ;
6123 int arg2 ;
6124 void *argp1 = 0 ;
6125 int res1 = 0 ;
6126 int val2 ;
6127 int ecode2 = 0 ;
6128 PyObject * obj0 = 0 ;
6129 PyObject * obj1 = 0 ;
6130 char * kwnames[] = {
6131 (char *) "self",(char *) "x", NULL
6132 };
6133
6134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6136 if (!SWIG_IsOK(res1)) {
6137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6138 }
6139 arg1 = reinterpret_cast< wxRect * >(argp1);
6140 ecode2 = SWIG_AsVal_int(obj1, &val2);
6141 if (!SWIG_IsOK(ecode2)) {
6142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6143 }
6144 arg2 = static_cast< int >(val2);
6145 {
6146 PyThreadState* __tstate = wxPyBeginAllowThreads();
6147 (arg1)->SetX(arg2);
6148 wxPyEndAllowThreads(__tstate);
6149 if (PyErr_Occurred()) SWIG_fail;
6150 }
6151 resultobj = SWIG_Py_Void();
6152 return resultobj;
6153 fail:
6154 return NULL;
6155 }
6156
6157
6158 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6159 PyObject *resultobj = 0;
6160 wxRect *arg1 = (wxRect *) 0 ;
6161 int result;
6162 void *argp1 = 0 ;
6163 int res1 = 0 ;
6164 PyObject *swig_obj[1] ;
6165
6166 if (!args) SWIG_fail;
6167 swig_obj[0] = args;
6168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6169 if (!SWIG_IsOK(res1)) {
6170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6171 }
6172 arg1 = reinterpret_cast< wxRect * >(argp1);
6173 {
6174 PyThreadState* __tstate = wxPyBeginAllowThreads();
6175 result = (int)(arg1)->GetY();
6176 wxPyEndAllowThreads(__tstate);
6177 if (PyErr_Occurred()) SWIG_fail;
6178 }
6179 resultobj = SWIG_From_int(static_cast< int >(result));
6180 return resultobj;
6181 fail:
6182 return NULL;
6183 }
6184
6185
6186 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6187 PyObject *resultobj = 0;
6188 wxRect *arg1 = (wxRect *) 0 ;
6189 int arg2 ;
6190 void *argp1 = 0 ;
6191 int res1 = 0 ;
6192 int val2 ;
6193 int ecode2 = 0 ;
6194 PyObject * obj0 = 0 ;
6195 PyObject * obj1 = 0 ;
6196 char * kwnames[] = {
6197 (char *) "self",(char *) "y", NULL
6198 };
6199
6200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6202 if (!SWIG_IsOK(res1)) {
6203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6204 }
6205 arg1 = reinterpret_cast< wxRect * >(argp1);
6206 ecode2 = SWIG_AsVal_int(obj1, &val2);
6207 if (!SWIG_IsOK(ecode2)) {
6208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6209 }
6210 arg2 = static_cast< int >(val2);
6211 {
6212 PyThreadState* __tstate = wxPyBeginAllowThreads();
6213 (arg1)->SetY(arg2);
6214 wxPyEndAllowThreads(__tstate);
6215 if (PyErr_Occurred()) SWIG_fail;
6216 }
6217 resultobj = SWIG_Py_Void();
6218 return resultobj;
6219 fail:
6220 return NULL;
6221 }
6222
6223
6224 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6225 PyObject *resultobj = 0;
6226 wxRect *arg1 = (wxRect *) 0 ;
6227 int result;
6228 void *argp1 = 0 ;
6229 int res1 = 0 ;
6230 PyObject *swig_obj[1] ;
6231
6232 if (!args) SWIG_fail;
6233 swig_obj[0] = args;
6234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6235 if (!SWIG_IsOK(res1)) {
6236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6237 }
6238 arg1 = reinterpret_cast< wxRect * >(argp1);
6239 {
6240 PyThreadState* __tstate = wxPyBeginAllowThreads();
6241 result = (int)((wxRect const *)arg1)->GetWidth();
6242 wxPyEndAllowThreads(__tstate);
6243 if (PyErr_Occurred()) SWIG_fail;
6244 }
6245 resultobj = SWIG_From_int(static_cast< int >(result));
6246 return resultobj;
6247 fail:
6248 return NULL;
6249 }
6250
6251
6252 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6253 PyObject *resultobj = 0;
6254 wxRect *arg1 = (wxRect *) 0 ;
6255 int arg2 ;
6256 void *argp1 = 0 ;
6257 int res1 = 0 ;
6258 int val2 ;
6259 int ecode2 = 0 ;
6260 PyObject * obj0 = 0 ;
6261 PyObject * obj1 = 0 ;
6262 char * kwnames[] = {
6263 (char *) "self",(char *) "w", NULL
6264 };
6265
6266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6268 if (!SWIG_IsOK(res1)) {
6269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6270 }
6271 arg1 = reinterpret_cast< wxRect * >(argp1);
6272 ecode2 = SWIG_AsVal_int(obj1, &val2);
6273 if (!SWIG_IsOK(ecode2)) {
6274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6275 }
6276 arg2 = static_cast< int >(val2);
6277 {
6278 PyThreadState* __tstate = wxPyBeginAllowThreads();
6279 (arg1)->SetWidth(arg2);
6280 wxPyEndAllowThreads(__tstate);
6281 if (PyErr_Occurred()) SWIG_fail;
6282 }
6283 resultobj = SWIG_Py_Void();
6284 return resultobj;
6285 fail:
6286 return NULL;
6287 }
6288
6289
6290 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6291 PyObject *resultobj = 0;
6292 wxRect *arg1 = (wxRect *) 0 ;
6293 int result;
6294 void *argp1 = 0 ;
6295 int res1 = 0 ;
6296 PyObject *swig_obj[1] ;
6297
6298 if (!args) SWIG_fail;
6299 swig_obj[0] = args;
6300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6301 if (!SWIG_IsOK(res1)) {
6302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6303 }
6304 arg1 = reinterpret_cast< wxRect * >(argp1);
6305 {
6306 PyThreadState* __tstate = wxPyBeginAllowThreads();
6307 result = (int)((wxRect const *)arg1)->GetHeight();
6308 wxPyEndAllowThreads(__tstate);
6309 if (PyErr_Occurred()) SWIG_fail;
6310 }
6311 resultobj = SWIG_From_int(static_cast< int >(result));
6312 return resultobj;
6313 fail:
6314 return NULL;
6315 }
6316
6317
6318 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6319 PyObject *resultobj = 0;
6320 wxRect *arg1 = (wxRect *) 0 ;
6321 int arg2 ;
6322 void *argp1 = 0 ;
6323 int res1 = 0 ;
6324 int val2 ;
6325 int ecode2 = 0 ;
6326 PyObject * obj0 = 0 ;
6327 PyObject * obj1 = 0 ;
6328 char * kwnames[] = {
6329 (char *) "self",(char *) "h", NULL
6330 };
6331
6332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6334 if (!SWIG_IsOK(res1)) {
6335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6336 }
6337 arg1 = reinterpret_cast< wxRect * >(argp1);
6338 ecode2 = SWIG_AsVal_int(obj1, &val2);
6339 if (!SWIG_IsOK(ecode2)) {
6340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6341 }
6342 arg2 = static_cast< int >(val2);
6343 {
6344 PyThreadState* __tstate = wxPyBeginAllowThreads();
6345 (arg1)->SetHeight(arg2);
6346 wxPyEndAllowThreads(__tstate);
6347 if (PyErr_Occurred()) SWIG_fail;
6348 }
6349 resultobj = SWIG_Py_Void();
6350 return resultobj;
6351 fail:
6352 return NULL;
6353 }
6354
6355
6356 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6357 PyObject *resultobj = 0;
6358 wxRect *arg1 = (wxRect *) 0 ;
6359 wxPoint result;
6360 void *argp1 = 0 ;
6361 int res1 = 0 ;
6362 PyObject *swig_obj[1] ;
6363
6364 if (!args) SWIG_fail;
6365 swig_obj[0] = args;
6366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6367 if (!SWIG_IsOK(res1)) {
6368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6369 }
6370 arg1 = reinterpret_cast< wxRect * >(argp1);
6371 {
6372 PyThreadState* __tstate = wxPyBeginAllowThreads();
6373 result = ((wxRect const *)arg1)->GetPosition();
6374 wxPyEndAllowThreads(__tstate);
6375 if (PyErr_Occurred()) SWIG_fail;
6376 }
6377 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6378 return resultobj;
6379 fail:
6380 return NULL;
6381 }
6382
6383
6384 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6385 PyObject *resultobj = 0;
6386 wxRect *arg1 = (wxRect *) 0 ;
6387 wxPoint *arg2 = 0 ;
6388 void *argp1 = 0 ;
6389 int res1 = 0 ;
6390 wxPoint temp2 ;
6391 PyObject * obj0 = 0 ;
6392 PyObject * obj1 = 0 ;
6393 char * kwnames[] = {
6394 (char *) "self",(char *) "p", NULL
6395 };
6396
6397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6399 if (!SWIG_IsOK(res1)) {
6400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6401 }
6402 arg1 = reinterpret_cast< wxRect * >(argp1);
6403 {
6404 arg2 = &temp2;
6405 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6406 }
6407 {
6408 PyThreadState* __tstate = wxPyBeginAllowThreads();
6409 (arg1)->SetPosition((wxPoint const &)*arg2);
6410 wxPyEndAllowThreads(__tstate);
6411 if (PyErr_Occurred()) SWIG_fail;
6412 }
6413 resultobj = SWIG_Py_Void();
6414 return resultobj;
6415 fail:
6416 return NULL;
6417 }
6418
6419
6420 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6421 PyObject *resultobj = 0;
6422 wxRect *arg1 = (wxRect *) 0 ;
6423 wxSize result;
6424 void *argp1 = 0 ;
6425 int res1 = 0 ;
6426 PyObject *swig_obj[1] ;
6427
6428 if (!args) SWIG_fail;
6429 swig_obj[0] = args;
6430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6431 if (!SWIG_IsOK(res1)) {
6432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6433 }
6434 arg1 = reinterpret_cast< wxRect * >(argp1);
6435 {
6436 PyThreadState* __tstate = wxPyBeginAllowThreads();
6437 result = ((wxRect const *)arg1)->GetSize();
6438 wxPyEndAllowThreads(__tstate);
6439 if (PyErr_Occurred()) SWIG_fail;
6440 }
6441 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6442 return resultobj;
6443 fail:
6444 return NULL;
6445 }
6446
6447
6448 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6449 PyObject *resultobj = 0;
6450 wxRect *arg1 = (wxRect *) 0 ;
6451 wxSize *arg2 = 0 ;
6452 void *argp1 = 0 ;
6453 int res1 = 0 ;
6454 wxSize temp2 ;
6455 PyObject * obj0 = 0 ;
6456 PyObject * obj1 = 0 ;
6457 char * kwnames[] = {
6458 (char *) "self",(char *) "s", NULL
6459 };
6460
6461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6463 if (!SWIG_IsOK(res1)) {
6464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6465 }
6466 arg1 = reinterpret_cast< wxRect * >(argp1);
6467 {
6468 arg2 = &temp2;
6469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6470 }
6471 {
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 (arg1)->SetSize((wxSize const &)*arg2);
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 resultobj = SWIG_Py_Void();
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6485 PyObject *resultobj = 0;
6486 wxRect *arg1 = (wxRect *) 0 ;
6487 bool result;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 PyObject *swig_obj[1] ;
6491
6492 if (!args) SWIG_fail;
6493 swig_obj[0] = args;
6494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6495 if (!SWIG_IsOK(res1)) {
6496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6497 }
6498 arg1 = reinterpret_cast< wxRect * >(argp1);
6499 {
6500 PyThreadState* __tstate = wxPyBeginAllowThreads();
6501 result = (bool)((wxRect const *)arg1)->IsEmpty();
6502 wxPyEndAllowThreads(__tstate);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 {
6506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6507 }
6508 return resultobj;
6509 fail:
6510 return NULL;
6511 }
6512
6513
6514 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6515 PyObject *resultobj = 0;
6516 wxRect *arg1 = (wxRect *) 0 ;
6517 wxPoint result;
6518 void *argp1 = 0 ;
6519 int res1 = 0 ;
6520 PyObject *swig_obj[1] ;
6521
6522 if (!args) SWIG_fail;
6523 swig_obj[0] = args;
6524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6525 if (!SWIG_IsOK(res1)) {
6526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6527 }
6528 arg1 = reinterpret_cast< wxRect * >(argp1);
6529 {
6530 PyThreadState* __tstate = wxPyBeginAllowThreads();
6531 result = ((wxRect const *)arg1)->GetTopLeft();
6532 wxPyEndAllowThreads(__tstate);
6533 if (PyErr_Occurred()) SWIG_fail;
6534 }
6535 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6536 return resultobj;
6537 fail:
6538 return NULL;
6539 }
6540
6541
6542 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6543 PyObject *resultobj = 0;
6544 wxRect *arg1 = (wxRect *) 0 ;
6545 wxPoint *arg2 = 0 ;
6546 void *argp1 = 0 ;
6547 int res1 = 0 ;
6548 wxPoint temp2 ;
6549 PyObject * obj0 = 0 ;
6550 PyObject * obj1 = 0 ;
6551 char * kwnames[] = {
6552 (char *) "self",(char *) "p", NULL
6553 };
6554
6555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6557 if (!SWIG_IsOK(res1)) {
6558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6559 }
6560 arg1 = reinterpret_cast< wxRect * >(argp1);
6561 {
6562 arg2 = &temp2;
6563 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6564 }
6565 {
6566 PyThreadState* __tstate = wxPyBeginAllowThreads();
6567 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6568 wxPyEndAllowThreads(__tstate);
6569 if (PyErr_Occurred()) SWIG_fail;
6570 }
6571 resultobj = SWIG_Py_Void();
6572 return resultobj;
6573 fail:
6574 return NULL;
6575 }
6576
6577
6578 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6579 PyObject *resultobj = 0;
6580 wxRect *arg1 = (wxRect *) 0 ;
6581 wxPoint result;
6582 void *argp1 = 0 ;
6583 int res1 = 0 ;
6584 PyObject *swig_obj[1] ;
6585
6586 if (!args) SWIG_fail;
6587 swig_obj[0] = args;
6588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6589 if (!SWIG_IsOK(res1)) {
6590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6591 }
6592 arg1 = reinterpret_cast< wxRect * >(argp1);
6593 {
6594 PyThreadState* __tstate = wxPyBeginAllowThreads();
6595 result = ((wxRect const *)arg1)->GetBottomRight();
6596 wxPyEndAllowThreads(__tstate);
6597 if (PyErr_Occurred()) SWIG_fail;
6598 }
6599 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6600 return resultobj;
6601 fail:
6602 return NULL;
6603 }
6604
6605
6606 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6607 PyObject *resultobj = 0;
6608 wxRect *arg1 = (wxRect *) 0 ;
6609 wxPoint *arg2 = 0 ;
6610 void *argp1 = 0 ;
6611 int res1 = 0 ;
6612 wxPoint temp2 ;
6613 PyObject * obj0 = 0 ;
6614 PyObject * obj1 = 0 ;
6615 char * kwnames[] = {
6616 (char *) "self",(char *) "p", NULL
6617 };
6618
6619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6621 if (!SWIG_IsOK(res1)) {
6622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6623 }
6624 arg1 = reinterpret_cast< wxRect * >(argp1);
6625 {
6626 arg2 = &temp2;
6627 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6628 }
6629 {
6630 PyThreadState* __tstate = wxPyBeginAllowThreads();
6631 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6632 wxPyEndAllowThreads(__tstate);
6633 if (PyErr_Occurred()) SWIG_fail;
6634 }
6635 resultobj = SWIG_Py_Void();
6636 return resultobj;
6637 fail:
6638 return NULL;
6639 }
6640
6641
6642 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6643 PyObject *resultobj = 0;
6644 wxRect *arg1 = (wxRect *) 0 ;
6645 int result;
6646 void *argp1 = 0 ;
6647 int res1 = 0 ;
6648 PyObject *swig_obj[1] ;
6649
6650 if (!args) SWIG_fail;
6651 swig_obj[0] = args;
6652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6653 if (!SWIG_IsOK(res1)) {
6654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6655 }
6656 arg1 = reinterpret_cast< wxRect * >(argp1);
6657 {
6658 PyThreadState* __tstate = wxPyBeginAllowThreads();
6659 result = (int)((wxRect const *)arg1)->GetLeft();
6660 wxPyEndAllowThreads(__tstate);
6661 if (PyErr_Occurred()) SWIG_fail;
6662 }
6663 resultobj = SWIG_From_int(static_cast< int >(result));
6664 return resultobj;
6665 fail:
6666 return NULL;
6667 }
6668
6669
6670 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6671 PyObject *resultobj = 0;
6672 wxRect *arg1 = (wxRect *) 0 ;
6673 int result;
6674 void *argp1 = 0 ;
6675 int res1 = 0 ;
6676 PyObject *swig_obj[1] ;
6677
6678 if (!args) SWIG_fail;
6679 swig_obj[0] = args;
6680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6681 if (!SWIG_IsOK(res1)) {
6682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6683 }
6684 arg1 = reinterpret_cast< wxRect * >(argp1);
6685 {
6686 PyThreadState* __tstate = wxPyBeginAllowThreads();
6687 result = (int)((wxRect const *)arg1)->GetTop();
6688 wxPyEndAllowThreads(__tstate);
6689 if (PyErr_Occurred()) SWIG_fail;
6690 }
6691 resultobj = SWIG_From_int(static_cast< int >(result));
6692 return resultobj;
6693 fail:
6694 return NULL;
6695 }
6696
6697
6698 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6699 PyObject *resultobj = 0;
6700 wxRect *arg1 = (wxRect *) 0 ;
6701 int result;
6702 void *argp1 = 0 ;
6703 int res1 = 0 ;
6704 PyObject *swig_obj[1] ;
6705
6706 if (!args) SWIG_fail;
6707 swig_obj[0] = args;
6708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6709 if (!SWIG_IsOK(res1)) {
6710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6711 }
6712 arg1 = reinterpret_cast< wxRect * >(argp1);
6713 {
6714 PyThreadState* __tstate = wxPyBeginAllowThreads();
6715 result = (int)((wxRect const *)arg1)->GetBottom();
6716 wxPyEndAllowThreads(__tstate);
6717 if (PyErr_Occurred()) SWIG_fail;
6718 }
6719 resultobj = SWIG_From_int(static_cast< int >(result));
6720 return resultobj;
6721 fail:
6722 return NULL;
6723 }
6724
6725
6726 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6727 PyObject *resultobj = 0;
6728 wxRect *arg1 = (wxRect *) 0 ;
6729 int result;
6730 void *argp1 = 0 ;
6731 int res1 = 0 ;
6732 PyObject *swig_obj[1] ;
6733
6734 if (!args) SWIG_fail;
6735 swig_obj[0] = args;
6736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6737 if (!SWIG_IsOK(res1)) {
6738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6739 }
6740 arg1 = reinterpret_cast< wxRect * >(argp1);
6741 {
6742 PyThreadState* __tstate = wxPyBeginAllowThreads();
6743 result = (int)((wxRect const *)arg1)->GetRight();
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 resultobj = SWIG_From_int(static_cast< int >(result));
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6755 PyObject *resultobj = 0;
6756 wxRect *arg1 = (wxRect *) 0 ;
6757 int arg2 ;
6758 void *argp1 = 0 ;
6759 int res1 = 0 ;
6760 int val2 ;
6761 int ecode2 = 0 ;
6762 PyObject * obj0 = 0 ;
6763 PyObject * obj1 = 0 ;
6764 char * kwnames[] = {
6765 (char *) "self",(char *) "left", NULL
6766 };
6767
6768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6770 if (!SWIG_IsOK(res1)) {
6771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6772 }
6773 arg1 = reinterpret_cast< wxRect * >(argp1);
6774 ecode2 = SWIG_AsVal_int(obj1, &val2);
6775 if (!SWIG_IsOK(ecode2)) {
6776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6777 }
6778 arg2 = static_cast< int >(val2);
6779 {
6780 PyThreadState* __tstate = wxPyBeginAllowThreads();
6781 (arg1)->SetLeft(arg2);
6782 wxPyEndAllowThreads(__tstate);
6783 if (PyErr_Occurred()) SWIG_fail;
6784 }
6785 resultobj = SWIG_Py_Void();
6786 return resultobj;
6787 fail:
6788 return NULL;
6789 }
6790
6791
6792 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6793 PyObject *resultobj = 0;
6794 wxRect *arg1 = (wxRect *) 0 ;
6795 int arg2 ;
6796 void *argp1 = 0 ;
6797 int res1 = 0 ;
6798 int val2 ;
6799 int ecode2 = 0 ;
6800 PyObject * obj0 = 0 ;
6801 PyObject * obj1 = 0 ;
6802 char * kwnames[] = {
6803 (char *) "self",(char *) "right", NULL
6804 };
6805
6806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6808 if (!SWIG_IsOK(res1)) {
6809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6810 }
6811 arg1 = reinterpret_cast< wxRect * >(argp1);
6812 ecode2 = SWIG_AsVal_int(obj1, &val2);
6813 if (!SWIG_IsOK(ecode2)) {
6814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6815 }
6816 arg2 = static_cast< int >(val2);
6817 {
6818 PyThreadState* __tstate = wxPyBeginAllowThreads();
6819 (arg1)->SetRight(arg2);
6820 wxPyEndAllowThreads(__tstate);
6821 if (PyErr_Occurred()) SWIG_fail;
6822 }
6823 resultobj = SWIG_Py_Void();
6824 return resultobj;
6825 fail:
6826 return NULL;
6827 }
6828
6829
6830 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6831 PyObject *resultobj = 0;
6832 wxRect *arg1 = (wxRect *) 0 ;
6833 int arg2 ;
6834 void *argp1 = 0 ;
6835 int res1 = 0 ;
6836 int val2 ;
6837 int ecode2 = 0 ;
6838 PyObject * obj0 = 0 ;
6839 PyObject * obj1 = 0 ;
6840 char * kwnames[] = {
6841 (char *) "self",(char *) "top", NULL
6842 };
6843
6844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6846 if (!SWIG_IsOK(res1)) {
6847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6848 }
6849 arg1 = reinterpret_cast< wxRect * >(argp1);
6850 ecode2 = SWIG_AsVal_int(obj1, &val2);
6851 if (!SWIG_IsOK(ecode2)) {
6852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6853 }
6854 arg2 = static_cast< int >(val2);
6855 {
6856 PyThreadState* __tstate = wxPyBeginAllowThreads();
6857 (arg1)->SetTop(arg2);
6858 wxPyEndAllowThreads(__tstate);
6859 if (PyErr_Occurred()) SWIG_fail;
6860 }
6861 resultobj = SWIG_Py_Void();
6862 return resultobj;
6863 fail:
6864 return NULL;
6865 }
6866
6867
6868 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6869 PyObject *resultobj = 0;
6870 wxRect *arg1 = (wxRect *) 0 ;
6871 int arg2 ;
6872 void *argp1 = 0 ;
6873 int res1 = 0 ;
6874 int val2 ;
6875 int ecode2 = 0 ;
6876 PyObject * obj0 = 0 ;
6877 PyObject * obj1 = 0 ;
6878 char * kwnames[] = {
6879 (char *) "self",(char *) "bottom", NULL
6880 };
6881
6882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6884 if (!SWIG_IsOK(res1)) {
6885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6886 }
6887 arg1 = reinterpret_cast< wxRect * >(argp1);
6888 ecode2 = SWIG_AsVal_int(obj1, &val2);
6889 if (!SWIG_IsOK(ecode2)) {
6890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6891 }
6892 arg2 = static_cast< int >(val2);
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 (arg1)->SetBottom(arg2);
6896 wxPyEndAllowThreads(__tstate);
6897 if (PyErr_Occurred()) SWIG_fail;
6898 }
6899 resultobj = SWIG_Py_Void();
6900 return resultobj;
6901 fail:
6902 return NULL;
6903 }
6904
6905
6906 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6907 PyObject *resultobj = 0;
6908 wxRect *arg1 = (wxRect *) 0 ;
6909 int arg2 ;
6910 int arg3 ;
6911 wxRect *result = 0 ;
6912 void *argp1 = 0 ;
6913 int res1 = 0 ;
6914 int val2 ;
6915 int ecode2 = 0 ;
6916 int val3 ;
6917 int ecode3 = 0 ;
6918 PyObject * obj0 = 0 ;
6919 PyObject * obj1 = 0 ;
6920 PyObject * obj2 = 0 ;
6921 char * kwnames[] = {
6922 (char *) "self",(char *) "dx",(char *) "dy", NULL
6923 };
6924
6925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6927 if (!SWIG_IsOK(res1)) {
6928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
6929 }
6930 arg1 = reinterpret_cast< wxRect * >(argp1);
6931 ecode2 = SWIG_AsVal_int(obj1, &val2);
6932 if (!SWIG_IsOK(ecode2)) {
6933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
6934 }
6935 arg2 = static_cast< int >(val2);
6936 ecode3 = SWIG_AsVal_int(obj2, &val3);
6937 if (!SWIG_IsOK(ecode3)) {
6938 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
6939 }
6940 arg3 = static_cast< int >(val3);
6941 {
6942 PyThreadState* __tstate = wxPyBeginAllowThreads();
6943 {
6944 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
6945 result = (wxRect *) &_result_ref;
6946 }
6947 wxPyEndAllowThreads(__tstate);
6948 if (PyErr_Occurred()) SWIG_fail;
6949 }
6950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj = 0;
6959 wxRect *arg1 = (wxRect *) 0 ;
6960 int arg2 ;
6961 int arg3 ;
6962 wxRect *result = 0 ;
6963 void *argp1 = 0 ;
6964 int res1 = 0 ;
6965 int val2 ;
6966 int ecode2 = 0 ;
6967 int val3 ;
6968 int ecode3 = 0 ;
6969 PyObject * obj0 = 0 ;
6970 PyObject * obj1 = 0 ;
6971 PyObject * obj2 = 0 ;
6972 char * kwnames[] = {
6973 (char *) "self",(char *) "dx",(char *) "dy", NULL
6974 };
6975
6976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6978 if (!SWIG_IsOK(res1)) {
6979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
6980 }
6981 arg1 = reinterpret_cast< wxRect * >(argp1);
6982 ecode2 = SWIG_AsVal_int(obj1, &val2);
6983 if (!SWIG_IsOK(ecode2)) {
6984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
6985 }
6986 arg2 = static_cast< int >(val2);
6987 ecode3 = SWIG_AsVal_int(obj2, &val3);
6988 if (!SWIG_IsOK(ecode3)) {
6989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
6990 }
6991 arg3 = static_cast< int >(val3);
6992 {
6993 PyThreadState* __tstate = wxPyBeginAllowThreads();
6994 {
6995 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
6996 result = (wxRect *) &_result_ref;
6997 }
6998 wxPyEndAllowThreads(__tstate);
6999 if (PyErr_Occurred()) SWIG_fail;
7000 }
7001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7002 return resultobj;
7003 fail:
7004 return NULL;
7005 }
7006
7007
7008 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7009 PyObject *resultobj = 0;
7010 wxRect *arg1 = (wxRect *) 0 ;
7011 int arg2 ;
7012 int arg3 ;
7013 void *argp1 = 0 ;
7014 int res1 = 0 ;
7015 int val2 ;
7016 int ecode2 = 0 ;
7017 int val3 ;
7018 int ecode3 = 0 ;
7019 PyObject * obj0 = 0 ;
7020 PyObject * obj1 = 0 ;
7021 PyObject * obj2 = 0 ;
7022 char * kwnames[] = {
7023 (char *) "self",(char *) "dx",(char *) "dy", NULL
7024 };
7025
7026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7028 if (!SWIG_IsOK(res1)) {
7029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7030 }
7031 arg1 = reinterpret_cast< wxRect * >(argp1);
7032 ecode2 = SWIG_AsVal_int(obj1, &val2);
7033 if (!SWIG_IsOK(ecode2)) {
7034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7035 }
7036 arg2 = static_cast< int >(val2);
7037 ecode3 = SWIG_AsVal_int(obj2, &val3);
7038 if (!SWIG_IsOK(ecode3)) {
7039 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7040 }
7041 arg3 = static_cast< int >(val3);
7042 {
7043 PyThreadState* __tstate = wxPyBeginAllowThreads();
7044 (arg1)->Offset(arg2,arg3);
7045 wxPyEndAllowThreads(__tstate);
7046 if (PyErr_Occurred()) SWIG_fail;
7047 }
7048 resultobj = SWIG_Py_Void();
7049 return resultobj;
7050 fail:
7051 return NULL;
7052 }
7053
7054
7055 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7056 PyObject *resultobj = 0;
7057 wxRect *arg1 = (wxRect *) 0 ;
7058 wxPoint *arg2 = 0 ;
7059 void *argp1 = 0 ;
7060 int res1 = 0 ;
7061 wxPoint temp2 ;
7062 PyObject * obj0 = 0 ;
7063 PyObject * obj1 = 0 ;
7064 char * kwnames[] = {
7065 (char *) "self",(char *) "pt", NULL
7066 };
7067
7068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7070 if (!SWIG_IsOK(res1)) {
7071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7072 }
7073 arg1 = reinterpret_cast< wxRect * >(argp1);
7074 {
7075 arg2 = &temp2;
7076 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7077 }
7078 {
7079 PyThreadState* __tstate = wxPyBeginAllowThreads();
7080 (arg1)->Offset((wxPoint const &)*arg2);
7081 wxPyEndAllowThreads(__tstate);
7082 if (PyErr_Occurred()) SWIG_fail;
7083 }
7084 resultobj = SWIG_Py_Void();
7085 return resultobj;
7086 fail:
7087 return NULL;
7088 }
7089
7090
7091 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7092 PyObject *resultobj = 0;
7093 wxRect *arg1 = (wxRect *) 0 ;
7094 wxRect *arg2 = 0 ;
7095 wxRect result;
7096 void *argp1 = 0 ;
7097 int res1 = 0 ;
7098 wxRect temp2 ;
7099 PyObject * obj0 = 0 ;
7100 PyObject * obj1 = 0 ;
7101 char * kwnames[] = {
7102 (char *) "self",(char *) "rect", NULL
7103 };
7104
7105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7107 if (!SWIG_IsOK(res1)) {
7108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7109 }
7110 arg1 = reinterpret_cast< wxRect * >(argp1);
7111 {
7112 arg2 = &temp2;
7113 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7114 }
7115 {
7116 PyThreadState* __tstate = wxPyBeginAllowThreads();
7117 result = (arg1)->Intersect((wxRect const &)*arg2);
7118 wxPyEndAllowThreads(__tstate);
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 wxRect *arg2 = 0 ;
7132 wxRect result;
7133 void *argp1 = 0 ;
7134 int res1 = 0 ;
7135 wxRect temp2 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "rect", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 {
7149 arg2 = &temp2;
7150 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7151 }
7152 {
7153 PyThreadState* __tstate = wxPyBeginAllowThreads();
7154 result = (arg1)->Union((wxRect const &)*arg2);
7155 wxPyEndAllowThreads(__tstate);
7156 if (PyErr_Occurred()) SWIG_fail;
7157 }
7158 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7159 return resultobj;
7160 fail:
7161 return NULL;
7162 }
7163
7164
7165 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7166 PyObject *resultobj = 0;
7167 wxRect *arg1 = (wxRect *) 0 ;
7168 wxRect *arg2 = 0 ;
7169 wxRect result;
7170 void *argp1 = 0 ;
7171 int res1 = 0 ;
7172 wxRect temp2 ;
7173 PyObject * obj0 = 0 ;
7174 PyObject * obj1 = 0 ;
7175 char * kwnames[] = {
7176 (char *) "self",(char *) "rect", NULL
7177 };
7178
7179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7181 if (!SWIG_IsOK(res1)) {
7182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7183 }
7184 arg1 = reinterpret_cast< wxRect * >(argp1);
7185 {
7186 arg2 = &temp2;
7187 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7188 }
7189 {
7190 PyThreadState* __tstate = wxPyBeginAllowThreads();
7191 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7192 wxPyEndAllowThreads(__tstate);
7193 if (PyErr_Occurred()) SWIG_fail;
7194 }
7195 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj = 0;
7204 wxRect *arg1 = (wxRect *) 0 ;
7205 wxRect *arg2 = 0 ;
7206 wxRect *result = 0 ;
7207 void *argp1 = 0 ;
7208 int res1 = 0 ;
7209 wxRect temp2 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 char * kwnames[] = {
7213 (char *) "self",(char *) "rect", NULL
7214 };
7215
7216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7218 if (!SWIG_IsOK(res1)) {
7219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7220 }
7221 arg1 = reinterpret_cast< wxRect * >(argp1);
7222 {
7223 arg2 = &temp2;
7224 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7225 }
7226 {
7227 PyThreadState* __tstate = wxPyBeginAllowThreads();
7228 {
7229 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7230 result = (wxRect *) &_result_ref;
7231 }
7232 wxPyEndAllowThreads(__tstate);
7233 if (PyErr_Occurred()) SWIG_fail;
7234 }
7235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7236 return resultobj;
7237 fail:
7238 return NULL;
7239 }
7240
7241
7242 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7243 PyObject *resultobj = 0;
7244 wxRect *arg1 = (wxRect *) 0 ;
7245 wxRect *arg2 = 0 ;
7246 bool result;
7247 void *argp1 = 0 ;
7248 int res1 = 0 ;
7249 wxRect temp2 ;
7250 PyObject * obj0 = 0 ;
7251 PyObject * obj1 = 0 ;
7252 char * kwnames[] = {
7253 (char *) "self",(char *) "rect", NULL
7254 };
7255
7256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7258 if (!SWIG_IsOK(res1)) {
7259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect const *""'");
7260 }
7261 arg1 = reinterpret_cast< wxRect * >(argp1);
7262 {
7263 arg2 = &temp2;
7264 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7265 }
7266 {
7267 PyThreadState* __tstate = wxPyBeginAllowThreads();
7268 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
7269 wxPyEndAllowThreads(__tstate);
7270 if (PyErr_Occurred()) SWIG_fail;
7271 }
7272 {
7273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7274 }
7275 return resultobj;
7276 fail:
7277 return NULL;
7278 }
7279
7280
7281 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7282 PyObject *resultobj = 0;
7283 wxRect *arg1 = (wxRect *) 0 ;
7284 wxRect *arg2 = 0 ;
7285 bool result;
7286 void *argp1 = 0 ;
7287 int res1 = 0 ;
7288 wxRect temp2 ;
7289 PyObject * obj0 = 0 ;
7290 PyObject * obj1 = 0 ;
7291 char * kwnames[] = {
7292 (char *) "self",(char *) "rect", NULL
7293 };
7294
7295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7297 if (!SWIG_IsOK(res1)) {
7298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect const *""'");
7299 }
7300 arg1 = reinterpret_cast< wxRect * >(argp1);
7301 {
7302 arg2 = &temp2;
7303 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7304 }
7305 {
7306 PyThreadState* __tstate = wxPyBeginAllowThreads();
7307 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 {
7312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7313 }
7314 return resultobj;
7315 fail:
7316 return NULL;
7317 }
7318
7319
7320 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7321 PyObject *resultobj = 0;
7322 wxRect *arg1 = (wxRect *) 0 ;
7323 int arg2 ;
7324 int arg3 ;
7325 bool result;
7326 void *argp1 = 0 ;
7327 int res1 = 0 ;
7328 int val2 ;
7329 int ecode2 = 0 ;
7330 int val3 ;
7331 int ecode3 = 0 ;
7332 PyObject * obj0 = 0 ;
7333 PyObject * obj1 = 0 ;
7334 PyObject * obj2 = 0 ;
7335 char * kwnames[] = {
7336 (char *) "self",(char *) "x",(char *) "y", NULL
7337 };
7338
7339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7341 if (!SWIG_IsOK(res1)) {
7342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7343 }
7344 arg1 = reinterpret_cast< wxRect * >(argp1);
7345 ecode2 = SWIG_AsVal_int(obj1, &val2);
7346 if (!SWIG_IsOK(ecode2)) {
7347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7348 }
7349 arg2 = static_cast< int >(val2);
7350 ecode3 = SWIG_AsVal_int(obj2, &val3);
7351 if (!SWIG_IsOK(ecode3)) {
7352 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7353 }
7354 arg3 = static_cast< int >(val3);
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 {
7362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7363 }
7364 return resultobj;
7365 fail:
7366 return NULL;
7367 }
7368
7369
7370 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7371 PyObject *resultobj = 0;
7372 wxRect *arg1 = (wxRect *) 0 ;
7373 wxPoint *arg2 = 0 ;
7374 bool result;
7375 void *argp1 = 0 ;
7376 int res1 = 0 ;
7377 wxPoint temp2 ;
7378 PyObject * obj0 = 0 ;
7379 PyObject * obj1 = 0 ;
7380 char * kwnames[] = {
7381 (char *) "self",(char *) "pt", NULL
7382 };
7383
7384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7386 if (!SWIG_IsOK(res1)) {
7387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7388 }
7389 arg1 = reinterpret_cast< wxRect * >(argp1);
7390 {
7391 arg2 = &temp2;
7392 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7393 }
7394 {
7395 PyThreadState* __tstate = wxPyBeginAllowThreads();
7396 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 {
7401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7402 }
7403 return resultobj;
7404 fail:
7405 return NULL;
7406 }
7407
7408
7409 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7410 PyObject *resultobj = 0;
7411 wxRect *arg1 = (wxRect *) 0 ;
7412 wxRect *arg2 = 0 ;
7413 bool result;
7414 void *argp1 = 0 ;
7415 int res1 = 0 ;
7416 wxRect temp2 ;
7417 PyObject * obj0 = 0 ;
7418 PyObject * obj1 = 0 ;
7419 char * kwnames[] = {
7420 (char *) "self",(char *) "rect", NULL
7421 };
7422
7423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7425 if (!SWIG_IsOK(res1)) {
7426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7427 }
7428 arg1 = reinterpret_cast< wxRect * >(argp1);
7429 {
7430 arg2 = &temp2;
7431 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7432 }
7433 {
7434 PyThreadState* __tstate = wxPyBeginAllowThreads();
7435 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 {
7440 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7441 }
7442 return resultobj;
7443 fail:
7444 return NULL;
7445 }
7446
7447
7448 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7449 PyObject *resultobj = 0;
7450 wxRect *arg1 = (wxRect *) 0 ;
7451 wxRect *arg2 = 0 ;
7452 int arg3 = (int) wxBOTH ;
7453 wxRect result;
7454 void *argp1 = 0 ;
7455 int res1 = 0 ;
7456 wxRect temp2 ;
7457 int val3 ;
7458 int ecode3 = 0 ;
7459 PyObject * obj0 = 0 ;
7460 PyObject * obj1 = 0 ;
7461 PyObject * obj2 = 0 ;
7462 char * kwnames[] = {
7463 (char *) "self",(char *) "r",(char *) "dir", NULL
7464 };
7465
7466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7468 if (!SWIG_IsOK(res1)) {
7469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7470 }
7471 arg1 = reinterpret_cast< wxRect * >(argp1);
7472 {
7473 arg2 = &temp2;
7474 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7475 }
7476 if (obj2) {
7477 ecode3 = SWIG_AsVal_int(obj2, &val3);
7478 if (!SWIG_IsOK(ecode3)) {
7479 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7480 }
7481 arg3 = static_cast< int >(val3);
7482 }
7483 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7486 wxPyEndAllowThreads(__tstate);
7487 if (PyErr_Occurred()) SWIG_fail;
7488 }
7489 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7490 return resultobj;
7491 fail:
7492 return NULL;
7493 }
7494
7495
7496 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7497 PyObject *resultobj = 0;
7498 wxRect *arg1 = (wxRect *) 0 ;
7499 int arg2 ;
7500 void *argp1 = 0 ;
7501 int res1 = 0 ;
7502 int val2 ;
7503 int ecode2 = 0 ;
7504 PyObject *swig_obj[2] ;
7505
7506 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7508 if (!SWIG_IsOK(res1)) {
7509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7510 }
7511 arg1 = reinterpret_cast< wxRect * >(argp1);
7512 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7513 if (!SWIG_IsOK(ecode2)) {
7514 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7515 }
7516 arg2 = static_cast< int >(val2);
7517 if (arg1) (arg1)->x = arg2;
7518
7519 resultobj = SWIG_Py_Void();
7520 return resultobj;
7521 fail:
7522 return NULL;
7523 }
7524
7525
7526 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7527 PyObject *resultobj = 0;
7528 wxRect *arg1 = (wxRect *) 0 ;
7529 int result;
7530 void *argp1 = 0 ;
7531 int res1 = 0 ;
7532 PyObject *swig_obj[1] ;
7533
7534 if (!args) SWIG_fail;
7535 swig_obj[0] = args;
7536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7537 if (!SWIG_IsOK(res1)) {
7538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7539 }
7540 arg1 = reinterpret_cast< wxRect * >(argp1);
7541 result = (int) ((arg1)->x);
7542 resultobj = SWIG_From_int(static_cast< int >(result));
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7550 PyObject *resultobj = 0;
7551 wxRect *arg1 = (wxRect *) 0 ;
7552 int arg2 ;
7553 void *argp1 = 0 ;
7554 int res1 = 0 ;
7555 int val2 ;
7556 int ecode2 = 0 ;
7557 PyObject *swig_obj[2] ;
7558
7559 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7561 if (!SWIG_IsOK(res1)) {
7562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7563 }
7564 arg1 = reinterpret_cast< wxRect * >(argp1);
7565 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7566 if (!SWIG_IsOK(ecode2)) {
7567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7568 }
7569 arg2 = static_cast< int >(val2);
7570 if (arg1) (arg1)->y = arg2;
7571
7572 resultobj = SWIG_Py_Void();
7573 return resultobj;
7574 fail:
7575 return NULL;
7576 }
7577
7578
7579 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7580 PyObject *resultobj = 0;
7581 wxRect *arg1 = (wxRect *) 0 ;
7582 int result;
7583 void *argp1 = 0 ;
7584 int res1 = 0 ;
7585 PyObject *swig_obj[1] ;
7586
7587 if (!args) SWIG_fail;
7588 swig_obj[0] = args;
7589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7590 if (!SWIG_IsOK(res1)) {
7591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7592 }
7593 arg1 = reinterpret_cast< wxRect * >(argp1);
7594 result = (int) ((arg1)->y);
7595 resultobj = SWIG_From_int(static_cast< int >(result));
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7603 PyObject *resultobj = 0;
7604 wxRect *arg1 = (wxRect *) 0 ;
7605 int arg2 ;
7606 void *argp1 = 0 ;
7607 int res1 = 0 ;
7608 int val2 ;
7609 int ecode2 = 0 ;
7610 PyObject *swig_obj[2] ;
7611
7612 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7614 if (!SWIG_IsOK(res1)) {
7615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7616 }
7617 arg1 = reinterpret_cast< wxRect * >(argp1);
7618 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7619 if (!SWIG_IsOK(ecode2)) {
7620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7621 }
7622 arg2 = static_cast< int >(val2);
7623 if (arg1) (arg1)->width = arg2;
7624
7625 resultobj = SWIG_Py_Void();
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7633 PyObject *resultobj = 0;
7634 wxRect *arg1 = (wxRect *) 0 ;
7635 int result;
7636 void *argp1 = 0 ;
7637 int res1 = 0 ;
7638 PyObject *swig_obj[1] ;
7639
7640 if (!args) SWIG_fail;
7641 swig_obj[0] = args;
7642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7643 if (!SWIG_IsOK(res1)) {
7644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7645 }
7646 arg1 = reinterpret_cast< wxRect * >(argp1);
7647 result = (int) ((arg1)->width);
7648 resultobj = SWIG_From_int(static_cast< int >(result));
7649 return resultobj;
7650 fail:
7651 return NULL;
7652 }
7653
7654
7655 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7656 PyObject *resultobj = 0;
7657 wxRect *arg1 = (wxRect *) 0 ;
7658 int arg2 ;
7659 void *argp1 = 0 ;
7660 int res1 = 0 ;
7661 int val2 ;
7662 int ecode2 = 0 ;
7663 PyObject *swig_obj[2] ;
7664
7665 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7667 if (!SWIG_IsOK(res1)) {
7668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7669 }
7670 arg1 = reinterpret_cast< wxRect * >(argp1);
7671 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7672 if (!SWIG_IsOK(ecode2)) {
7673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7674 }
7675 arg2 = static_cast< int >(val2);
7676 if (arg1) (arg1)->height = arg2;
7677
7678 resultobj = SWIG_Py_Void();
7679 return resultobj;
7680 fail:
7681 return NULL;
7682 }
7683
7684
7685 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7686 PyObject *resultobj = 0;
7687 wxRect *arg1 = (wxRect *) 0 ;
7688 int result;
7689 void *argp1 = 0 ;
7690 int res1 = 0 ;
7691 PyObject *swig_obj[1] ;
7692
7693 if (!args) SWIG_fail;
7694 swig_obj[0] = args;
7695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7696 if (!SWIG_IsOK(res1)) {
7697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7698 }
7699 arg1 = reinterpret_cast< wxRect * >(argp1);
7700 result = (int) ((arg1)->height);
7701 resultobj = SWIG_From_int(static_cast< int >(result));
7702 return resultobj;
7703 fail:
7704 return NULL;
7705 }
7706
7707
7708 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7709 PyObject *resultobj = 0;
7710 wxRect *arg1 = (wxRect *) 0 ;
7711 int arg2 = (int) 0 ;
7712 int arg3 = (int) 0 ;
7713 int arg4 = (int) 0 ;
7714 int arg5 = (int) 0 ;
7715 void *argp1 = 0 ;
7716 int res1 = 0 ;
7717 int val2 ;
7718 int ecode2 = 0 ;
7719 int val3 ;
7720 int ecode3 = 0 ;
7721 int val4 ;
7722 int ecode4 = 0 ;
7723 int val5 ;
7724 int ecode5 = 0 ;
7725 PyObject * obj0 = 0 ;
7726 PyObject * obj1 = 0 ;
7727 PyObject * obj2 = 0 ;
7728 PyObject * obj3 = 0 ;
7729 PyObject * obj4 = 0 ;
7730 char * kwnames[] = {
7731 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7732 };
7733
7734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7736 if (!SWIG_IsOK(res1)) {
7737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7738 }
7739 arg1 = reinterpret_cast< wxRect * >(argp1);
7740 if (obj1) {
7741 ecode2 = SWIG_AsVal_int(obj1, &val2);
7742 if (!SWIG_IsOK(ecode2)) {
7743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7744 }
7745 arg2 = static_cast< int >(val2);
7746 }
7747 if (obj2) {
7748 ecode3 = SWIG_AsVal_int(obj2, &val3);
7749 if (!SWIG_IsOK(ecode3)) {
7750 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7751 }
7752 arg3 = static_cast< int >(val3);
7753 }
7754 if (obj3) {
7755 ecode4 = SWIG_AsVal_int(obj3, &val4);
7756 if (!SWIG_IsOK(ecode4)) {
7757 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7758 }
7759 arg4 = static_cast< int >(val4);
7760 }
7761 if (obj4) {
7762 ecode5 = SWIG_AsVal_int(obj4, &val5);
7763 if (!SWIG_IsOK(ecode5)) {
7764 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7765 }
7766 arg5 = static_cast< int >(val5);
7767 }
7768 {
7769 PyThreadState* __tstate = wxPyBeginAllowThreads();
7770 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7771 wxPyEndAllowThreads(__tstate);
7772 if (PyErr_Occurred()) SWIG_fail;
7773 }
7774 resultobj = SWIG_Py_Void();
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7782 PyObject *resultobj = 0;
7783 wxRect *arg1 = (wxRect *) 0 ;
7784 PyObject *result = 0 ;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 PyObject *swig_obj[1] ;
7788
7789 if (!args) SWIG_fail;
7790 swig_obj[0] = args;
7791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7794 }
7795 arg1 = reinterpret_cast< wxRect * >(argp1);
7796 {
7797 PyThreadState* __tstate = wxPyBeginAllowThreads();
7798 result = (PyObject *)wxRect_Get(arg1);
7799 wxPyEndAllowThreads(__tstate);
7800 if (PyErr_Occurred()) SWIG_fail;
7801 }
7802 resultobj = result;
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 PyObject *obj;
7811 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7812 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7813 return SWIG_Py_Void();
7814 }
7815
7816 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7817 return SWIG_Python_InitShadowInstance(args);
7818 }
7819
7820 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj = 0;
7822 wxRect *arg1 = (wxRect *) 0 ;
7823 wxRect *arg2 = (wxRect *) 0 ;
7824 PyObject *result = 0 ;
7825 void *argp1 = 0 ;
7826 int res1 = 0 ;
7827 void *argp2 = 0 ;
7828 int res2 = 0 ;
7829 PyObject * obj0 = 0 ;
7830 PyObject * obj1 = 0 ;
7831 char * kwnames[] = {
7832 (char *) "r1",(char *) "r2", NULL
7833 };
7834
7835 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7836 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7837 if (!SWIG_IsOK(res1)) {
7838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7839 }
7840 arg1 = reinterpret_cast< wxRect * >(argp1);
7841 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7842 if (!SWIG_IsOK(res2)) {
7843 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7844 }
7845 arg2 = reinterpret_cast< wxRect * >(argp2);
7846 {
7847 if (!wxPyCheckForApp()) SWIG_fail;
7848 PyThreadState* __tstate = wxPyBeginAllowThreads();
7849 result = (PyObject *)wxIntersectRect(arg1,arg2);
7850 wxPyEndAllowThreads(__tstate);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = result;
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7861 PyObject *resultobj = 0;
7862 double arg1 = (double) 0.0 ;
7863 double arg2 = (double) 0.0 ;
7864 wxPoint2D *result = 0 ;
7865 double val1 ;
7866 int ecode1 = 0 ;
7867 double val2 ;
7868 int ecode2 = 0 ;
7869 PyObject * obj0 = 0 ;
7870 PyObject * obj1 = 0 ;
7871 char * kwnames[] = {
7872 (char *) "x",(char *) "y", NULL
7873 };
7874
7875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7876 if (obj0) {
7877 ecode1 = SWIG_AsVal_double(obj0, &val1);
7878 if (!SWIG_IsOK(ecode1)) {
7879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7880 }
7881 arg1 = static_cast< double >(val1);
7882 }
7883 if (obj1) {
7884 ecode2 = SWIG_AsVal_double(obj1, &val2);
7885 if (!SWIG_IsOK(ecode2)) {
7886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7887 }
7888 arg2 = static_cast< double >(val2);
7889 }
7890 {
7891 PyThreadState* __tstate = wxPyBeginAllowThreads();
7892 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7893 wxPyEndAllowThreads(__tstate);
7894 if (PyErr_Occurred()) SWIG_fail;
7895 }
7896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7897 return resultobj;
7898 fail:
7899 return NULL;
7900 }
7901
7902
7903 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7904 PyObject *resultobj = 0;
7905 wxPoint2D *arg1 = 0 ;
7906 wxPoint2D *result = 0 ;
7907 wxPoint2D temp1 ;
7908 PyObject * obj0 = 0 ;
7909 char * kwnames[] = {
7910 (char *) "pt", NULL
7911 };
7912
7913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
7914 {
7915 arg1 = &temp1;
7916 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
7917 }
7918 {
7919 PyThreadState* __tstate = wxPyBeginAllowThreads();
7920 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
7921 wxPyEndAllowThreads(__tstate);
7922 if (PyErr_Occurred()) SWIG_fail;
7923 }
7924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7925 return resultobj;
7926 fail:
7927 return NULL;
7928 }
7929
7930
7931 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7932 PyObject *resultobj = 0;
7933 wxPoint *arg1 = 0 ;
7934 wxPoint2D *result = 0 ;
7935 wxPoint temp1 ;
7936 PyObject * obj0 = 0 ;
7937 char * kwnames[] = {
7938 (char *) "pt", NULL
7939 };
7940
7941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
7942 {
7943 arg1 = &temp1;
7944 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
7945 }
7946 {
7947 PyThreadState* __tstate = wxPyBeginAllowThreads();
7948 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
7949 wxPyEndAllowThreads(__tstate);
7950 if (PyErr_Occurred()) SWIG_fail;
7951 }
7952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
7953 return resultobj;
7954 fail:
7955 return NULL;
7956 }
7957
7958
7959 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7960 PyObject *resultobj = 0;
7961 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7962 int *arg2 = (int *) 0 ;
7963 int *arg3 = (int *) 0 ;
7964 void *argp1 = 0 ;
7965 int res1 = 0 ;
7966 int temp2 ;
7967 int res2 = SWIG_TMPOBJ ;
7968 int temp3 ;
7969 int res3 = SWIG_TMPOBJ ;
7970 PyObject *swig_obj[1] ;
7971
7972 arg2 = &temp2;
7973 arg3 = &temp3;
7974 if (!args) SWIG_fail;
7975 swig_obj[0] = args;
7976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
7977 if (!SWIG_IsOK(res1)) {
7978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
7979 }
7980 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
7981 {
7982 PyThreadState* __tstate = wxPyBeginAllowThreads();
7983 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
7984 wxPyEndAllowThreads(__tstate);
7985 if (PyErr_Occurred()) SWIG_fail;
7986 }
7987 resultobj = SWIG_Py_Void();
7988 if (SWIG_IsTmpObj(res2)) {
7989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
7990 } else {
7991 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
7993 }
7994 if (SWIG_IsTmpObj(res3)) {
7995 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
7996 } else {
7997 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
7998 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
7999 }
8000 return resultobj;
8001 fail:
8002 return NULL;
8003 }
8004
8005
8006 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8007 PyObject *resultobj = 0;
8008 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8009 int *arg2 = (int *) 0 ;
8010 int *arg3 = (int *) 0 ;
8011 void *argp1 = 0 ;
8012 int res1 = 0 ;
8013 int temp2 ;
8014 int res2 = SWIG_TMPOBJ ;
8015 int temp3 ;
8016 int res3 = SWIG_TMPOBJ ;
8017 PyObject *swig_obj[1] ;
8018
8019 arg2 = &temp2;
8020 arg3 = &temp3;
8021 if (!args) SWIG_fail;
8022 swig_obj[0] = args;
8023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8024 if (!SWIG_IsOK(res1)) {
8025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8026 }
8027 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8028 {
8029 PyThreadState* __tstate = wxPyBeginAllowThreads();
8030 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8031 wxPyEndAllowThreads(__tstate);
8032 if (PyErr_Occurred()) SWIG_fail;
8033 }
8034 resultobj = SWIG_Py_Void();
8035 if (SWIG_IsTmpObj(res2)) {
8036 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8037 } else {
8038 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8039 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8040 }
8041 if (SWIG_IsTmpObj(res3)) {
8042 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8043 } else {
8044 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8045 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8046 }
8047 return resultobj;
8048 fail:
8049 return NULL;
8050 }
8051
8052
8053 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8054 PyObject *resultobj = 0;
8055 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8056 double result;
8057 void *argp1 = 0 ;
8058 int res1 = 0 ;
8059 PyObject *swig_obj[1] ;
8060
8061 if (!args) SWIG_fail;
8062 swig_obj[0] = args;
8063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8064 if (!SWIG_IsOK(res1)) {
8065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8066 }
8067 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8068 {
8069 PyThreadState* __tstate = wxPyBeginAllowThreads();
8070 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8071 wxPyEndAllowThreads(__tstate);
8072 if (PyErr_Occurred()) SWIG_fail;
8073 }
8074 resultobj = SWIG_From_double(static_cast< double >(result));
8075 return resultobj;
8076 fail:
8077 return NULL;
8078 }
8079
8080
8081 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8082 PyObject *resultobj = 0;
8083 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8084 double result;
8085 void *argp1 = 0 ;
8086 int res1 = 0 ;
8087 PyObject *swig_obj[1] ;
8088
8089 if (!args) SWIG_fail;
8090 swig_obj[0] = args;
8091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8092 if (!SWIG_IsOK(res1)) {
8093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8094 }
8095 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8096 {
8097 PyThreadState* __tstate = wxPyBeginAllowThreads();
8098 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8099 wxPyEndAllowThreads(__tstate);
8100 if (PyErr_Occurred()) SWIG_fail;
8101 }
8102 resultobj = SWIG_From_double(static_cast< double >(result));
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8110 PyObject *resultobj = 0;
8111 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8112 double arg2 ;
8113 void *argp1 = 0 ;
8114 int res1 = 0 ;
8115 double val2 ;
8116 int ecode2 = 0 ;
8117 PyObject * obj0 = 0 ;
8118 PyObject * obj1 = 0 ;
8119 char * kwnames[] = {
8120 (char *) "self",(char *) "length", NULL
8121 };
8122
8123 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8124 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8125 if (!SWIG_IsOK(res1)) {
8126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8127 }
8128 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8129 ecode2 = SWIG_AsVal_double(obj1, &val2);
8130 if (!SWIG_IsOK(ecode2)) {
8131 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8132 }
8133 arg2 = static_cast< double >(val2);
8134 {
8135 PyThreadState* __tstate = wxPyBeginAllowThreads();
8136 (arg1)->SetVectorLength(arg2);
8137 wxPyEndAllowThreads(__tstate);
8138 if (PyErr_Occurred()) SWIG_fail;
8139 }
8140 resultobj = SWIG_Py_Void();
8141 return resultobj;
8142 fail:
8143 return NULL;
8144 }
8145
8146
8147 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8148 PyObject *resultobj = 0;
8149 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8150 double arg2 ;
8151 void *argp1 = 0 ;
8152 int res1 = 0 ;
8153 double val2 ;
8154 int ecode2 = 0 ;
8155 PyObject * obj0 = 0 ;
8156 PyObject * obj1 = 0 ;
8157 char * kwnames[] = {
8158 (char *) "self",(char *) "degrees", NULL
8159 };
8160
8161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8163 if (!SWIG_IsOK(res1)) {
8164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8165 }
8166 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8167 ecode2 = SWIG_AsVal_double(obj1, &val2);
8168 if (!SWIG_IsOK(ecode2)) {
8169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8170 }
8171 arg2 = static_cast< double >(val2);
8172 {
8173 PyThreadState* __tstate = wxPyBeginAllowThreads();
8174 (arg1)->SetVectorAngle(arg2);
8175 wxPyEndAllowThreads(__tstate);
8176 if (PyErr_Occurred()) SWIG_fail;
8177 }
8178 resultobj = SWIG_Py_Void();
8179 return resultobj;
8180 fail:
8181 return NULL;
8182 }
8183
8184
8185 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8186 PyObject *resultobj = 0;
8187 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8188 wxPoint2D *arg2 = 0 ;
8189 double result;
8190 void *argp1 = 0 ;
8191 int res1 = 0 ;
8192 wxPoint2D temp2 ;
8193 PyObject * obj0 = 0 ;
8194 PyObject * obj1 = 0 ;
8195 char * kwnames[] = {
8196 (char *) "self",(char *) "pt", NULL
8197 };
8198
8199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8201 if (!SWIG_IsOK(res1)) {
8202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8203 }
8204 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8205 {
8206 arg2 = &temp2;
8207 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8208 }
8209 {
8210 PyThreadState* __tstate = wxPyBeginAllowThreads();
8211 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8212 wxPyEndAllowThreads(__tstate);
8213 if (PyErr_Occurred()) SWIG_fail;
8214 }
8215 resultobj = SWIG_From_double(static_cast< double >(result));
8216 return resultobj;
8217 fail:
8218 return NULL;
8219 }
8220
8221
8222 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8223 PyObject *resultobj = 0;
8224 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8225 wxPoint2D *arg2 = 0 ;
8226 double result;
8227 void *argp1 = 0 ;
8228 int res1 = 0 ;
8229 wxPoint2D temp2 ;
8230 PyObject * obj0 = 0 ;
8231 PyObject * obj1 = 0 ;
8232 char * kwnames[] = {
8233 (char *) "self",(char *) "pt", NULL
8234 };
8235
8236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8238 if (!SWIG_IsOK(res1)) {
8239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8240 }
8241 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8242 {
8243 arg2 = &temp2;
8244 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8245 }
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8249 wxPyEndAllowThreads(__tstate);
8250 if (PyErr_Occurred()) SWIG_fail;
8251 }
8252 resultobj = SWIG_From_double(static_cast< double >(result));
8253 return resultobj;
8254 fail:
8255 return NULL;
8256 }
8257
8258
8259 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8260 PyObject *resultobj = 0;
8261 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8262 wxPoint2D *arg2 = 0 ;
8263 double result;
8264 void *argp1 = 0 ;
8265 int res1 = 0 ;
8266 wxPoint2D temp2 ;
8267 PyObject * obj0 = 0 ;
8268 PyObject * obj1 = 0 ;
8269 char * kwnames[] = {
8270 (char *) "self",(char *) "vec", NULL
8271 };
8272
8273 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8274 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8275 if (!SWIG_IsOK(res1)) {
8276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8277 }
8278 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8279 {
8280 arg2 = &temp2;
8281 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8282 }
8283 {
8284 PyThreadState* __tstate = wxPyBeginAllowThreads();
8285 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8286 wxPyEndAllowThreads(__tstate);
8287 if (PyErr_Occurred()) SWIG_fail;
8288 }
8289 resultobj = SWIG_From_double(static_cast< double >(result));
8290 return resultobj;
8291 fail:
8292 return NULL;
8293 }
8294
8295
8296 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8297 PyObject *resultobj = 0;
8298 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8299 wxPoint2D *arg2 = 0 ;
8300 double result;
8301 void *argp1 = 0 ;
8302 int res1 = 0 ;
8303 wxPoint2D temp2 ;
8304 PyObject * obj0 = 0 ;
8305 PyObject * obj1 = 0 ;
8306 char * kwnames[] = {
8307 (char *) "self",(char *) "vec", NULL
8308 };
8309
8310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8312 if (!SWIG_IsOK(res1)) {
8313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8314 }
8315 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8316 {
8317 arg2 = &temp2;
8318 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8319 }
8320 {
8321 PyThreadState* __tstate = wxPyBeginAllowThreads();
8322 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8323 wxPyEndAllowThreads(__tstate);
8324 if (PyErr_Occurred()) SWIG_fail;
8325 }
8326 resultobj = SWIG_From_double(static_cast< double >(result));
8327 return resultobj;
8328 fail:
8329 return NULL;
8330 }
8331
8332
8333 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8334 PyObject *resultobj = 0;
8335 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8336 wxPoint2D result;
8337 void *argp1 = 0 ;
8338 int res1 = 0 ;
8339 PyObject *swig_obj[1] ;
8340
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___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8346 }
8347 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8348 {
8349 PyThreadState* __tstate = wxPyBeginAllowThreads();
8350 result = (arg1)->operator -();
8351 wxPyEndAllowThreads(__tstate);
8352 if (PyErr_Occurred()) SWIG_fail;
8353 }
8354 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8355 return resultobj;
8356 fail:
8357 return NULL;
8358 }
8359
8360
8361 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8362 PyObject *resultobj = 0;
8363 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8364 wxPoint2D *arg2 = 0 ;
8365 wxPoint2D *result = 0 ;
8366 void *argp1 = 0 ;
8367 int res1 = 0 ;
8368 wxPoint2D temp2 ;
8369 PyObject * obj0 = 0 ;
8370 PyObject * obj1 = 0 ;
8371 char * kwnames[] = {
8372 (char *) "self",(char *) "pt", NULL
8373 };
8374
8375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8376 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8377 if (!SWIG_IsOK(res1)) {
8378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8379 }
8380 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8381 {
8382 arg2 = &temp2;
8383 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 {
8388 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8389 result = (wxPoint2D *) &_result_ref;
8390 }
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8395 return resultobj;
8396 fail:
8397 return NULL;
8398 }
8399
8400
8401 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8402 PyObject *resultobj = 0;
8403 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8404 wxPoint2D *arg2 = 0 ;
8405 wxPoint2D *result = 0 ;
8406 void *argp1 = 0 ;
8407 int res1 = 0 ;
8408 wxPoint2D temp2 ;
8409 PyObject * obj0 = 0 ;
8410 PyObject * obj1 = 0 ;
8411 char * kwnames[] = {
8412 (char *) "self",(char *) "pt", NULL
8413 };
8414
8415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8417 if (!SWIG_IsOK(res1)) {
8418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8419 }
8420 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8421 {
8422 arg2 = &temp2;
8423 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8424 }
8425 {
8426 PyThreadState* __tstate = wxPyBeginAllowThreads();
8427 {
8428 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8429 result = (wxPoint2D *) &_result_ref;
8430 }
8431 wxPyEndAllowThreads(__tstate);
8432 if (PyErr_Occurred()) SWIG_fail;
8433 }
8434 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8435 return resultobj;
8436 fail:
8437 return NULL;
8438 }
8439
8440
8441 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8442 PyObject *resultobj = 0;
8443 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8444 wxPoint2D *arg2 = 0 ;
8445 wxPoint2D *result = 0 ;
8446 void *argp1 = 0 ;
8447 int res1 = 0 ;
8448 wxPoint2D temp2 ;
8449 PyObject * obj0 = 0 ;
8450 PyObject * obj1 = 0 ;
8451 char * kwnames[] = {
8452 (char *) "self",(char *) "pt", NULL
8453 };
8454
8455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8457 if (!SWIG_IsOK(res1)) {
8458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8459 }
8460 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8461 {
8462 arg2 = &temp2;
8463 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8464 }
8465 {
8466 PyThreadState* __tstate = wxPyBeginAllowThreads();
8467 {
8468 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8469 result = (wxPoint2D *) &_result_ref;
8470 }
8471 wxPyEndAllowThreads(__tstate);
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8482 PyObject *resultobj = 0;
8483 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8484 wxPoint2D *arg2 = 0 ;
8485 wxPoint2D *result = 0 ;
8486 void *argp1 = 0 ;
8487 int res1 = 0 ;
8488 wxPoint2D temp2 ;
8489 PyObject * obj0 = 0 ;
8490 PyObject * obj1 = 0 ;
8491 char * kwnames[] = {
8492 (char *) "self",(char *) "pt", NULL
8493 };
8494
8495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8499 }
8500 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8501 {
8502 arg2 = &temp2;
8503 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8504 }
8505 {
8506 PyThreadState* __tstate = wxPyBeginAllowThreads();
8507 {
8508 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8509 result = (wxPoint2D *) &_result_ref;
8510 }
8511 wxPyEndAllowThreads(__tstate);
8512 if (PyErr_Occurred()) SWIG_fail;
8513 }
8514 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8515 return resultobj;
8516 fail:
8517 return NULL;
8518 }
8519
8520
8521 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8522 PyObject *resultobj = 0;
8523 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8524 wxPoint2D *arg2 = 0 ;
8525 bool result;
8526 void *argp1 = 0 ;
8527 int res1 = 0 ;
8528 wxPoint2D temp2 ;
8529 PyObject * obj0 = 0 ;
8530 PyObject * obj1 = 0 ;
8531 char * kwnames[] = {
8532 (char *) "self",(char *) "pt", NULL
8533 };
8534
8535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8537 if (!SWIG_IsOK(res1)) {
8538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8539 }
8540 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8541 {
8542 arg2 = &temp2;
8543 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8544 }
8545 {
8546 PyThreadState* __tstate = wxPyBeginAllowThreads();
8547 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
8548 wxPyEndAllowThreads(__tstate);
8549 if (PyErr_Occurred()) SWIG_fail;
8550 }
8551 {
8552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8553 }
8554 return resultobj;
8555 fail:
8556 return NULL;
8557 }
8558
8559
8560 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8561 PyObject *resultobj = 0;
8562 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8563 wxPoint2D *arg2 = 0 ;
8564 bool result;
8565 void *argp1 = 0 ;
8566 int res1 = 0 ;
8567 wxPoint2D temp2 ;
8568 PyObject * obj0 = 0 ;
8569 PyObject * obj1 = 0 ;
8570 char * kwnames[] = {
8571 (char *) "self",(char *) "pt", NULL
8572 };
8573
8574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8576 if (!SWIG_IsOK(res1)) {
8577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8578 }
8579 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8580 {
8581 arg2 = &temp2;
8582 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8583 }
8584 {
8585 PyThreadState* __tstate = wxPyBeginAllowThreads();
8586 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
8587 wxPyEndAllowThreads(__tstate);
8588 if (PyErr_Occurred()) SWIG_fail;
8589 }
8590 {
8591 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8592 }
8593 return resultobj;
8594 fail:
8595 return NULL;
8596 }
8597
8598
8599 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8600 PyObject *resultobj = 0;
8601 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8602 double arg2 ;
8603 void *argp1 = 0 ;
8604 int res1 = 0 ;
8605 double val2 ;
8606 int ecode2 = 0 ;
8607 PyObject *swig_obj[2] ;
8608
8609 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8611 if (!SWIG_IsOK(res1)) {
8612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8613 }
8614 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8615 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8616 if (!SWIG_IsOK(ecode2)) {
8617 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8618 }
8619 arg2 = static_cast< double >(val2);
8620 if (arg1) (arg1)->m_x = arg2;
8621
8622 resultobj = SWIG_Py_Void();
8623 return resultobj;
8624 fail:
8625 return NULL;
8626 }
8627
8628
8629 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8630 PyObject *resultobj = 0;
8631 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8632 double result;
8633 void *argp1 = 0 ;
8634 int res1 = 0 ;
8635 PyObject *swig_obj[1] ;
8636
8637 if (!args) SWIG_fail;
8638 swig_obj[0] = args;
8639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8640 if (!SWIG_IsOK(res1)) {
8641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8642 }
8643 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8644 result = (double) ((arg1)->m_x);
8645 resultobj = SWIG_From_double(static_cast< double >(result));
8646 return resultobj;
8647 fail:
8648 return NULL;
8649 }
8650
8651
8652 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8653 PyObject *resultobj = 0;
8654 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8655 double arg2 ;
8656 void *argp1 = 0 ;
8657 int res1 = 0 ;
8658 double val2 ;
8659 int ecode2 = 0 ;
8660 PyObject *swig_obj[2] ;
8661
8662 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8664 if (!SWIG_IsOK(res1)) {
8665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8666 }
8667 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8668 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8669 if (!SWIG_IsOK(ecode2)) {
8670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8671 }
8672 arg2 = static_cast< double >(val2);
8673 if (arg1) (arg1)->m_y = arg2;
8674
8675 resultobj = SWIG_Py_Void();
8676 return resultobj;
8677 fail:
8678 return NULL;
8679 }
8680
8681
8682 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8683 PyObject *resultobj = 0;
8684 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8685 double result;
8686 void *argp1 = 0 ;
8687 int res1 = 0 ;
8688 PyObject *swig_obj[1] ;
8689
8690 if (!args) SWIG_fail;
8691 swig_obj[0] = args;
8692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8693 if (!SWIG_IsOK(res1)) {
8694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8695 }
8696 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8697 result = (double) ((arg1)->m_y);
8698 resultobj = SWIG_From_double(static_cast< double >(result));
8699 return resultobj;
8700 fail:
8701 return NULL;
8702 }
8703
8704
8705 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8706 PyObject *resultobj = 0;
8707 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8708 double arg2 = (double) 0 ;
8709 double arg3 = (double) 0 ;
8710 void *argp1 = 0 ;
8711 int res1 = 0 ;
8712 double val2 ;
8713 int ecode2 = 0 ;
8714 double val3 ;
8715 int ecode3 = 0 ;
8716 PyObject * obj0 = 0 ;
8717 PyObject * obj1 = 0 ;
8718 PyObject * obj2 = 0 ;
8719 char * kwnames[] = {
8720 (char *) "self",(char *) "x",(char *) "y", NULL
8721 };
8722
8723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8725 if (!SWIG_IsOK(res1)) {
8726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8727 }
8728 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8729 if (obj1) {
8730 ecode2 = SWIG_AsVal_double(obj1, &val2);
8731 if (!SWIG_IsOK(ecode2)) {
8732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8733 }
8734 arg2 = static_cast< double >(val2);
8735 }
8736 if (obj2) {
8737 ecode3 = SWIG_AsVal_double(obj2, &val3);
8738 if (!SWIG_IsOK(ecode3)) {
8739 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8740 }
8741 arg3 = static_cast< double >(val3);
8742 }
8743 {
8744 PyThreadState* __tstate = wxPyBeginAllowThreads();
8745 wxPoint2D_Set(arg1,arg2,arg3);
8746 wxPyEndAllowThreads(__tstate);
8747 if (PyErr_Occurred()) SWIG_fail;
8748 }
8749 resultobj = SWIG_Py_Void();
8750 return resultobj;
8751 fail:
8752 return NULL;
8753 }
8754
8755
8756 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8757 PyObject *resultobj = 0;
8758 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8759 PyObject *result = 0 ;
8760 void *argp1 = 0 ;
8761 int res1 = 0 ;
8762 PyObject *swig_obj[1] ;
8763
8764 if (!args) SWIG_fail;
8765 swig_obj[0] = args;
8766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8767 if (!SWIG_IsOK(res1)) {
8768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8769 }
8770 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8771 {
8772 PyThreadState* __tstate = wxPyBeginAllowThreads();
8773 result = (PyObject *)wxPoint2D_Get(arg1);
8774 wxPyEndAllowThreads(__tstate);
8775 if (PyErr_Occurred()) SWIG_fail;
8776 }
8777 resultobj = result;
8778 return resultobj;
8779 fail:
8780 return NULL;
8781 }
8782
8783
8784 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8785 PyObject *obj;
8786 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8787 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8788 return SWIG_Py_Void();
8789 }
8790
8791 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8792 return SWIG_Python_InitShadowInstance(args);
8793 }
8794
8795 SWIGINTERN int DefaultPosition_set(PyObject *) {
8796 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8797 return 1;
8798 }
8799
8800
8801 SWIGINTERN PyObject *DefaultPosition_get(void) {
8802 PyObject *pyobj = 0;
8803
8804 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8805 return pyobj;
8806 }
8807
8808
8809 SWIGINTERN int DefaultSize_set(PyObject *) {
8810 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8811 return 1;
8812 }
8813
8814
8815 SWIGINTERN PyObject *DefaultSize_get(void) {
8816 PyObject *pyobj = 0;
8817
8818 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8819 return pyobj;
8820 }
8821
8822
8823 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj = 0;
8825 PyObject *arg1 = (PyObject *) 0 ;
8826 wxPyInputStream *result = 0 ;
8827 PyObject * obj0 = 0 ;
8828 char * kwnames[] = {
8829 (char *) "p", NULL
8830 };
8831
8832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8833 arg1 = obj0;
8834 {
8835 PyThreadState* __tstate = wxPyBeginAllowThreads();
8836 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8837 wxPyEndAllowThreads(__tstate);
8838 if (PyErr_Occurred()) SWIG_fail;
8839 }
8840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8848 PyObject *resultobj = 0;
8849 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8850 void *argp1 = 0 ;
8851 int res1 = 0 ;
8852 PyObject *swig_obj[1] ;
8853
8854 if (!args) SWIG_fail;
8855 swig_obj[0] = args;
8856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8857 if (!SWIG_IsOK(res1)) {
8858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8859 }
8860 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8861 {
8862 PyThreadState* __tstate = wxPyBeginAllowThreads();
8863 delete arg1;
8864
8865 wxPyEndAllowThreads(__tstate);
8866 if (PyErr_Occurred()) SWIG_fail;
8867 }
8868 resultobj = SWIG_Py_Void();
8869 return resultobj;
8870 fail:
8871 return NULL;
8872 }
8873
8874
8875 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8876 PyObject *resultobj = 0;
8877 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8878 void *argp1 = 0 ;
8879 int res1 = 0 ;
8880 PyObject *swig_obj[1] ;
8881
8882 if (!args) SWIG_fail;
8883 swig_obj[0] = args;
8884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8885 if (!SWIG_IsOK(res1)) {
8886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8887 }
8888 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8889 {
8890 PyThreadState* __tstate = wxPyBeginAllowThreads();
8891 (arg1)->close();
8892 wxPyEndAllowThreads(__tstate);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 resultobj = SWIG_Py_Void();
8896 return resultobj;
8897 fail:
8898 return NULL;
8899 }
8900
8901
8902 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8903 PyObject *resultobj = 0;
8904 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8905 void *argp1 = 0 ;
8906 int res1 = 0 ;
8907 PyObject *swig_obj[1] ;
8908
8909 if (!args) SWIG_fail;
8910 swig_obj[0] = args;
8911 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8912 if (!SWIG_IsOK(res1)) {
8913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8914 }
8915 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8916 {
8917 PyThreadState* __tstate = wxPyBeginAllowThreads();
8918 (arg1)->flush();
8919 wxPyEndAllowThreads(__tstate);
8920 if (PyErr_Occurred()) SWIG_fail;
8921 }
8922 resultobj = SWIG_Py_Void();
8923 return resultobj;
8924 fail:
8925 return NULL;
8926 }
8927
8928
8929 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8930 PyObject *resultobj = 0;
8931 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8932 bool result;
8933 void *argp1 = 0 ;
8934 int res1 = 0 ;
8935 PyObject *swig_obj[1] ;
8936
8937 if (!args) SWIG_fail;
8938 swig_obj[0] = args;
8939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8940 if (!SWIG_IsOK(res1)) {
8941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8942 }
8943 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8944 {
8945 PyThreadState* __tstate = wxPyBeginAllowThreads();
8946 result = (bool)(arg1)->eof();
8947 wxPyEndAllowThreads(__tstate);
8948 if (PyErr_Occurred()) SWIG_fail;
8949 }
8950 {
8951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8952 }
8953 return resultobj;
8954 fail:
8955 return NULL;
8956 }
8957
8958
8959 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8960 PyObject *resultobj = 0;
8961 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8962 int arg2 = (int) -1 ;
8963 PyObject *result = 0 ;
8964 void *argp1 = 0 ;
8965 int res1 = 0 ;
8966 int val2 ;
8967 int ecode2 = 0 ;
8968 PyObject * obj0 = 0 ;
8969 PyObject * obj1 = 0 ;
8970 char * kwnames[] = {
8971 (char *) "self",(char *) "size", NULL
8972 };
8973
8974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
8975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8976 if (!SWIG_IsOK(res1)) {
8977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8978 }
8979 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8980 if (obj1) {
8981 ecode2 = SWIG_AsVal_int(obj1, &val2);
8982 if (!SWIG_IsOK(ecode2)) {
8983 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
8984 }
8985 arg2 = static_cast< int >(val2);
8986 }
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 result = (PyObject *)(arg1)->read(arg2);
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 resultobj = result;
8994 return resultobj;
8995 fail:
8996 return NULL;
8997 }
8998
8999
9000 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9001 PyObject *resultobj = 0;
9002 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9003 int arg2 = (int) -1 ;
9004 PyObject *result = 0 ;
9005 void *argp1 = 0 ;
9006 int res1 = 0 ;
9007 int val2 ;
9008 int ecode2 = 0 ;
9009 PyObject * obj0 = 0 ;
9010 PyObject * obj1 = 0 ;
9011 char * kwnames[] = {
9012 (char *) "self",(char *) "size", NULL
9013 };
9014
9015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9017 if (!SWIG_IsOK(res1)) {
9018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9019 }
9020 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9021 if (obj1) {
9022 ecode2 = SWIG_AsVal_int(obj1, &val2);
9023 if (!SWIG_IsOK(ecode2)) {
9024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9025 }
9026 arg2 = static_cast< int >(val2);
9027 }
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 result = (PyObject *)(arg1)->readline(arg2);
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 resultobj = result;
9035 return resultobj;
9036 fail:
9037 return NULL;
9038 }
9039
9040
9041 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9042 PyObject *resultobj = 0;
9043 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9044 int arg2 = (int) -1 ;
9045 PyObject *result = 0 ;
9046 void *argp1 = 0 ;
9047 int res1 = 0 ;
9048 int val2 ;
9049 int ecode2 = 0 ;
9050 PyObject * obj0 = 0 ;
9051 PyObject * obj1 = 0 ;
9052 char * kwnames[] = {
9053 (char *) "self",(char *) "sizehint", NULL
9054 };
9055
9056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9058 if (!SWIG_IsOK(res1)) {
9059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9060 }
9061 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9062 if (obj1) {
9063 ecode2 = SWIG_AsVal_int(obj1, &val2);
9064 if (!SWIG_IsOK(ecode2)) {
9065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9066 }
9067 arg2 = static_cast< int >(val2);
9068 }
9069 {
9070 PyThreadState* __tstate = wxPyBeginAllowThreads();
9071 result = (PyObject *)(arg1)->readlines(arg2);
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 resultobj = result;
9076 return resultobj;
9077 fail:
9078 return NULL;
9079 }
9080
9081
9082 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9083 PyObject *resultobj = 0;
9084 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9085 int arg2 ;
9086 int arg3 = (int) 0 ;
9087 void *argp1 = 0 ;
9088 int res1 = 0 ;
9089 int val2 ;
9090 int ecode2 = 0 ;
9091 int val3 ;
9092 int ecode3 = 0 ;
9093 PyObject * obj0 = 0 ;
9094 PyObject * obj1 = 0 ;
9095 PyObject * obj2 = 0 ;
9096 char * kwnames[] = {
9097 (char *) "self",(char *) "offset",(char *) "whence", NULL
9098 };
9099
9100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9102 if (!SWIG_IsOK(res1)) {
9103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9104 }
9105 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9106 ecode2 = SWIG_AsVal_int(obj1, &val2);
9107 if (!SWIG_IsOK(ecode2)) {
9108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9109 }
9110 arg2 = static_cast< int >(val2);
9111 if (obj2) {
9112 ecode3 = SWIG_AsVal_int(obj2, &val3);
9113 if (!SWIG_IsOK(ecode3)) {
9114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9115 }
9116 arg3 = static_cast< int >(val3);
9117 }
9118 {
9119 PyThreadState* __tstate = wxPyBeginAllowThreads();
9120 (arg1)->seek(arg2,arg3);
9121 wxPyEndAllowThreads(__tstate);
9122 if (PyErr_Occurred()) SWIG_fail;
9123 }
9124 resultobj = SWIG_Py_Void();
9125 return resultobj;
9126 fail:
9127 return NULL;
9128 }
9129
9130
9131 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9132 PyObject *resultobj = 0;
9133 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9134 int result;
9135 void *argp1 = 0 ;
9136 int res1 = 0 ;
9137 PyObject *swig_obj[1] ;
9138
9139 if (!args) SWIG_fail;
9140 swig_obj[0] = args;
9141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9142 if (!SWIG_IsOK(res1)) {
9143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9144 }
9145 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9146 {
9147 PyThreadState* __tstate = wxPyBeginAllowThreads();
9148 result = (int)(arg1)->tell();
9149 wxPyEndAllowThreads(__tstate);
9150 if (PyErr_Occurred()) SWIG_fail;
9151 }
9152 resultobj = SWIG_From_int(static_cast< int >(result));
9153 return resultobj;
9154 fail:
9155 return NULL;
9156 }
9157
9158
9159 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9160 PyObject *resultobj = 0;
9161 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9162 char result;
9163 void *argp1 = 0 ;
9164 int res1 = 0 ;
9165 PyObject *swig_obj[1] ;
9166
9167 if (!args) SWIG_fail;
9168 swig_obj[0] = args;
9169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9170 if (!SWIG_IsOK(res1)) {
9171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9172 }
9173 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9174 {
9175 PyThreadState* __tstate = wxPyBeginAllowThreads();
9176 result = (char)(arg1)->Peek();
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 resultobj = SWIG_From_char(static_cast< char >(result));
9181 return resultobj;
9182 fail:
9183 return NULL;
9184 }
9185
9186
9187 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9188 PyObject *resultobj = 0;
9189 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9190 char result;
9191 void *argp1 = 0 ;
9192 int res1 = 0 ;
9193 PyObject *swig_obj[1] ;
9194
9195 if (!args) SWIG_fail;
9196 swig_obj[0] = args;
9197 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9198 if (!SWIG_IsOK(res1)) {
9199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9200 }
9201 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9202 {
9203 PyThreadState* __tstate = wxPyBeginAllowThreads();
9204 result = (char)(arg1)->GetC();
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_From_char(static_cast< char >(result));
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9218 size_t result;
9219 void *argp1 = 0 ;
9220 int res1 = 0 ;
9221 PyObject *swig_obj[1] ;
9222
9223 if (!args) SWIG_fail;
9224 swig_obj[0] = args;
9225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9226 if (!SWIG_IsOK(res1)) {
9227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9228 }
9229 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 result = (size_t)(arg1)->LastRead();
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 PyObject *resultobj = 0;
9245 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9246 bool result;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 PyObject *swig_obj[1] ;
9250
9251 if (!args) SWIG_fail;
9252 swig_obj[0] = args;
9253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9254 if (!SWIG_IsOK(res1)) {
9255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9256 }
9257 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9258 {
9259 PyThreadState* __tstate = wxPyBeginAllowThreads();
9260 result = (bool)(arg1)->CanRead();
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 {
9265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9266 }
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 PyObject *resultobj = 0;
9275 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9276 bool result;
9277 void *argp1 = 0 ;
9278 int res1 = 0 ;
9279 PyObject *swig_obj[1] ;
9280
9281 if (!args) SWIG_fail;
9282 swig_obj[0] = args;
9283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9284 if (!SWIG_IsOK(res1)) {
9285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9286 }
9287 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (bool)(arg1)->Eof();
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 {
9295 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9296 }
9297 return resultobj;
9298 fail:
9299 return NULL;
9300 }
9301
9302
9303 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9304 PyObject *resultobj = 0;
9305 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9306 char arg2 ;
9307 bool result;
9308 void *argp1 = 0 ;
9309 int res1 = 0 ;
9310 char val2 ;
9311 int ecode2 = 0 ;
9312 PyObject * obj0 = 0 ;
9313 PyObject * obj1 = 0 ;
9314 char * kwnames[] = {
9315 (char *) "self",(char *) "c", NULL
9316 };
9317
9318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9320 if (!SWIG_IsOK(res1)) {
9321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9322 }
9323 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9324 ecode2 = SWIG_AsVal_char(obj1, &val2);
9325 if (!SWIG_IsOK(ecode2)) {
9326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9327 }
9328 arg2 = static_cast< char >(val2);
9329 {
9330 PyThreadState* __tstate = wxPyBeginAllowThreads();
9331 result = (bool)(arg1)->Ungetch(arg2);
9332 wxPyEndAllowThreads(__tstate);
9333 if (PyErr_Occurred()) SWIG_fail;
9334 }
9335 {
9336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9337 }
9338 return resultobj;
9339 fail:
9340 return NULL;
9341 }
9342
9343
9344 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9345 PyObject *resultobj = 0;
9346 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9347 long arg2 ;
9348 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9349 long result;
9350 void *argp1 = 0 ;
9351 int res1 = 0 ;
9352 long val2 ;
9353 int ecode2 = 0 ;
9354 int val3 ;
9355 int ecode3 = 0 ;
9356 PyObject * obj0 = 0 ;
9357 PyObject * obj1 = 0 ;
9358 PyObject * obj2 = 0 ;
9359 char * kwnames[] = {
9360 (char *) "self",(char *) "pos",(char *) "mode", NULL
9361 };
9362
9363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9365 if (!SWIG_IsOK(res1)) {
9366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9367 }
9368 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9369 ecode2 = SWIG_AsVal_long(obj1, &val2);
9370 if (!SWIG_IsOK(ecode2)) {
9371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9372 }
9373 arg2 = static_cast< long >(val2);
9374 if (obj2) {
9375 ecode3 = SWIG_AsVal_int(obj2, &val3);
9376 if (!SWIG_IsOK(ecode3)) {
9377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9378 }
9379 arg3 = static_cast< wxSeekMode >(val3);
9380 }
9381 {
9382 PyThreadState* __tstate = wxPyBeginAllowThreads();
9383 result = (long)(arg1)->SeekI(arg2,arg3);
9384 wxPyEndAllowThreads(__tstate);
9385 if (PyErr_Occurred()) SWIG_fail;
9386 }
9387 resultobj = SWIG_From_long(static_cast< long >(result));
9388 return resultobj;
9389 fail:
9390 return NULL;
9391 }
9392
9393
9394 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9395 PyObject *resultobj = 0;
9396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9397 long result;
9398 void *argp1 = 0 ;
9399 int res1 = 0 ;
9400 PyObject *swig_obj[1] ;
9401
9402 if (!args) SWIG_fail;
9403 swig_obj[0] = args;
9404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9405 if (!SWIG_IsOK(res1)) {
9406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9407 }
9408 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9409 {
9410 PyThreadState* __tstate = wxPyBeginAllowThreads();
9411 result = (long)(arg1)->TellI();
9412 wxPyEndAllowThreads(__tstate);
9413 if (PyErr_Occurred()) SWIG_fail;
9414 }
9415 resultobj = SWIG_From_long(static_cast< long >(result));
9416 return resultobj;
9417 fail:
9418 return NULL;
9419 }
9420
9421
9422 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9423 PyObject *obj;
9424 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9425 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9426 return SWIG_Py_Void();
9427 }
9428
9429 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9430 return SWIG_Python_InitShadowInstance(args);
9431 }
9432
9433 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9434 PyObject *resultobj = 0;
9435 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9436 PyObject *arg2 = (PyObject *) 0 ;
9437 void *argp1 = 0 ;
9438 int res1 = 0 ;
9439 PyObject * obj0 = 0 ;
9440 PyObject * obj1 = 0 ;
9441 char * kwnames[] = {
9442 (char *) "self",(char *) "obj", NULL
9443 };
9444
9445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9447 if (!SWIG_IsOK(res1)) {
9448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9449 }
9450 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9451 arg2 = obj1;
9452 {
9453 PyThreadState* __tstate = wxPyBeginAllowThreads();
9454 wxOutputStream_write(arg1,arg2);
9455 wxPyEndAllowThreads(__tstate);
9456 if (PyErr_Occurred()) SWIG_fail;
9457 }
9458 resultobj = SWIG_Py_Void();
9459 return resultobj;
9460 fail:
9461 return NULL;
9462 }
9463
9464
9465 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9466 PyObject *resultobj = 0;
9467 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9468 size_t result;
9469 void *argp1 = 0 ;
9470 int res1 = 0 ;
9471 PyObject *swig_obj[1] ;
9472
9473 if (!args) SWIG_fail;
9474 swig_obj[0] = args;
9475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9476 if (!SWIG_IsOK(res1)) {
9477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9478 }
9479 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9480 {
9481 PyThreadState* __tstate = wxPyBeginAllowThreads();
9482 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9483 wxPyEndAllowThreads(__tstate);
9484 if (PyErr_Occurred()) SWIG_fail;
9485 }
9486 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9487 return resultobj;
9488 fail:
9489 return NULL;
9490 }
9491
9492
9493 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9494 PyObject *obj;
9495 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9496 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9497 return SWIG_Py_Void();
9498 }
9499
9500 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9501 PyObject *resultobj = 0;
9502 wxInputStream *arg1 = (wxInputStream *) 0 ;
9503 wxString *arg2 = 0 ;
9504 wxString *arg3 = 0 ;
9505 wxString *arg4 = 0 ;
9506 wxDateTime arg5 ;
9507 wxFSFile *result = 0 ;
9508 wxPyInputStream *temp1 ;
9509 bool temp2 = false ;
9510 bool temp3 = false ;
9511 bool temp4 = false ;
9512 void *argp5 ;
9513 int res5 = 0 ;
9514 PyObject * obj0 = 0 ;
9515 PyObject * obj1 = 0 ;
9516 PyObject * obj2 = 0 ;
9517 PyObject * obj3 = 0 ;
9518 PyObject * obj4 = 0 ;
9519 char * kwnames[] = {
9520 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9521 };
9522
9523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9524 {
9525 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9526 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9527 } else {
9528 PyErr_Clear(); // clear the failure of the wxPyConvert above
9529 arg1 = wxPyCBInputStream_create(obj0, true);
9530 if (arg1 == NULL) {
9531 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9532 SWIG_fail;
9533 }
9534 }
9535 }
9536 {
9537 arg2 = wxString_in_helper(obj1);
9538 if (arg2 == NULL) SWIG_fail;
9539 temp2 = true;
9540 }
9541 {
9542 arg3 = wxString_in_helper(obj2);
9543 if (arg3 == NULL) SWIG_fail;
9544 temp3 = true;
9545 }
9546 {
9547 arg4 = wxString_in_helper(obj3);
9548 if (arg4 == NULL) SWIG_fail;
9549 temp4 = true;
9550 }
9551 {
9552 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9553 if (!SWIG_IsOK(res5)) {
9554 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9555 }
9556 if (!argp5) {
9557 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9558 } else {
9559 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9560 arg5 = *temp;
9561 if (SWIG_IsNewObj(res5)) delete temp;
9562 }
9563 }
9564 {
9565 PyThreadState* __tstate = wxPyBeginAllowThreads();
9566 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 {
9571 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9572 }
9573 {
9574 if (temp2)
9575 delete arg2;
9576 }
9577 {
9578 if (temp3)
9579 delete arg3;
9580 }
9581 {
9582 if (temp4)
9583 delete arg4;
9584 }
9585 return resultobj;
9586 fail:
9587 {
9588 if (temp2)
9589 delete arg2;
9590 }
9591 {
9592 if (temp3)
9593 delete arg3;
9594 }
9595 {
9596 if (temp4)
9597 delete arg4;
9598 }
9599 return NULL;
9600 }
9601
9602
9603 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9604 PyObject *resultobj = 0;
9605 wxFSFile *arg1 = (wxFSFile *) 0 ;
9606 void *argp1 = 0 ;
9607 int res1 = 0 ;
9608 PyObject *swig_obj[1] ;
9609
9610 if (!args) SWIG_fail;
9611 swig_obj[0] = args;
9612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9613 if (!SWIG_IsOK(res1)) {
9614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9615 }
9616 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9617 {
9618 PyThreadState* __tstate = wxPyBeginAllowThreads();
9619 delete arg1;
9620
9621 wxPyEndAllowThreads(__tstate);
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_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9632 PyObject *resultobj = 0;
9633 wxFSFile *arg1 = (wxFSFile *) 0 ;
9634 wxInputStream *result = 0 ;
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_wxFSFile, 0 | 0 );
9642 if (!SWIG_IsOK(res1)) {
9643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9644 }
9645 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9646 {
9647 PyThreadState* __tstate = wxPyBeginAllowThreads();
9648 result = (wxInputStream *)(arg1)->GetStream();
9649 wxPyEndAllowThreads(__tstate);
9650 if (PyErr_Occurred()) SWIG_fail;
9651 }
9652 {
9653 wxPyInputStream * _ptr = NULL;
9654
9655 if (result) {
9656 _ptr = new wxPyInputStream(result);
9657 }
9658 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9659 }
9660 return resultobj;
9661 fail:
9662 return NULL;
9663 }
9664
9665
9666 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9667 PyObject *resultobj = 0;
9668 wxFSFile *arg1 = (wxFSFile *) 0 ;
9669 wxString *result = 0 ;
9670 void *argp1 = 0 ;
9671 int res1 = 0 ;
9672 PyObject *swig_obj[1] ;
9673
9674 if (!args) SWIG_fail;
9675 swig_obj[0] = args;
9676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9677 if (!SWIG_IsOK(res1)) {
9678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9679 }
9680 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9681 {
9682 PyThreadState* __tstate = wxPyBeginAllowThreads();
9683 {
9684 wxString const &_result_ref = (arg1)->GetMimeType();
9685 result = (wxString *) &_result_ref;
9686 }
9687 wxPyEndAllowThreads(__tstate);
9688 if (PyErr_Occurred()) SWIG_fail;
9689 }
9690 {
9691 #if wxUSE_UNICODE
9692 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9693 #else
9694 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9695 #endif
9696 }
9697 return resultobj;
9698 fail:
9699 return NULL;
9700 }
9701
9702
9703 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9704 PyObject *resultobj = 0;
9705 wxFSFile *arg1 = (wxFSFile *) 0 ;
9706 wxString *result = 0 ;
9707 void *argp1 = 0 ;
9708 int res1 = 0 ;
9709 PyObject *swig_obj[1] ;
9710
9711 if (!args) SWIG_fail;
9712 swig_obj[0] = args;
9713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9714 if (!SWIG_IsOK(res1)) {
9715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9716 }
9717 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9718 {
9719 PyThreadState* __tstate = wxPyBeginAllowThreads();
9720 {
9721 wxString const &_result_ref = (arg1)->GetLocation();
9722 result = (wxString *) &_result_ref;
9723 }
9724 wxPyEndAllowThreads(__tstate);
9725 if (PyErr_Occurred()) SWIG_fail;
9726 }
9727 {
9728 #if wxUSE_UNICODE
9729 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9730 #else
9731 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9732 #endif
9733 }
9734 return resultobj;
9735 fail:
9736 return NULL;
9737 }
9738
9739
9740 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9741 PyObject *resultobj = 0;
9742 wxFSFile *arg1 = (wxFSFile *) 0 ;
9743 wxString *result = 0 ;
9744 void *argp1 = 0 ;
9745 int res1 = 0 ;
9746 PyObject *swig_obj[1] ;
9747
9748 if (!args) SWIG_fail;
9749 swig_obj[0] = args;
9750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9751 if (!SWIG_IsOK(res1)) {
9752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9753 }
9754 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9755 {
9756 PyThreadState* __tstate = wxPyBeginAllowThreads();
9757 {
9758 wxString const &_result_ref = (arg1)->GetAnchor();
9759 result = (wxString *) &_result_ref;
9760 }
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 {
9765 #if wxUSE_UNICODE
9766 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9767 #else
9768 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9769 #endif
9770 }
9771 return resultobj;
9772 fail:
9773 return NULL;
9774 }
9775
9776
9777 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9778 PyObject *resultobj = 0;
9779 wxFSFile *arg1 = (wxFSFile *) 0 ;
9780 wxDateTime result;
9781 void *argp1 = 0 ;
9782 int res1 = 0 ;
9783 PyObject *swig_obj[1] ;
9784
9785 if (!args) SWIG_fail;
9786 swig_obj[0] = args;
9787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9788 if (!SWIG_IsOK(res1)) {
9789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9790 }
9791 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9792 {
9793 PyThreadState* __tstate = wxPyBeginAllowThreads();
9794 result = (arg1)->GetModificationTime();
9795 wxPyEndAllowThreads(__tstate);
9796 if (PyErr_Occurred()) SWIG_fail;
9797 }
9798 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9799 return resultobj;
9800 fail:
9801 return NULL;
9802 }
9803
9804
9805 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9806 PyObject *obj;
9807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9808 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9809 return SWIG_Py_Void();
9810 }
9811
9812 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9813 return SWIG_Python_InitShadowInstance(args);
9814 }
9815
9816 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9817 PyObject *obj;
9818 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9819 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9820 return SWIG_Py_Void();
9821 }
9822
9823 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9824 PyObject *resultobj = 0;
9825 wxPyFileSystemHandler *result = 0 ;
9826
9827 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9828 {
9829 PyThreadState* __tstate = wxPyBeginAllowThreads();
9830 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9831 wxPyEndAllowThreads(__tstate);
9832 if (PyErr_Occurred()) SWIG_fail;
9833 }
9834 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9835 return resultobj;
9836 fail:
9837 return NULL;
9838 }
9839
9840
9841 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9842 PyObject *resultobj = 0;
9843 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9844 PyObject *arg2 = (PyObject *) 0 ;
9845 PyObject *arg3 = (PyObject *) 0 ;
9846 void *argp1 = 0 ;
9847 int res1 = 0 ;
9848 PyObject * obj0 = 0 ;
9849 PyObject * obj1 = 0 ;
9850 PyObject * obj2 = 0 ;
9851 char * kwnames[] = {
9852 (char *) "self",(char *) "self",(char *) "_class", NULL
9853 };
9854
9855 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9856 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9857 if (!SWIG_IsOK(res1)) {
9858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9859 }
9860 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9861 arg2 = obj1;
9862 arg3 = obj2;
9863 {
9864 PyThreadState* __tstate = wxPyBeginAllowThreads();
9865 (arg1)->_setCallbackInfo(arg2,arg3);
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 resultobj = SWIG_Py_Void();
9870 return resultobj;
9871 fail:
9872 return NULL;
9873 }
9874
9875
9876 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9877 PyObject *resultobj = 0;
9878 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9879 wxString *arg2 = 0 ;
9880 bool result;
9881 void *argp1 = 0 ;
9882 int res1 = 0 ;
9883 bool temp2 = false ;
9884 PyObject * obj0 = 0 ;
9885 PyObject * obj1 = 0 ;
9886 char * kwnames[] = {
9887 (char *) "self",(char *) "location", NULL
9888 };
9889
9890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
9891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9892 if (!SWIG_IsOK(res1)) {
9893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9894 }
9895 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9896 {
9897 arg2 = wxString_in_helper(obj1);
9898 if (arg2 == NULL) SWIG_fail;
9899 temp2 = true;
9900 }
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9904 wxPyEndAllowThreads(__tstate);
9905 if (PyErr_Occurred()) SWIG_fail;
9906 }
9907 {
9908 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9909 }
9910 {
9911 if (temp2)
9912 delete arg2;
9913 }
9914 return resultobj;
9915 fail:
9916 {
9917 if (temp2)
9918 delete arg2;
9919 }
9920 return NULL;
9921 }
9922
9923
9924 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9925 PyObject *resultobj = 0;
9926 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9927 wxFileSystem *arg2 = 0 ;
9928 wxString *arg3 = 0 ;
9929 wxFSFile *result = 0 ;
9930 void *argp1 = 0 ;
9931 int res1 = 0 ;
9932 void *argp2 = 0 ;
9933 int res2 = 0 ;
9934 bool temp3 = false ;
9935 PyObject * obj0 = 0 ;
9936 PyObject * obj1 = 0 ;
9937 PyObject * obj2 = 0 ;
9938 char * kwnames[] = {
9939 (char *) "self",(char *) "fs",(char *) "location", NULL
9940 };
9941
9942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9944 if (!SWIG_IsOK(res1)) {
9945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9946 }
9947 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9948 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
9949 if (!SWIG_IsOK(res2)) {
9950 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9951 }
9952 if (!argp2) {
9953 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
9954 }
9955 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
9956 {
9957 arg3 = wxString_in_helper(obj2);
9958 if (arg3 == NULL) SWIG_fail;
9959 temp3 = true;
9960 }
9961 {
9962 PyThreadState* __tstate = wxPyBeginAllowThreads();
9963 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9964 wxPyEndAllowThreads(__tstate);
9965 if (PyErr_Occurred()) SWIG_fail;
9966 }
9967 {
9968 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
9969 }
9970 {
9971 if (temp3)
9972 delete arg3;
9973 }
9974 return resultobj;
9975 fail:
9976 {
9977 if (temp3)
9978 delete arg3;
9979 }
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9985 PyObject *resultobj = 0;
9986 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9987 wxString *arg2 = 0 ;
9988 int arg3 = (int) 0 ;
9989 wxString result;
9990 void *argp1 = 0 ;
9991 int res1 = 0 ;
9992 bool temp2 = false ;
9993 int val3 ;
9994 int ecode3 = 0 ;
9995 PyObject * obj0 = 0 ;
9996 PyObject * obj1 = 0 ;
9997 PyObject * obj2 = 0 ;
9998 char * kwnames[] = {
9999 (char *) "self",(char *) "spec",(char *) "flags", NULL
10000 };
10001
10002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10004 if (!SWIG_IsOK(res1)) {
10005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10006 }
10007 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10008 {
10009 arg2 = wxString_in_helper(obj1);
10010 if (arg2 == NULL) SWIG_fail;
10011 temp2 = true;
10012 }
10013 if (obj2) {
10014 ecode3 = SWIG_AsVal_int(obj2, &val3);
10015 if (!SWIG_IsOK(ecode3)) {
10016 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10017 }
10018 arg3 = static_cast< int >(val3);
10019 }
10020 {
10021 PyThreadState* __tstate = wxPyBeginAllowThreads();
10022 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10023 wxPyEndAllowThreads(__tstate);
10024 if (PyErr_Occurred()) SWIG_fail;
10025 }
10026 {
10027 #if wxUSE_UNICODE
10028 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10029 #else
10030 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10031 #endif
10032 }
10033 {
10034 if (temp2)
10035 delete arg2;
10036 }
10037 return resultobj;
10038 fail:
10039 {
10040 if (temp2)
10041 delete arg2;
10042 }
10043 return NULL;
10044 }
10045
10046
10047 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10048 PyObject *resultobj = 0;
10049 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10050 wxString result;
10051 void *argp1 = 0 ;
10052 int res1 = 0 ;
10053 PyObject *swig_obj[1] ;
10054
10055 if (!args) SWIG_fail;
10056 swig_obj[0] = args;
10057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10058 if (!SWIG_IsOK(res1)) {
10059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10060 }
10061 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10062 {
10063 PyThreadState* __tstate = wxPyBeginAllowThreads();
10064 result = (arg1)->FindNext();
10065 wxPyEndAllowThreads(__tstate);
10066 if (PyErr_Occurred()) SWIG_fail;
10067 }
10068 {
10069 #if wxUSE_UNICODE
10070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10071 #else
10072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10073 #endif
10074 }
10075 return resultobj;
10076 fail:
10077 return NULL;
10078 }
10079
10080
10081 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10082 PyObject *resultobj = 0;
10083 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10084 wxString *arg2 = 0 ;
10085 wxString result;
10086 void *argp1 = 0 ;
10087 int res1 = 0 ;
10088 bool temp2 = false ;
10089 PyObject * obj0 = 0 ;
10090 PyObject * obj1 = 0 ;
10091 char * kwnames[] = {
10092 (char *) "self",(char *) "location", NULL
10093 };
10094
10095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10097 if (!SWIG_IsOK(res1)) {
10098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10099 }
10100 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10101 {
10102 arg2 = wxString_in_helper(obj1);
10103 if (arg2 == NULL) SWIG_fail;
10104 temp2 = true;
10105 }
10106 {
10107 PyThreadState* __tstate = wxPyBeginAllowThreads();
10108 result = (arg1)->GetProtocol((wxString const &)*arg2);
10109 wxPyEndAllowThreads(__tstate);
10110 if (PyErr_Occurred()) SWIG_fail;
10111 }
10112 {
10113 #if wxUSE_UNICODE
10114 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10115 #else
10116 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10117 #endif
10118 }
10119 {
10120 if (temp2)
10121 delete arg2;
10122 }
10123 return resultobj;
10124 fail:
10125 {
10126 if (temp2)
10127 delete arg2;
10128 }
10129 return NULL;
10130 }
10131
10132
10133 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10134 PyObject *resultobj = 0;
10135 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10136 wxString *arg2 = 0 ;
10137 wxString result;
10138 void *argp1 = 0 ;
10139 int res1 = 0 ;
10140 bool temp2 = false ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char * kwnames[] = {
10144 (char *) "self",(char *) "location", NULL
10145 };
10146
10147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10149 if (!SWIG_IsOK(res1)) {
10150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10151 }
10152 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10153 {
10154 arg2 = wxString_in_helper(obj1);
10155 if (arg2 == NULL) SWIG_fail;
10156 temp2 = true;
10157 }
10158 {
10159 PyThreadState* __tstate = wxPyBeginAllowThreads();
10160 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10161 wxPyEndAllowThreads(__tstate);
10162 if (PyErr_Occurred()) SWIG_fail;
10163 }
10164 {
10165 #if wxUSE_UNICODE
10166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10167 #else
10168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10169 #endif
10170 }
10171 {
10172 if (temp2)
10173 delete arg2;
10174 }
10175 return resultobj;
10176 fail:
10177 {
10178 if (temp2)
10179 delete arg2;
10180 }
10181 return NULL;
10182 }
10183
10184
10185 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10186 PyObject *resultobj = 0;
10187 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10188 wxString *arg2 = 0 ;
10189 wxString result;
10190 void *argp1 = 0 ;
10191 int res1 = 0 ;
10192 bool temp2 = false ;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 char * kwnames[] = {
10196 (char *) "self",(char *) "location", NULL
10197 };
10198
10199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10201 if (!SWIG_IsOK(res1)) {
10202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10203 }
10204 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10205 {
10206 arg2 = wxString_in_helper(obj1);
10207 if (arg2 == NULL) SWIG_fail;
10208 temp2 = true;
10209 }
10210 {
10211 PyThreadState* __tstate = wxPyBeginAllowThreads();
10212 result = (arg1)->GetAnchor((wxString const &)*arg2);
10213 wxPyEndAllowThreads(__tstate);
10214 if (PyErr_Occurred()) SWIG_fail;
10215 }
10216 {
10217 #if wxUSE_UNICODE
10218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10219 #else
10220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10221 #endif
10222 }
10223 {
10224 if (temp2)
10225 delete arg2;
10226 }
10227 return resultobj;
10228 fail:
10229 {
10230 if (temp2)
10231 delete arg2;
10232 }
10233 return NULL;
10234 }
10235
10236
10237 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10238 PyObject *resultobj = 0;
10239 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10240 wxString *arg2 = 0 ;
10241 wxString result;
10242 void *argp1 = 0 ;
10243 int res1 = 0 ;
10244 bool temp2 = false ;
10245 PyObject * obj0 = 0 ;
10246 PyObject * obj1 = 0 ;
10247 char * kwnames[] = {
10248 (char *) "self",(char *) "location", NULL
10249 };
10250
10251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10253 if (!SWIG_IsOK(res1)) {
10254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10255 }
10256 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10257 {
10258 arg2 = wxString_in_helper(obj1);
10259 if (arg2 == NULL) SWIG_fail;
10260 temp2 = true;
10261 }
10262 {
10263 PyThreadState* __tstate = wxPyBeginAllowThreads();
10264 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10265 wxPyEndAllowThreads(__tstate);
10266 if (PyErr_Occurred()) SWIG_fail;
10267 }
10268 {
10269 #if wxUSE_UNICODE
10270 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10271 #else
10272 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10273 #endif
10274 }
10275 {
10276 if (temp2)
10277 delete arg2;
10278 }
10279 return resultobj;
10280 fail:
10281 {
10282 if (temp2)
10283 delete arg2;
10284 }
10285 return NULL;
10286 }
10287
10288
10289 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10290 PyObject *resultobj = 0;
10291 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10292 wxString *arg2 = 0 ;
10293 wxString result;
10294 void *argp1 = 0 ;
10295 int res1 = 0 ;
10296 bool temp2 = false ;
10297 PyObject * obj0 = 0 ;
10298 PyObject * obj1 = 0 ;
10299 char * kwnames[] = {
10300 (char *) "self",(char *) "location", NULL
10301 };
10302
10303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10305 if (!SWIG_IsOK(res1)) {
10306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10307 }
10308 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10309 {
10310 arg2 = wxString_in_helper(obj1);
10311 if (arg2 == NULL) SWIG_fail;
10312 temp2 = true;
10313 }
10314 {
10315 PyThreadState* __tstate = wxPyBeginAllowThreads();
10316 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10317 wxPyEndAllowThreads(__tstate);
10318 if (PyErr_Occurred()) SWIG_fail;
10319 }
10320 {
10321 #if wxUSE_UNICODE
10322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10323 #else
10324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10325 #endif
10326 }
10327 {
10328 if (temp2)
10329 delete arg2;
10330 }
10331 return resultobj;
10332 fail:
10333 {
10334 if (temp2)
10335 delete arg2;
10336 }
10337 return NULL;
10338 }
10339
10340
10341 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10342 PyObject *obj;
10343 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10344 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10345 return SWIG_Py_Void();
10346 }
10347
10348 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10349 return SWIG_Python_InitShadowInstance(args);
10350 }
10351
10352 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10353 PyObject *resultobj = 0;
10354 wxFileSystem *result = 0 ;
10355
10356 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10357 {
10358 PyThreadState* __tstate = wxPyBeginAllowThreads();
10359 result = (wxFileSystem *)new wxFileSystem();
10360 wxPyEndAllowThreads(__tstate);
10361 if (PyErr_Occurred()) SWIG_fail;
10362 }
10363 {
10364 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10365 }
10366 return resultobj;
10367 fail:
10368 return NULL;
10369 }
10370
10371
10372 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10373 PyObject *resultobj = 0;
10374 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10375 void *argp1 = 0 ;
10376 int res1 = 0 ;
10377 PyObject *swig_obj[1] ;
10378
10379 if (!args) SWIG_fail;
10380 swig_obj[0] = args;
10381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10382 if (!SWIG_IsOK(res1)) {
10383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10384 }
10385 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10386 {
10387 PyThreadState* __tstate = wxPyBeginAllowThreads();
10388 delete arg1;
10389
10390 wxPyEndAllowThreads(__tstate);
10391 if (PyErr_Occurred()) SWIG_fail;
10392 }
10393 resultobj = SWIG_Py_Void();
10394 return resultobj;
10395 fail:
10396 return NULL;
10397 }
10398
10399
10400 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10401 PyObject *resultobj = 0;
10402 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10403 wxString *arg2 = 0 ;
10404 bool arg3 = (bool) false ;
10405 void *argp1 = 0 ;
10406 int res1 = 0 ;
10407 bool temp2 = false ;
10408 bool val3 ;
10409 int ecode3 = 0 ;
10410 PyObject * obj0 = 0 ;
10411 PyObject * obj1 = 0 ;
10412 PyObject * obj2 = 0 ;
10413 char * kwnames[] = {
10414 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10415 };
10416
10417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10419 if (!SWIG_IsOK(res1)) {
10420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10421 }
10422 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10423 {
10424 arg2 = wxString_in_helper(obj1);
10425 if (arg2 == NULL) SWIG_fail;
10426 temp2 = true;
10427 }
10428 if (obj2) {
10429 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10430 if (!SWIG_IsOK(ecode3)) {
10431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10432 }
10433 arg3 = static_cast< bool >(val3);
10434 }
10435 {
10436 PyThreadState* __tstate = wxPyBeginAllowThreads();
10437 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10438 wxPyEndAllowThreads(__tstate);
10439 if (PyErr_Occurred()) SWIG_fail;
10440 }
10441 resultobj = SWIG_Py_Void();
10442 {
10443 if (temp2)
10444 delete arg2;
10445 }
10446 return resultobj;
10447 fail:
10448 {
10449 if (temp2)
10450 delete arg2;
10451 }
10452 return NULL;
10453 }
10454
10455
10456 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10457 PyObject *resultobj = 0;
10458 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10459 wxString result;
10460 void *argp1 = 0 ;
10461 int res1 = 0 ;
10462 PyObject *swig_obj[1] ;
10463
10464 if (!args) SWIG_fail;
10465 swig_obj[0] = args;
10466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10467 if (!SWIG_IsOK(res1)) {
10468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10469 }
10470 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10471 {
10472 PyThreadState* __tstate = wxPyBeginAllowThreads();
10473 result = (arg1)->GetPath();
10474 wxPyEndAllowThreads(__tstate);
10475 if (PyErr_Occurred()) SWIG_fail;
10476 }
10477 {
10478 #if wxUSE_UNICODE
10479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10480 #else
10481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10482 #endif
10483 }
10484 return resultobj;
10485 fail:
10486 return NULL;
10487 }
10488
10489
10490 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10491 PyObject *resultobj = 0;
10492 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10493 wxString *arg2 = 0 ;
10494 wxFSFile *result = 0 ;
10495 void *argp1 = 0 ;
10496 int res1 = 0 ;
10497 bool temp2 = false ;
10498 PyObject * obj0 = 0 ;
10499 PyObject * obj1 = 0 ;
10500 char * kwnames[] = {
10501 (char *) "self",(char *) "location", NULL
10502 };
10503
10504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10506 if (!SWIG_IsOK(res1)) {
10507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10508 }
10509 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10510 {
10511 arg2 = wxString_in_helper(obj1);
10512 if (arg2 == NULL) SWIG_fail;
10513 temp2 = true;
10514 }
10515 {
10516 PyThreadState* __tstate = wxPyBeginAllowThreads();
10517 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10518 wxPyEndAllowThreads(__tstate);
10519 if (PyErr_Occurred()) SWIG_fail;
10520 }
10521 {
10522 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10523 }
10524 {
10525 if (temp2)
10526 delete arg2;
10527 }
10528 return resultobj;
10529 fail:
10530 {
10531 if (temp2)
10532 delete arg2;
10533 }
10534 return NULL;
10535 }
10536
10537
10538 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10539 PyObject *resultobj = 0;
10540 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10541 wxString *arg2 = 0 ;
10542 int arg3 = (int) 0 ;
10543 wxString result;
10544 void *argp1 = 0 ;
10545 int res1 = 0 ;
10546 bool temp2 = false ;
10547 int val3 ;
10548 int ecode3 = 0 ;
10549 PyObject * obj0 = 0 ;
10550 PyObject * obj1 = 0 ;
10551 PyObject * obj2 = 0 ;
10552 char * kwnames[] = {
10553 (char *) "self",(char *) "spec",(char *) "flags", NULL
10554 };
10555
10556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10558 if (!SWIG_IsOK(res1)) {
10559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10560 }
10561 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10562 {
10563 arg2 = wxString_in_helper(obj1);
10564 if (arg2 == NULL) SWIG_fail;
10565 temp2 = true;
10566 }
10567 if (obj2) {
10568 ecode3 = SWIG_AsVal_int(obj2, &val3);
10569 if (!SWIG_IsOK(ecode3)) {
10570 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10571 }
10572 arg3 = static_cast< int >(val3);
10573 }
10574 {
10575 PyThreadState* __tstate = wxPyBeginAllowThreads();
10576 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10577 wxPyEndAllowThreads(__tstate);
10578 if (PyErr_Occurred()) SWIG_fail;
10579 }
10580 {
10581 #if wxUSE_UNICODE
10582 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10583 #else
10584 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10585 #endif
10586 }
10587 {
10588 if (temp2)
10589 delete arg2;
10590 }
10591 return resultobj;
10592 fail:
10593 {
10594 if (temp2)
10595 delete arg2;
10596 }
10597 return NULL;
10598 }
10599
10600
10601 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10602 PyObject *resultobj = 0;
10603 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10604 wxString result;
10605 void *argp1 = 0 ;
10606 int res1 = 0 ;
10607 PyObject *swig_obj[1] ;
10608
10609 if (!args) SWIG_fail;
10610 swig_obj[0] = args;
10611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10612 if (!SWIG_IsOK(res1)) {
10613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10614 }
10615 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10616 {
10617 PyThreadState* __tstate = wxPyBeginAllowThreads();
10618 result = (arg1)->FindNext();
10619 wxPyEndAllowThreads(__tstate);
10620 if (PyErr_Occurred()) SWIG_fail;
10621 }
10622 {
10623 #if wxUSE_UNICODE
10624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10625 #else
10626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10627 #endif
10628 }
10629 return resultobj;
10630 fail:
10631 return NULL;
10632 }
10633
10634
10635 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10636 PyObject *resultobj = 0;
10637 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10638 void *argp1 = 0 ;
10639 int res1 = 0 ;
10640 PyObject * obj0 = 0 ;
10641 char * kwnames[] = {
10642 (char *) "handler", NULL
10643 };
10644
10645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
10647 if (!SWIG_IsOK(res1)) {
10648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10649 }
10650 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
10651 {
10652 PyThreadState* __tstate = wxPyBeginAllowThreads();
10653 wxFileSystem::AddHandler(arg1);
10654 wxPyEndAllowThreads(__tstate);
10655 if (PyErr_Occurred()) SWIG_fail;
10656 }
10657 resultobj = SWIG_Py_Void();
10658 return resultobj;
10659 fail:
10660 return NULL;
10661 }
10662
10663
10664 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10665 PyObject *resultobj = 0;
10666
10667 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10668 {
10669 PyThreadState* __tstate = wxPyBeginAllowThreads();
10670 wxFileSystem::CleanUpHandlers();
10671 wxPyEndAllowThreads(__tstate);
10672 if (PyErr_Occurred()) SWIG_fail;
10673 }
10674 resultobj = SWIG_Py_Void();
10675 return resultobj;
10676 fail:
10677 return NULL;
10678 }
10679
10680
10681 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10682 PyObject *resultobj = 0;
10683 wxString *arg1 = 0 ;
10684 wxString result;
10685 bool temp1 = false ;
10686 PyObject * obj0 = 0 ;
10687 char * kwnames[] = {
10688 (char *) "filename", NULL
10689 };
10690
10691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10692 {
10693 arg1 = wxString_in_helper(obj0);
10694 if (arg1 == NULL) SWIG_fail;
10695 temp1 = true;
10696 }
10697 {
10698 PyThreadState* __tstate = wxPyBeginAllowThreads();
10699 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10700 wxPyEndAllowThreads(__tstate);
10701 if (PyErr_Occurred()) SWIG_fail;
10702 }
10703 {
10704 #if wxUSE_UNICODE
10705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10706 #else
10707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10708 #endif
10709 }
10710 {
10711 if (temp1)
10712 delete arg1;
10713 }
10714 return resultobj;
10715 fail:
10716 {
10717 if (temp1)
10718 delete arg1;
10719 }
10720 return NULL;
10721 }
10722
10723
10724 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10725 PyObject *resultobj = 0;
10726 wxString *arg1 = 0 ;
10727 wxString result;
10728 bool temp1 = false ;
10729 PyObject * obj0 = 0 ;
10730 char * kwnames[] = {
10731 (char *) "url", NULL
10732 };
10733
10734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10735 {
10736 arg1 = wxString_in_helper(obj0);
10737 if (arg1 == NULL) SWIG_fail;
10738 temp1 = true;
10739 }
10740 {
10741 PyThreadState* __tstate = wxPyBeginAllowThreads();
10742 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10743 wxPyEndAllowThreads(__tstate);
10744 if (PyErr_Occurred()) SWIG_fail;
10745 }
10746 {
10747 #if wxUSE_UNICODE
10748 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10749 #else
10750 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10751 #endif
10752 }
10753 {
10754 if (temp1)
10755 delete arg1;
10756 }
10757 return resultobj;
10758 fail:
10759 {
10760 if (temp1)
10761 delete arg1;
10762 }
10763 return NULL;
10764 }
10765
10766
10767 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10768 PyObject *obj;
10769 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10770 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10771 return SWIG_Py_Void();
10772 }
10773
10774 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 return SWIG_Python_InitShadowInstance(args);
10776 }
10777
10778 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10779 PyObject *resultobj = 0;
10780 wxInternetFSHandler *result = 0 ;
10781
10782 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10783 {
10784 PyThreadState* __tstate = wxPyBeginAllowThreads();
10785 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10786 wxPyEndAllowThreads(__tstate);
10787 if (PyErr_Occurred()) SWIG_fail;
10788 }
10789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10790 return resultobj;
10791 fail:
10792 return NULL;
10793 }
10794
10795
10796 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10797 PyObject *resultobj = 0;
10798 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10799 wxString *arg2 = 0 ;
10800 bool result;
10801 void *argp1 = 0 ;
10802 int res1 = 0 ;
10803 bool temp2 = false ;
10804 PyObject * obj0 = 0 ;
10805 PyObject * obj1 = 0 ;
10806 char * kwnames[] = {
10807 (char *) "self",(char *) "location", NULL
10808 };
10809
10810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10812 if (!SWIG_IsOK(res1)) {
10813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10814 }
10815 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10816 {
10817 arg2 = wxString_in_helper(obj1);
10818 if (arg2 == NULL) SWIG_fail;
10819 temp2 = true;
10820 }
10821 {
10822 PyThreadState* __tstate = wxPyBeginAllowThreads();
10823 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10824 wxPyEndAllowThreads(__tstate);
10825 if (PyErr_Occurred()) SWIG_fail;
10826 }
10827 {
10828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10829 }
10830 {
10831 if (temp2)
10832 delete arg2;
10833 }
10834 return resultobj;
10835 fail:
10836 {
10837 if (temp2)
10838 delete arg2;
10839 }
10840 return NULL;
10841 }
10842
10843
10844 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj = 0;
10846 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10847 wxFileSystem *arg2 = 0 ;
10848 wxString *arg3 = 0 ;
10849 wxFSFile *result = 0 ;
10850 void *argp1 = 0 ;
10851 int res1 = 0 ;
10852 void *argp2 = 0 ;
10853 int res2 = 0 ;
10854 bool temp3 = false ;
10855 PyObject * obj0 = 0 ;
10856 PyObject * obj1 = 0 ;
10857 PyObject * obj2 = 0 ;
10858 char * kwnames[] = {
10859 (char *) "self",(char *) "fs",(char *) "location", NULL
10860 };
10861
10862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10864 if (!SWIG_IsOK(res1)) {
10865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10866 }
10867 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10868 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10869 if (!SWIG_IsOK(res2)) {
10870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10871 }
10872 if (!argp2) {
10873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10874 }
10875 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10876 {
10877 arg3 = wxString_in_helper(obj2);
10878 if (arg3 == NULL) SWIG_fail;
10879 temp3 = true;
10880 }
10881 {
10882 PyThreadState* __tstate = wxPyBeginAllowThreads();
10883 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10884 wxPyEndAllowThreads(__tstate);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 {
10888 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10889 }
10890 {
10891 if (temp3)
10892 delete arg3;
10893 }
10894 return resultobj;
10895 fail:
10896 {
10897 if (temp3)
10898 delete arg3;
10899 }
10900 return NULL;
10901 }
10902
10903
10904 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10905 PyObject *obj;
10906 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10907 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
10908 return SWIG_Py_Void();
10909 }
10910
10911 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10912 return SWIG_Python_InitShadowInstance(args);
10913 }
10914
10915 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10916 PyObject *resultobj = 0;
10917 wxZipFSHandler *result = 0 ;
10918
10919 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
10920 {
10921 PyThreadState* __tstate = wxPyBeginAllowThreads();
10922 result = (wxZipFSHandler *)new wxZipFSHandler();
10923 wxPyEndAllowThreads(__tstate);
10924 if (PyErr_Occurred()) SWIG_fail;
10925 }
10926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
10927 return resultobj;
10928 fail:
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10934 PyObject *resultobj = 0;
10935 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10936 wxString *arg2 = 0 ;
10937 bool result;
10938 void *argp1 = 0 ;
10939 int res1 = 0 ;
10940 bool temp2 = false ;
10941 PyObject * obj0 = 0 ;
10942 PyObject * obj1 = 0 ;
10943 char * kwnames[] = {
10944 (char *) "self",(char *) "location", NULL
10945 };
10946
10947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
10949 if (!SWIG_IsOK(res1)) {
10950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
10951 }
10952 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
10953 {
10954 arg2 = wxString_in_helper(obj1);
10955 if (arg2 == NULL) SWIG_fail;
10956 temp2 = true;
10957 }
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10961 wxPyEndAllowThreads(__tstate);
10962 if (PyErr_Occurred()) SWIG_fail;
10963 }
10964 {
10965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10966 }
10967 {
10968 if (temp2)
10969 delete arg2;
10970 }
10971 return resultobj;
10972 fail:
10973 {
10974 if (temp2)
10975 delete arg2;
10976 }
10977 return NULL;
10978 }
10979
10980
10981 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10982 PyObject *resultobj = 0;
10983 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
10984 wxFileSystem *arg2 = 0 ;
10985 wxString *arg3 = 0 ;
10986 wxFSFile *result = 0 ;
10987 void *argp1 = 0 ;
10988 int res1 = 0 ;
10989 void *argp2 = 0 ;
10990 int res2 = 0 ;
10991 bool temp3 = false ;
10992 PyObject * obj0 = 0 ;
10993 PyObject * obj1 = 0 ;
10994 PyObject * obj2 = 0 ;
10995 char * kwnames[] = {
10996 (char *) "self",(char *) "fs",(char *) "location", NULL
10997 };
10998
10999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11001 if (!SWIG_IsOK(res1)) {
11002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11003 }
11004 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11005 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11006 if (!SWIG_IsOK(res2)) {
11007 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11008 }
11009 if (!argp2) {
11010 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11011 }
11012 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11013 {
11014 arg3 = wxString_in_helper(obj2);
11015 if (arg3 == NULL) SWIG_fail;
11016 temp3 = true;
11017 }
11018 {
11019 PyThreadState* __tstate = wxPyBeginAllowThreads();
11020 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11021 wxPyEndAllowThreads(__tstate);
11022 if (PyErr_Occurred()) SWIG_fail;
11023 }
11024 {
11025 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11026 }
11027 {
11028 if (temp3)
11029 delete arg3;
11030 }
11031 return resultobj;
11032 fail:
11033 {
11034 if (temp3)
11035 delete arg3;
11036 }
11037 return NULL;
11038 }
11039
11040
11041 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11042 PyObject *resultobj = 0;
11043 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11044 wxString *arg2 = 0 ;
11045 int arg3 = (int) 0 ;
11046 wxString result;
11047 void *argp1 = 0 ;
11048 int res1 = 0 ;
11049 bool temp2 = false ;
11050 int val3 ;
11051 int ecode3 = 0 ;
11052 PyObject * obj0 = 0 ;
11053 PyObject * obj1 = 0 ;
11054 PyObject * obj2 = 0 ;
11055 char * kwnames[] = {
11056 (char *) "self",(char *) "spec",(char *) "flags", NULL
11057 };
11058
11059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11061 if (!SWIG_IsOK(res1)) {
11062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11063 }
11064 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11065 {
11066 arg2 = wxString_in_helper(obj1);
11067 if (arg2 == NULL) SWIG_fail;
11068 temp2 = true;
11069 }
11070 if (obj2) {
11071 ecode3 = SWIG_AsVal_int(obj2, &val3);
11072 if (!SWIG_IsOK(ecode3)) {
11073 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11074 }
11075 arg3 = static_cast< int >(val3);
11076 }
11077 {
11078 PyThreadState* __tstate = wxPyBeginAllowThreads();
11079 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11080 wxPyEndAllowThreads(__tstate);
11081 if (PyErr_Occurred()) SWIG_fail;
11082 }
11083 {
11084 #if wxUSE_UNICODE
11085 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11086 #else
11087 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11088 #endif
11089 }
11090 {
11091 if (temp2)
11092 delete arg2;
11093 }
11094 return resultobj;
11095 fail:
11096 {
11097 if (temp2)
11098 delete arg2;
11099 }
11100 return NULL;
11101 }
11102
11103
11104 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11105 PyObject *resultobj = 0;
11106 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11107 wxString result;
11108 void *argp1 = 0 ;
11109 int res1 = 0 ;
11110 PyObject *swig_obj[1] ;
11111
11112 if (!args) SWIG_fail;
11113 swig_obj[0] = args;
11114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11117 }
11118 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11119 {
11120 PyThreadState* __tstate = wxPyBeginAllowThreads();
11121 result = (arg1)->FindNext();
11122 wxPyEndAllowThreads(__tstate);
11123 if (PyErr_Occurred()) SWIG_fail;
11124 }
11125 {
11126 #if wxUSE_UNICODE
11127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11128 #else
11129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11130 #endif
11131 }
11132 return resultobj;
11133 fail:
11134 return NULL;
11135 }
11136
11137
11138 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11139 PyObject *obj;
11140 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11141 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11142 return SWIG_Py_Void();
11143 }
11144
11145 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11146 return SWIG_Python_InitShadowInstance(args);
11147 }
11148
11149 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11150 PyObject *resultobj = 0;
11151 wxString *arg1 = 0 ;
11152 wxImage *arg2 = 0 ;
11153 long arg3 ;
11154 bool temp1 = false ;
11155 void *argp2 = 0 ;
11156 int res2 = 0 ;
11157 long val3 ;
11158 int ecode3 = 0 ;
11159 PyObject * obj0 = 0 ;
11160 PyObject * obj1 = 0 ;
11161 PyObject * obj2 = 0 ;
11162 char * kwnames[] = {
11163 (char *) "filename",(char *) "image",(char *) "type", NULL
11164 };
11165
11166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11167 {
11168 arg1 = wxString_in_helper(obj0);
11169 if (arg1 == NULL) SWIG_fail;
11170 temp1 = true;
11171 }
11172 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11173 if (!SWIG_IsOK(res2)) {
11174 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11175 }
11176 if (!argp2) {
11177 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11178 }
11179 arg2 = reinterpret_cast< wxImage * >(argp2);
11180 ecode3 = SWIG_AsVal_long(obj2, &val3);
11181 if (!SWIG_IsOK(ecode3)) {
11182 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11183 }
11184 arg3 = static_cast< long >(val3);
11185 {
11186 PyThreadState* __tstate = wxPyBeginAllowThreads();
11187 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11188 wxPyEndAllowThreads(__tstate);
11189 if (PyErr_Occurred()) SWIG_fail;
11190 }
11191 resultobj = SWIG_Py_Void();
11192 {
11193 if (temp1)
11194 delete arg1;
11195 }
11196 return resultobj;
11197 fail:
11198 {
11199 if (temp1)
11200 delete arg1;
11201 }
11202 return NULL;
11203 }
11204
11205
11206 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11207 PyObject *resultobj = 0;
11208 wxString *arg1 = 0 ;
11209 wxBitmap *arg2 = 0 ;
11210 long arg3 ;
11211 bool temp1 = false ;
11212 void *argp2 = 0 ;
11213 int res2 = 0 ;
11214 long val3 ;
11215 int ecode3 = 0 ;
11216 PyObject * obj0 = 0 ;
11217 PyObject * obj1 = 0 ;
11218 PyObject * obj2 = 0 ;
11219 char * kwnames[] = {
11220 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11221 };
11222
11223 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11224 {
11225 arg1 = wxString_in_helper(obj0);
11226 if (arg1 == NULL) SWIG_fail;
11227 temp1 = true;
11228 }
11229 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11230 if (!SWIG_IsOK(res2)) {
11231 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11232 }
11233 if (!argp2) {
11234 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11235 }
11236 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11237 ecode3 = SWIG_AsVal_long(obj2, &val3);
11238 if (!SWIG_IsOK(ecode3)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11240 }
11241 arg3 = static_cast< long >(val3);
11242 {
11243 PyThreadState* __tstate = wxPyBeginAllowThreads();
11244 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11245 wxPyEndAllowThreads(__tstate);
11246 if (PyErr_Occurred()) SWIG_fail;
11247 }
11248 resultobj = SWIG_Py_Void();
11249 {
11250 if (temp1)
11251 delete arg1;
11252 }
11253 return resultobj;
11254 fail:
11255 {
11256 if (temp1)
11257 delete arg1;
11258 }
11259 return NULL;
11260 }
11261
11262
11263 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11264 PyObject *resultobj = 0;
11265 wxString *arg1 = 0 ;
11266 PyObject *arg2 = (PyObject *) 0 ;
11267 bool temp1 = false ;
11268 PyObject * obj0 = 0 ;
11269 PyObject * obj1 = 0 ;
11270 char * kwnames[] = {
11271 (char *) "filename",(char *) "data", NULL
11272 };
11273
11274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11275 {
11276 arg1 = wxString_in_helper(obj0);
11277 if (arg1 == NULL) SWIG_fail;
11278 temp1 = true;
11279 }
11280 arg2 = obj1;
11281 {
11282 PyThreadState* __tstate = wxPyBeginAllowThreads();
11283 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11284 wxPyEndAllowThreads(__tstate);
11285 if (PyErr_Occurred()) SWIG_fail;
11286 }
11287 resultobj = SWIG_Py_Void();
11288 {
11289 if (temp1)
11290 delete arg1;
11291 }
11292 return resultobj;
11293 fail:
11294 {
11295 if (temp1)
11296 delete arg1;
11297 }
11298 return NULL;
11299 }
11300
11301
11302 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11303 PyObject *resultobj = 0;
11304 wxMemoryFSHandler *result = 0 ;
11305
11306 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11307 {
11308 PyThreadState* __tstate = wxPyBeginAllowThreads();
11309 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11310 wxPyEndAllowThreads(__tstate);
11311 if (PyErr_Occurred()) SWIG_fail;
11312 }
11313 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11314 return resultobj;
11315 fail:
11316 return NULL;
11317 }
11318
11319
11320 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11321 PyObject *resultobj = 0;
11322 wxString *arg1 = 0 ;
11323 bool temp1 = false ;
11324 PyObject * obj0 = 0 ;
11325 char * kwnames[] = {
11326 (char *) "filename", NULL
11327 };
11328
11329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11330 {
11331 arg1 = wxString_in_helper(obj0);
11332 if (arg1 == NULL) SWIG_fail;
11333 temp1 = true;
11334 }
11335 {
11336 PyThreadState* __tstate = wxPyBeginAllowThreads();
11337 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11338 wxPyEndAllowThreads(__tstate);
11339 if (PyErr_Occurred()) SWIG_fail;
11340 }
11341 resultobj = SWIG_Py_Void();
11342 {
11343 if (temp1)
11344 delete arg1;
11345 }
11346 return resultobj;
11347 fail:
11348 {
11349 if (temp1)
11350 delete arg1;
11351 }
11352 return NULL;
11353 }
11354
11355
11356 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11357 PyObject *resultobj = 0;
11358 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11359 wxString *arg2 = 0 ;
11360 bool result;
11361 void *argp1 = 0 ;
11362 int res1 = 0 ;
11363 bool temp2 = false ;
11364 PyObject * obj0 = 0 ;
11365 PyObject * obj1 = 0 ;
11366 char * kwnames[] = {
11367 (char *) "self",(char *) "location", NULL
11368 };
11369
11370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11372 if (!SWIG_IsOK(res1)) {
11373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11374 }
11375 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11376 {
11377 arg2 = wxString_in_helper(obj1);
11378 if (arg2 == NULL) SWIG_fail;
11379 temp2 = true;
11380 }
11381 {
11382 PyThreadState* __tstate = wxPyBeginAllowThreads();
11383 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11384 wxPyEndAllowThreads(__tstate);
11385 if (PyErr_Occurred()) SWIG_fail;
11386 }
11387 {
11388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11389 }
11390 {
11391 if (temp2)
11392 delete arg2;
11393 }
11394 return resultobj;
11395 fail:
11396 {
11397 if (temp2)
11398 delete arg2;
11399 }
11400 return NULL;
11401 }
11402
11403
11404 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11405 PyObject *resultobj = 0;
11406 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11407 wxFileSystem *arg2 = 0 ;
11408 wxString *arg3 = 0 ;
11409 wxFSFile *result = 0 ;
11410 void *argp1 = 0 ;
11411 int res1 = 0 ;
11412 void *argp2 = 0 ;
11413 int res2 = 0 ;
11414 bool temp3 = false ;
11415 PyObject * obj0 = 0 ;
11416 PyObject * obj1 = 0 ;
11417 PyObject * obj2 = 0 ;
11418 char * kwnames[] = {
11419 (char *) "self",(char *) "fs",(char *) "location", NULL
11420 };
11421
11422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11424 if (!SWIG_IsOK(res1)) {
11425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11426 }
11427 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11428 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11429 if (!SWIG_IsOK(res2)) {
11430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11431 }
11432 if (!argp2) {
11433 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11434 }
11435 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11436 {
11437 arg3 = wxString_in_helper(obj2);
11438 if (arg3 == NULL) SWIG_fail;
11439 temp3 = true;
11440 }
11441 {
11442 PyThreadState* __tstate = wxPyBeginAllowThreads();
11443 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 {
11448 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11449 }
11450 {
11451 if (temp3)
11452 delete arg3;
11453 }
11454 return resultobj;
11455 fail:
11456 {
11457 if (temp3)
11458 delete arg3;
11459 }
11460 return NULL;
11461 }
11462
11463
11464 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11465 PyObject *resultobj = 0;
11466 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11467 wxString *arg2 = 0 ;
11468 int arg3 = (int) 0 ;
11469 wxString result;
11470 void *argp1 = 0 ;
11471 int res1 = 0 ;
11472 bool temp2 = false ;
11473 int val3 ;
11474 int ecode3 = 0 ;
11475 PyObject * obj0 = 0 ;
11476 PyObject * obj1 = 0 ;
11477 PyObject * obj2 = 0 ;
11478 char * kwnames[] = {
11479 (char *) "self",(char *) "spec",(char *) "flags", NULL
11480 };
11481
11482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11483 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11484 if (!SWIG_IsOK(res1)) {
11485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11486 }
11487 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11488 {
11489 arg2 = wxString_in_helper(obj1);
11490 if (arg2 == NULL) SWIG_fail;
11491 temp2 = true;
11492 }
11493 if (obj2) {
11494 ecode3 = SWIG_AsVal_int(obj2, &val3);
11495 if (!SWIG_IsOK(ecode3)) {
11496 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11497 }
11498 arg3 = static_cast< int >(val3);
11499 }
11500 {
11501 PyThreadState* __tstate = wxPyBeginAllowThreads();
11502 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11503 wxPyEndAllowThreads(__tstate);
11504 if (PyErr_Occurred()) SWIG_fail;
11505 }
11506 {
11507 #if wxUSE_UNICODE
11508 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11509 #else
11510 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11511 #endif
11512 }
11513 {
11514 if (temp2)
11515 delete arg2;
11516 }
11517 return resultobj;
11518 fail:
11519 {
11520 if (temp2)
11521 delete arg2;
11522 }
11523 return NULL;
11524 }
11525
11526
11527 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11528 PyObject *resultobj = 0;
11529 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11530 wxString result;
11531 void *argp1 = 0 ;
11532 int res1 = 0 ;
11533 PyObject *swig_obj[1] ;
11534
11535 if (!args) SWIG_fail;
11536 swig_obj[0] = args;
11537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11540 }
11541 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11542 {
11543 PyThreadState* __tstate = wxPyBeginAllowThreads();
11544 result = (arg1)->FindNext();
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 {
11549 #if wxUSE_UNICODE
11550 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11551 #else
11552 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11553 #endif
11554 }
11555 return resultobj;
11556 fail:
11557 return NULL;
11558 }
11559
11560
11561 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11562 PyObject *obj;
11563 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11564 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11565 return SWIG_Py_Void();
11566 }
11567
11568 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11569 return SWIG_Python_InitShadowInstance(args);
11570 }
11571
11572 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11573 PyObject *resultobj = 0;
11574 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11575 wxString result;
11576 void *argp1 = 0 ;
11577 int res1 = 0 ;
11578 PyObject *swig_obj[1] ;
11579
11580 if (!args) SWIG_fail;
11581 swig_obj[0] = args;
11582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11583 if (!SWIG_IsOK(res1)) {
11584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11585 }
11586 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11587 {
11588 PyThreadState* __tstate = wxPyBeginAllowThreads();
11589 result = (arg1)->GetName();
11590 wxPyEndAllowThreads(__tstate);
11591 if (PyErr_Occurred()) SWIG_fail;
11592 }
11593 {
11594 #if wxUSE_UNICODE
11595 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11596 #else
11597 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11598 #endif
11599 }
11600 return resultobj;
11601 fail:
11602 return NULL;
11603 }
11604
11605
11606 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11607 PyObject *resultobj = 0;
11608 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11609 wxString result;
11610 void *argp1 = 0 ;
11611 int res1 = 0 ;
11612 PyObject *swig_obj[1] ;
11613
11614 if (!args) SWIG_fail;
11615 swig_obj[0] = args;
11616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11617 if (!SWIG_IsOK(res1)) {
11618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11619 }
11620 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11621 {
11622 PyThreadState* __tstate = wxPyBeginAllowThreads();
11623 result = (arg1)->GetExtension();
11624 wxPyEndAllowThreads(__tstate);
11625 if (PyErr_Occurred()) SWIG_fail;
11626 }
11627 {
11628 #if wxUSE_UNICODE
11629 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11630 #else
11631 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11632 #endif
11633 }
11634 return resultobj;
11635 fail:
11636 return NULL;
11637 }
11638
11639
11640 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11641 PyObject *resultobj = 0;
11642 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11643 long result;
11644 void *argp1 = 0 ;
11645 int res1 = 0 ;
11646 PyObject *swig_obj[1] ;
11647
11648 if (!args) SWIG_fail;
11649 swig_obj[0] = args;
11650 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11651 if (!SWIG_IsOK(res1)) {
11652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11653 }
11654 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11655 {
11656 PyThreadState* __tstate = wxPyBeginAllowThreads();
11657 result = (long)(arg1)->GetType();
11658 wxPyEndAllowThreads(__tstate);
11659 if (PyErr_Occurred()) SWIG_fail;
11660 }
11661 resultobj = SWIG_From_long(static_cast< long >(result));
11662 return resultobj;
11663 fail:
11664 return NULL;
11665 }
11666
11667
11668 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11669 PyObject *resultobj = 0;
11670 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11671 wxString result;
11672 void *argp1 = 0 ;
11673 int res1 = 0 ;
11674 PyObject *swig_obj[1] ;
11675
11676 if (!args) SWIG_fail;
11677 swig_obj[0] = args;
11678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11679 if (!SWIG_IsOK(res1)) {
11680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11681 }
11682 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11683 {
11684 PyThreadState* __tstate = wxPyBeginAllowThreads();
11685 result = (arg1)->GetMimeType();
11686 wxPyEndAllowThreads(__tstate);
11687 if (PyErr_Occurred()) SWIG_fail;
11688 }
11689 {
11690 #if wxUSE_UNICODE
11691 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11692 #else
11693 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11694 #endif
11695 }
11696 return resultobj;
11697 fail:
11698 return NULL;
11699 }
11700
11701
11702 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11703 PyObject *resultobj = 0;
11704 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11705 wxString *arg2 = 0 ;
11706 bool result;
11707 void *argp1 = 0 ;
11708 int res1 = 0 ;
11709 bool temp2 = false ;
11710 PyObject * obj0 = 0 ;
11711 PyObject * obj1 = 0 ;
11712 char * kwnames[] = {
11713 (char *) "self",(char *) "name", NULL
11714 };
11715
11716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11718 if (!SWIG_IsOK(res1)) {
11719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11720 }
11721 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11722 {
11723 arg2 = wxString_in_helper(obj1);
11724 if (arg2 == NULL) SWIG_fail;
11725 temp2 = true;
11726 }
11727 {
11728 PyThreadState* __tstate = wxPyBeginAllowThreads();
11729 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11730 wxPyEndAllowThreads(__tstate);
11731 if (PyErr_Occurred()) SWIG_fail;
11732 }
11733 {
11734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11735 }
11736 {
11737 if (temp2)
11738 delete arg2;
11739 }
11740 return resultobj;
11741 fail:
11742 {
11743 if (temp2)
11744 delete arg2;
11745 }
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11751 PyObject *resultobj = 0;
11752 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11753 wxString *arg2 = 0 ;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 bool temp2 = false ;
11757 PyObject * obj0 = 0 ;
11758 PyObject * obj1 = 0 ;
11759 char * kwnames[] = {
11760 (char *) "self",(char *) "name", NULL
11761 };
11762
11763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11765 if (!SWIG_IsOK(res1)) {
11766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11767 }
11768 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11769 {
11770 arg2 = wxString_in_helper(obj1);
11771 if (arg2 == NULL) SWIG_fail;
11772 temp2 = true;
11773 }
11774 {
11775 PyThreadState* __tstate = wxPyBeginAllowThreads();
11776 (arg1)->SetName((wxString const &)*arg2);
11777 wxPyEndAllowThreads(__tstate);
11778 if (PyErr_Occurred()) SWIG_fail;
11779 }
11780 resultobj = SWIG_Py_Void();
11781 {
11782 if (temp2)
11783 delete arg2;
11784 }
11785 return resultobj;
11786 fail:
11787 {
11788 if (temp2)
11789 delete arg2;
11790 }
11791 return NULL;
11792 }
11793
11794
11795 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11796 PyObject *resultobj = 0;
11797 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11798 wxString *arg2 = 0 ;
11799 void *argp1 = 0 ;
11800 int res1 = 0 ;
11801 bool temp2 = false ;
11802 PyObject * obj0 = 0 ;
11803 PyObject * obj1 = 0 ;
11804 char * kwnames[] = {
11805 (char *) "self",(char *) "extension", NULL
11806 };
11807
11808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11810 if (!SWIG_IsOK(res1)) {
11811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11812 }
11813 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11814 {
11815 arg2 = wxString_in_helper(obj1);
11816 if (arg2 == NULL) SWIG_fail;
11817 temp2 = true;
11818 }
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 (arg1)->SetExtension((wxString const &)*arg2);
11822 wxPyEndAllowThreads(__tstate);
11823 if (PyErr_Occurred()) SWIG_fail;
11824 }
11825 resultobj = SWIG_Py_Void();
11826 {
11827 if (temp2)
11828 delete arg2;
11829 }
11830 return resultobj;
11831 fail:
11832 {
11833 if (temp2)
11834 delete arg2;
11835 }
11836 return NULL;
11837 }
11838
11839
11840 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11841 PyObject *resultobj = 0;
11842 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11843 long arg2 ;
11844 void *argp1 = 0 ;
11845 int res1 = 0 ;
11846 long val2 ;
11847 int ecode2 = 0 ;
11848 PyObject * obj0 = 0 ;
11849 PyObject * obj1 = 0 ;
11850 char * kwnames[] = {
11851 (char *) "self",(char *) "type", NULL
11852 };
11853
11854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11856 if (!SWIG_IsOK(res1)) {
11857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11858 }
11859 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11860 ecode2 = SWIG_AsVal_long(obj1, &val2);
11861 if (!SWIG_IsOK(ecode2)) {
11862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11863 }
11864 arg2 = static_cast< long >(val2);
11865 {
11866 PyThreadState* __tstate = wxPyBeginAllowThreads();
11867 (arg1)->SetType(arg2);
11868 wxPyEndAllowThreads(__tstate);
11869 if (PyErr_Occurred()) SWIG_fail;
11870 }
11871 resultobj = SWIG_Py_Void();
11872 return resultobj;
11873 fail:
11874 return NULL;
11875 }
11876
11877
11878 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11879 PyObject *resultobj = 0;
11880 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11881 wxString *arg2 = 0 ;
11882 void *argp1 = 0 ;
11883 int res1 = 0 ;
11884 bool temp2 = false ;
11885 PyObject * obj0 = 0 ;
11886 PyObject * obj1 = 0 ;
11887 char * kwnames[] = {
11888 (char *) "self",(char *) "mimetype", NULL
11889 };
11890
11891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
11892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11893 if (!SWIG_IsOK(res1)) {
11894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11895 }
11896 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11897 {
11898 arg2 = wxString_in_helper(obj1);
11899 if (arg2 == NULL) SWIG_fail;
11900 temp2 = true;
11901 }
11902 {
11903 PyThreadState* __tstate = wxPyBeginAllowThreads();
11904 (arg1)->SetMimeType((wxString const &)*arg2);
11905 wxPyEndAllowThreads(__tstate);
11906 if (PyErr_Occurred()) SWIG_fail;
11907 }
11908 resultobj = SWIG_Py_Void();
11909 {
11910 if (temp2)
11911 delete arg2;
11912 }
11913 return resultobj;
11914 fail:
11915 {
11916 if (temp2)
11917 delete arg2;
11918 }
11919 return NULL;
11920 }
11921
11922
11923 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11924 PyObject *obj;
11925 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11926 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
11927 return SWIG_Py_Void();
11928 }
11929
11930 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11931 PyObject *resultobj = 0;
11932 wxPyImageHandler *result = 0 ;
11933
11934 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
11935 {
11936 PyThreadState* __tstate = wxPyBeginAllowThreads();
11937 result = (wxPyImageHandler *)new wxPyImageHandler();
11938 wxPyEndAllowThreads(__tstate);
11939 if (PyErr_Occurred()) SWIG_fail;
11940 }
11941 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
11942 return resultobj;
11943 fail:
11944 return NULL;
11945 }
11946
11947
11948 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11949 PyObject *resultobj = 0;
11950 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
11951 PyObject *arg2 = (PyObject *) 0 ;
11952 void *argp1 = 0 ;
11953 int res1 = 0 ;
11954 PyObject * obj0 = 0 ;
11955 PyObject * obj1 = 0 ;
11956 char * kwnames[] = {
11957 (char *) "self",(char *) "self", NULL
11958 };
11959
11960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
11961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
11962 if (!SWIG_IsOK(res1)) {
11963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
11964 }
11965 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
11966 arg2 = obj1;
11967 {
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 (arg1)->_SetSelf(arg2);
11970 wxPyEndAllowThreads(__tstate);
11971 if (PyErr_Occurred()) SWIG_fail;
11972 }
11973 resultobj = SWIG_Py_Void();
11974 return resultobj;
11975 fail:
11976 return NULL;
11977 }
11978
11979
11980 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11981 PyObject *obj;
11982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11983 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
11984 return SWIG_Py_Void();
11985 }
11986
11987 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11988 return SWIG_Python_InitShadowInstance(args);
11989 }
11990
11991 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11992 PyObject *resultobj = 0;
11993 wxImageHistogram *result = 0 ;
11994
11995 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 result = (wxImageHistogram *)new wxImageHistogram();
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12003 return resultobj;
12004 fail:
12005 return NULL;
12006 }
12007
12008
12009 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12010 PyObject *resultobj = 0;
12011 byte arg1 ;
12012 byte arg2 ;
12013 byte arg3 ;
12014 unsigned long result;
12015 unsigned char val1 ;
12016 int ecode1 = 0 ;
12017 unsigned char val2 ;
12018 int ecode2 = 0 ;
12019 unsigned char val3 ;
12020 int ecode3 = 0 ;
12021 PyObject * obj0 = 0 ;
12022 PyObject * obj1 = 0 ;
12023 PyObject * obj2 = 0 ;
12024 char * kwnames[] = {
12025 (char *) "r",(char *) "g",(char *) "b", NULL
12026 };
12027
12028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12029 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12030 if (!SWIG_IsOK(ecode1)) {
12031 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12032 }
12033 arg1 = static_cast< byte >(val1);
12034 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12035 if (!SWIG_IsOK(ecode2)) {
12036 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12037 }
12038 arg2 = static_cast< byte >(val2);
12039 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12040 if (!SWIG_IsOK(ecode3)) {
12041 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12042 }
12043 arg3 = static_cast< byte >(val3);
12044 {
12045 PyThreadState* __tstate = wxPyBeginAllowThreads();
12046 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12051 return resultobj;
12052 fail:
12053 return NULL;
12054 }
12055
12056
12057 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12058 PyObject *resultobj = 0;
12059 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12060 byte *arg2 = (byte *) 0 ;
12061 byte *arg3 = (byte *) 0 ;
12062 byte *arg4 = (byte *) 0 ;
12063 byte arg5 = (byte) 1 ;
12064 byte arg6 = (byte) 0 ;
12065 byte arg7 = (byte) 0 ;
12066 bool result;
12067 void *argp1 = 0 ;
12068 int res1 = 0 ;
12069 byte temp2 ;
12070 int res2 = SWIG_TMPOBJ ;
12071 byte temp3 ;
12072 int res3 = SWIG_TMPOBJ ;
12073 byte temp4 ;
12074 int res4 = SWIG_TMPOBJ ;
12075 unsigned char val5 ;
12076 int ecode5 = 0 ;
12077 unsigned char val6 ;
12078 int ecode6 = 0 ;
12079 unsigned char val7 ;
12080 int ecode7 = 0 ;
12081 PyObject * obj0 = 0 ;
12082 PyObject * obj1 = 0 ;
12083 PyObject * obj2 = 0 ;
12084 PyObject * obj3 = 0 ;
12085 char * kwnames[] = {
12086 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12087 };
12088
12089 arg2 = &temp2;
12090 arg3 = &temp3;
12091 arg4 = &temp4;
12092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12094 if (!SWIG_IsOK(res1)) {
12095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12096 }
12097 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12098 if (obj1) {
12099 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12100 if (!SWIG_IsOK(ecode5)) {
12101 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12102 }
12103 arg5 = static_cast< byte >(val5);
12104 }
12105 if (obj2) {
12106 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12107 if (!SWIG_IsOK(ecode6)) {
12108 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12109 }
12110 arg6 = static_cast< byte >(val6);
12111 }
12112 if (obj3) {
12113 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12114 if (!SWIG_IsOK(ecode7)) {
12115 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12116 }
12117 arg7 = static_cast< byte >(val7);
12118 }
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12122 wxPyEndAllowThreads(__tstate);
12123 if (PyErr_Occurred()) SWIG_fail;
12124 }
12125 {
12126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12127 }
12128 if (SWIG_IsTmpObj(res2)) {
12129 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12130 } else {
12131 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12133 }
12134 if (SWIG_IsTmpObj(res3)) {
12135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12136 } else {
12137 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12139 }
12140 if (SWIG_IsTmpObj(res4)) {
12141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12142 } else {
12143 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12144 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12145 }
12146 return resultobj;
12147 fail:
12148 return NULL;
12149 }
12150
12151
12152 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12153 PyObject *resultobj = 0;
12154 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12155 unsigned long arg2 ;
12156 unsigned long result;
12157 void *argp1 = 0 ;
12158 int res1 = 0 ;
12159 unsigned long val2 ;
12160 int ecode2 = 0 ;
12161 PyObject * obj0 = 0 ;
12162 PyObject * obj1 = 0 ;
12163 char * kwnames[] = {
12164 (char *) "self",(char *) "key", NULL
12165 };
12166
12167 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12168 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12169 if (!SWIG_IsOK(res1)) {
12170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12171 }
12172 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12173 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12174 if (!SWIG_IsOK(ecode2)) {
12175 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12176 }
12177 arg2 = static_cast< unsigned long >(val2);
12178 {
12179 PyThreadState* __tstate = wxPyBeginAllowThreads();
12180 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12181 wxPyEndAllowThreads(__tstate);
12182 if (PyErr_Occurred()) SWIG_fail;
12183 }
12184 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj = 0;
12193 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12194 byte arg2 ;
12195 byte arg3 ;
12196 byte arg4 ;
12197 unsigned long result;
12198 void *argp1 = 0 ;
12199 int res1 = 0 ;
12200 unsigned char val2 ;
12201 int ecode2 = 0 ;
12202 unsigned char val3 ;
12203 int ecode3 = 0 ;
12204 unsigned char val4 ;
12205 int ecode4 = 0 ;
12206 PyObject * obj0 = 0 ;
12207 PyObject * obj1 = 0 ;
12208 PyObject * obj2 = 0 ;
12209 PyObject * obj3 = 0 ;
12210 char * kwnames[] = {
12211 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12212 };
12213
12214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12216 if (!SWIG_IsOK(res1)) {
12217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12218 }
12219 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12220 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12221 if (!SWIG_IsOK(ecode2)) {
12222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12223 }
12224 arg2 = static_cast< byte >(val2);
12225 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12226 if (!SWIG_IsOK(ecode3)) {
12227 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12228 }
12229 arg3 = static_cast< byte >(val3);
12230 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12231 if (!SWIG_IsOK(ecode4)) {
12232 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12233 }
12234 arg4 = static_cast< byte >(val4);
12235 {
12236 PyThreadState* __tstate = wxPyBeginAllowThreads();
12237 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12238 wxPyEndAllowThreads(__tstate);
12239 if (PyErr_Occurred()) SWIG_fail;
12240 }
12241 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12242 return resultobj;
12243 fail:
12244 return NULL;
12245 }
12246
12247
12248 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12249 PyObject *resultobj = 0;
12250 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12251 wxColour *arg2 = 0 ;
12252 unsigned long result;
12253 void *argp1 = 0 ;
12254 int res1 = 0 ;
12255 wxColour temp2 ;
12256 PyObject * obj0 = 0 ;
12257 PyObject * obj1 = 0 ;
12258 char * kwnames[] = {
12259 (char *) "self",(char *) "colour", NULL
12260 };
12261
12262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12264 if (!SWIG_IsOK(res1)) {
12265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12266 }
12267 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12268 {
12269 arg2 = &temp2;
12270 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12271 }
12272 {
12273 PyThreadState* __tstate = wxPyBeginAllowThreads();
12274 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12275 wxPyEndAllowThreads(__tstate);
12276 if (PyErr_Occurred()) SWIG_fail;
12277 }
12278 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12279 return resultobj;
12280 fail:
12281 return NULL;
12282 }
12283
12284
12285 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12286 PyObject *obj;
12287 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12288 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12289 return SWIG_Py_Void();
12290 }
12291
12292 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12293 return SWIG_Python_InitShadowInstance(args);
12294 }
12295
12296 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12297 PyObject *resultobj = 0;
12298 byte arg1 = (byte) 0 ;
12299 byte arg2 = (byte) 0 ;
12300 byte arg3 = (byte) 0 ;
12301 wxImage_RGBValue *result = 0 ;
12302 unsigned char val1 ;
12303 int ecode1 = 0 ;
12304 unsigned char val2 ;
12305 int ecode2 = 0 ;
12306 unsigned char val3 ;
12307 int ecode3 = 0 ;
12308 PyObject * obj0 = 0 ;
12309 PyObject * obj1 = 0 ;
12310 PyObject * obj2 = 0 ;
12311 char * kwnames[] = {
12312 (char *) "r",(char *) "g",(char *) "b", NULL
12313 };
12314
12315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12316 if (obj0) {
12317 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12318 if (!SWIG_IsOK(ecode1)) {
12319 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12320 }
12321 arg1 = static_cast< byte >(val1);
12322 }
12323 if (obj1) {
12324 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12325 if (!SWIG_IsOK(ecode2)) {
12326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12327 }
12328 arg2 = static_cast< byte >(val2);
12329 }
12330 if (obj2) {
12331 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12332 if (!SWIG_IsOK(ecode3)) {
12333 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12334 }
12335 arg3 = static_cast< byte >(val3);
12336 }
12337 {
12338 PyThreadState* __tstate = wxPyBeginAllowThreads();
12339 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12340 wxPyEndAllowThreads(__tstate);
12341 if (PyErr_Occurred()) SWIG_fail;
12342 }
12343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12344 return resultobj;
12345 fail:
12346 return NULL;
12347 }
12348
12349
12350 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12351 PyObject *resultobj = 0;
12352 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12353 byte arg2 ;
12354 void *argp1 = 0 ;
12355 int res1 = 0 ;
12356 unsigned char val2 ;
12357 int ecode2 = 0 ;
12358 PyObject *swig_obj[2] ;
12359
12360 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12362 if (!SWIG_IsOK(res1)) {
12363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12364 }
12365 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12366 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12367 if (!SWIG_IsOK(ecode2)) {
12368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12369 }
12370 arg2 = static_cast< byte >(val2);
12371 if (arg1) (arg1)->red = arg2;
12372
12373 resultobj = SWIG_Py_Void();
12374 return resultobj;
12375 fail:
12376 return NULL;
12377 }
12378
12379
12380 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12381 PyObject *resultobj = 0;
12382 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12383 byte result;
12384 void *argp1 = 0 ;
12385 int res1 = 0 ;
12386 PyObject *swig_obj[1] ;
12387
12388 if (!args) SWIG_fail;
12389 swig_obj[0] = args;
12390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12393 }
12394 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12395 result = (byte) ((arg1)->red);
12396 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12397 return resultobj;
12398 fail:
12399 return NULL;
12400 }
12401
12402
12403 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12404 PyObject *resultobj = 0;
12405 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12406 byte arg2 ;
12407 void *argp1 = 0 ;
12408 int res1 = 0 ;
12409 unsigned char val2 ;
12410 int ecode2 = 0 ;
12411 PyObject *swig_obj[2] ;
12412
12413 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12415 if (!SWIG_IsOK(res1)) {
12416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12417 }
12418 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12419 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12420 if (!SWIG_IsOK(ecode2)) {
12421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12422 }
12423 arg2 = static_cast< byte >(val2);
12424 if (arg1) (arg1)->green = arg2;
12425
12426 resultobj = SWIG_Py_Void();
12427 return resultobj;
12428 fail:
12429 return NULL;
12430 }
12431
12432
12433 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12434 PyObject *resultobj = 0;
12435 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12436 byte result;
12437 void *argp1 = 0 ;
12438 int res1 = 0 ;
12439 PyObject *swig_obj[1] ;
12440
12441 if (!args) SWIG_fail;
12442 swig_obj[0] = args;
12443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12444 if (!SWIG_IsOK(res1)) {
12445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12446 }
12447 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12448 result = (byte) ((arg1)->green);
12449 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12450 return resultobj;
12451 fail:
12452 return NULL;
12453 }
12454
12455
12456 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12457 PyObject *resultobj = 0;
12458 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12459 byte arg2 ;
12460 void *argp1 = 0 ;
12461 int res1 = 0 ;
12462 unsigned char val2 ;
12463 int ecode2 = 0 ;
12464 PyObject *swig_obj[2] ;
12465
12466 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12468 if (!SWIG_IsOK(res1)) {
12469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12470 }
12471 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12472 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12473 if (!SWIG_IsOK(ecode2)) {
12474 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12475 }
12476 arg2 = static_cast< byte >(val2);
12477 if (arg1) (arg1)->blue = arg2;
12478
12479 resultobj = SWIG_Py_Void();
12480 return resultobj;
12481 fail:
12482 return NULL;
12483 }
12484
12485
12486 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12487 PyObject *resultobj = 0;
12488 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12489 byte result;
12490 void *argp1 = 0 ;
12491 int res1 = 0 ;
12492 PyObject *swig_obj[1] ;
12493
12494 if (!args) SWIG_fail;
12495 swig_obj[0] = args;
12496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12497 if (!SWIG_IsOK(res1)) {
12498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12499 }
12500 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12501 result = (byte) ((arg1)->blue);
12502 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12503 return resultobj;
12504 fail:
12505 return NULL;
12506 }
12507
12508
12509 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12510 PyObject *obj;
12511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12512 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12513 return SWIG_Py_Void();
12514 }
12515
12516 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12517 return SWIG_Python_InitShadowInstance(args);
12518 }
12519
12520 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12521 PyObject *resultobj = 0;
12522 double arg1 = (double) 0.0 ;
12523 double arg2 = (double) 0.0 ;
12524 double arg3 = (double) 0.0 ;
12525 wxImage_HSVValue *result = 0 ;
12526 double val1 ;
12527 int ecode1 = 0 ;
12528 double val2 ;
12529 int ecode2 = 0 ;
12530 double val3 ;
12531 int ecode3 = 0 ;
12532 PyObject * obj0 = 0 ;
12533 PyObject * obj1 = 0 ;
12534 PyObject * obj2 = 0 ;
12535 char * kwnames[] = {
12536 (char *) "h",(char *) "s",(char *) "v", NULL
12537 };
12538
12539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12540 if (obj0) {
12541 ecode1 = SWIG_AsVal_double(obj0, &val1);
12542 if (!SWIG_IsOK(ecode1)) {
12543 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12544 }
12545 arg1 = static_cast< double >(val1);
12546 }
12547 if (obj1) {
12548 ecode2 = SWIG_AsVal_double(obj1, &val2);
12549 if (!SWIG_IsOK(ecode2)) {
12550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12551 }
12552 arg2 = static_cast< double >(val2);
12553 }
12554 if (obj2) {
12555 ecode3 = SWIG_AsVal_double(obj2, &val3);
12556 if (!SWIG_IsOK(ecode3)) {
12557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12558 }
12559 arg3 = static_cast< double >(val3);
12560 }
12561 {
12562 PyThreadState* __tstate = wxPyBeginAllowThreads();
12563 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12564 wxPyEndAllowThreads(__tstate);
12565 if (PyErr_Occurred()) SWIG_fail;
12566 }
12567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12568 return resultobj;
12569 fail:
12570 return NULL;
12571 }
12572
12573
12574 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12575 PyObject *resultobj = 0;
12576 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12577 double arg2 ;
12578 void *argp1 = 0 ;
12579 int res1 = 0 ;
12580 double val2 ;
12581 int ecode2 = 0 ;
12582 PyObject *swig_obj[2] ;
12583
12584 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12586 if (!SWIG_IsOK(res1)) {
12587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12588 }
12589 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12590 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12591 if (!SWIG_IsOK(ecode2)) {
12592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12593 }
12594 arg2 = static_cast< double >(val2);
12595 if (arg1) (arg1)->hue = arg2;
12596
12597 resultobj = SWIG_Py_Void();
12598 return resultobj;
12599 fail:
12600 return NULL;
12601 }
12602
12603
12604 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12605 PyObject *resultobj = 0;
12606 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12607 double result;
12608 void *argp1 = 0 ;
12609 int res1 = 0 ;
12610 PyObject *swig_obj[1] ;
12611
12612 if (!args) SWIG_fail;
12613 swig_obj[0] = args;
12614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12615 if (!SWIG_IsOK(res1)) {
12616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12617 }
12618 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12619 result = (double) ((arg1)->hue);
12620 resultobj = SWIG_From_double(static_cast< double >(result));
12621 return resultobj;
12622 fail:
12623 return NULL;
12624 }
12625
12626
12627 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12628 PyObject *resultobj = 0;
12629 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12630 double arg2 ;
12631 void *argp1 = 0 ;
12632 int res1 = 0 ;
12633 double val2 ;
12634 int ecode2 = 0 ;
12635 PyObject *swig_obj[2] ;
12636
12637 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12639 if (!SWIG_IsOK(res1)) {
12640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12641 }
12642 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12643 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12644 if (!SWIG_IsOK(ecode2)) {
12645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12646 }
12647 arg2 = static_cast< double >(val2);
12648 if (arg1) (arg1)->saturation = arg2;
12649
12650 resultobj = SWIG_Py_Void();
12651 return resultobj;
12652 fail:
12653 return NULL;
12654 }
12655
12656
12657 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12658 PyObject *resultobj = 0;
12659 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12660 double result;
12661 void *argp1 = 0 ;
12662 int res1 = 0 ;
12663 PyObject *swig_obj[1] ;
12664
12665 if (!args) SWIG_fail;
12666 swig_obj[0] = args;
12667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12668 if (!SWIG_IsOK(res1)) {
12669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12670 }
12671 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12672 result = (double) ((arg1)->saturation);
12673 resultobj = SWIG_From_double(static_cast< double >(result));
12674 return resultobj;
12675 fail:
12676 return NULL;
12677 }
12678
12679
12680 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12681 PyObject *resultobj = 0;
12682 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12683 double arg2 ;
12684 void *argp1 = 0 ;
12685 int res1 = 0 ;
12686 double val2 ;
12687 int ecode2 = 0 ;
12688 PyObject *swig_obj[2] ;
12689
12690 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12692 if (!SWIG_IsOK(res1)) {
12693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12694 }
12695 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12696 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12697 if (!SWIG_IsOK(ecode2)) {
12698 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12699 }
12700 arg2 = static_cast< double >(val2);
12701 if (arg1) (arg1)->value = arg2;
12702
12703 resultobj = SWIG_Py_Void();
12704 return resultobj;
12705 fail:
12706 return NULL;
12707 }
12708
12709
12710 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12711 PyObject *resultobj = 0;
12712 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12713 double result;
12714 void *argp1 = 0 ;
12715 int res1 = 0 ;
12716 PyObject *swig_obj[1] ;
12717
12718 if (!args) SWIG_fail;
12719 swig_obj[0] = args;
12720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12721 if (!SWIG_IsOK(res1)) {
12722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12723 }
12724 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12725 result = (double) ((arg1)->value);
12726 resultobj = SWIG_From_double(static_cast< double >(result));
12727 return resultobj;
12728 fail:
12729 return NULL;
12730 }
12731
12732
12733 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12734 PyObject *obj;
12735 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12736 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12737 return SWIG_Py_Void();
12738 }
12739
12740 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12741 return SWIG_Python_InitShadowInstance(args);
12742 }
12743
12744 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12745 PyObject *resultobj = 0;
12746 wxString *arg1 = 0 ;
12747 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12748 int arg3 = (int) -1 ;
12749 wxImage *result = 0 ;
12750 bool temp1 = false ;
12751 long val2 ;
12752 int ecode2 = 0 ;
12753 int val3 ;
12754 int ecode3 = 0 ;
12755 PyObject * obj0 = 0 ;
12756 PyObject * obj1 = 0 ;
12757 PyObject * obj2 = 0 ;
12758 char * kwnames[] = {
12759 (char *) "name",(char *) "type",(char *) "index", NULL
12760 };
12761
12762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12763 {
12764 arg1 = wxString_in_helper(obj0);
12765 if (arg1 == NULL) SWIG_fail;
12766 temp1 = true;
12767 }
12768 if (obj1) {
12769 ecode2 = SWIG_AsVal_long(obj1, &val2);
12770 if (!SWIG_IsOK(ecode2)) {
12771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12772 }
12773 arg2 = static_cast< long >(val2);
12774 }
12775 if (obj2) {
12776 ecode3 = SWIG_AsVal_int(obj2, &val3);
12777 if (!SWIG_IsOK(ecode3)) {
12778 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12779 }
12780 arg3 = static_cast< int >(val3);
12781 }
12782 {
12783 PyThreadState* __tstate = wxPyBeginAllowThreads();
12784 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12785 wxPyEndAllowThreads(__tstate);
12786 if (PyErr_Occurred()) SWIG_fail;
12787 }
12788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12789 {
12790 if (temp1)
12791 delete arg1;
12792 }
12793 return resultobj;
12794 fail:
12795 {
12796 if (temp1)
12797 delete arg1;
12798 }
12799 return NULL;
12800 }
12801
12802
12803 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12804 PyObject *resultobj = 0;
12805 wxImage *arg1 = (wxImage *) 0 ;
12806 void *argp1 = 0 ;
12807 int res1 = 0 ;
12808 PyObject *swig_obj[1] ;
12809
12810 if (!args) SWIG_fail;
12811 swig_obj[0] = args;
12812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12813 if (!SWIG_IsOK(res1)) {
12814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12815 }
12816 arg1 = reinterpret_cast< wxImage * >(argp1);
12817 {
12818 PyThreadState* __tstate = wxPyBeginAllowThreads();
12819 delete arg1;
12820
12821 wxPyEndAllowThreads(__tstate);
12822 if (PyErr_Occurred()) SWIG_fail;
12823 }
12824 resultobj = SWIG_Py_Void();
12825 return resultobj;
12826 fail:
12827 return NULL;
12828 }
12829
12830
12831 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12832 PyObject *resultobj = 0;
12833 wxString *arg1 = 0 ;
12834 wxString *arg2 = 0 ;
12835 int arg3 = (int) -1 ;
12836 wxImage *result = 0 ;
12837 bool temp1 = false ;
12838 bool temp2 = false ;
12839 int val3 ;
12840 int ecode3 = 0 ;
12841 PyObject * obj0 = 0 ;
12842 PyObject * obj1 = 0 ;
12843 PyObject * obj2 = 0 ;
12844 char * kwnames[] = {
12845 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12846 };
12847
12848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12849 {
12850 arg1 = wxString_in_helper(obj0);
12851 if (arg1 == NULL) SWIG_fail;
12852 temp1 = true;
12853 }
12854 {
12855 arg2 = wxString_in_helper(obj1);
12856 if (arg2 == NULL) SWIG_fail;
12857 temp2 = true;
12858 }
12859 if (obj2) {
12860 ecode3 = SWIG_AsVal_int(obj2, &val3);
12861 if (!SWIG_IsOK(ecode3)) {
12862 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12863 }
12864 arg3 = static_cast< int >(val3);
12865 }
12866 {
12867 PyThreadState* __tstate = wxPyBeginAllowThreads();
12868 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12869 wxPyEndAllowThreads(__tstate);
12870 if (PyErr_Occurred()) SWIG_fail;
12871 }
12872 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12873 {
12874 if (temp1)
12875 delete arg1;
12876 }
12877 {
12878 if (temp2)
12879 delete arg2;
12880 }
12881 return resultobj;
12882 fail:
12883 {
12884 if (temp1)
12885 delete arg1;
12886 }
12887 {
12888 if (temp2)
12889 delete arg2;
12890 }
12891 return NULL;
12892 }
12893
12894
12895 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12896 PyObject *resultobj = 0;
12897 wxInputStream *arg1 = 0 ;
12898 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12899 int arg3 = (int) -1 ;
12900 wxImage *result = 0 ;
12901 wxPyInputStream *temp1 ;
12902 bool created1 ;
12903 long val2 ;
12904 int ecode2 = 0 ;
12905 int val3 ;
12906 int ecode3 = 0 ;
12907 PyObject * obj0 = 0 ;
12908 PyObject * obj1 = 0 ;
12909 PyObject * obj2 = 0 ;
12910 char * kwnames[] = {
12911 (char *) "stream",(char *) "type",(char *) "index", NULL
12912 };
12913
12914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12915 {
12916 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12917 arg1 = temp1->m_wxis;
12918 created1 = false;
12919 } else {
12920 PyErr_Clear(); // clear the failure of the wxPyConvert above
12921 arg1 = wxPyCBInputStream_create(obj0, false);
12922 if (arg1 == NULL) {
12923 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12924 SWIG_fail;
12925 }
12926 created1 = true;
12927 }
12928 }
12929 if (obj1) {
12930 ecode2 = SWIG_AsVal_long(obj1, &val2);
12931 if (!SWIG_IsOK(ecode2)) {
12932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
12933 }
12934 arg2 = static_cast< long >(val2);
12935 }
12936 if (obj2) {
12937 ecode3 = SWIG_AsVal_int(obj2, &val3);
12938 if (!SWIG_IsOK(ecode3)) {
12939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
12940 }
12941 arg3 = static_cast< int >(val3);
12942 }
12943 {
12944 PyThreadState* __tstate = wxPyBeginAllowThreads();
12945 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
12946 wxPyEndAllowThreads(__tstate);
12947 if (PyErr_Occurred()) SWIG_fail;
12948 }
12949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12950 {
12951 if (created1) delete arg1;
12952 }
12953 return resultobj;
12954 fail:
12955 {
12956 if (created1) delete arg1;
12957 }
12958 return NULL;
12959 }
12960
12961
12962 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12963 PyObject *resultobj = 0;
12964 wxInputStream *arg1 = 0 ;
12965 wxString *arg2 = 0 ;
12966 int arg3 = (int) -1 ;
12967 wxImage *result = 0 ;
12968 wxPyInputStream *temp1 ;
12969 bool created1 ;
12970 bool temp2 = false ;
12971 int val3 ;
12972 int ecode3 = 0 ;
12973 PyObject * obj0 = 0 ;
12974 PyObject * obj1 = 0 ;
12975 PyObject * obj2 = 0 ;
12976 char * kwnames[] = {
12977 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
12978 };
12979
12980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12981 {
12982 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12983 arg1 = temp1->m_wxis;
12984 created1 = false;
12985 } else {
12986 PyErr_Clear(); // clear the failure of the wxPyConvert above
12987 arg1 = wxPyCBInputStream_create(obj0, false);
12988 if (arg1 == NULL) {
12989 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12990 SWIG_fail;
12991 }
12992 created1 = true;
12993 }
12994 }
12995 {
12996 arg2 = wxString_in_helper(obj1);
12997 if (arg2 == NULL) SWIG_fail;
12998 temp2 = true;
12999 }
13000 if (obj2) {
13001 ecode3 = SWIG_AsVal_int(obj2, &val3);
13002 if (!SWIG_IsOK(ecode3)) {
13003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13004 }
13005 arg3 = static_cast< int >(val3);
13006 }
13007 {
13008 PyThreadState* __tstate = wxPyBeginAllowThreads();
13009 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13010 wxPyEndAllowThreads(__tstate);
13011 if (PyErr_Occurred()) SWIG_fail;
13012 }
13013 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13014 {
13015 if (created1) delete arg1;
13016 }
13017 {
13018 if (temp2)
13019 delete arg2;
13020 }
13021 return resultobj;
13022 fail:
13023 {
13024 if (created1) delete arg1;
13025 }
13026 {
13027 if (temp2)
13028 delete arg2;
13029 }
13030 return NULL;
13031 }
13032
13033
13034 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13035 PyObject *resultobj = 0;
13036 int arg1 = (int) 0 ;
13037 int arg2 = (int) 0 ;
13038 bool arg3 = (bool) true ;
13039 wxImage *result = 0 ;
13040 int val1 ;
13041 int ecode1 = 0 ;
13042 int val2 ;
13043 int ecode2 = 0 ;
13044 bool val3 ;
13045 int ecode3 = 0 ;
13046 PyObject * obj0 = 0 ;
13047 PyObject * obj1 = 0 ;
13048 PyObject * obj2 = 0 ;
13049 char * kwnames[] = {
13050 (char *) "width",(char *) "height",(char *) "clear", NULL
13051 };
13052
13053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13054 if (obj0) {
13055 ecode1 = SWIG_AsVal_int(obj0, &val1);
13056 if (!SWIG_IsOK(ecode1)) {
13057 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13058 }
13059 arg1 = static_cast< int >(val1);
13060 }
13061 if (obj1) {
13062 ecode2 = SWIG_AsVal_int(obj1, &val2);
13063 if (!SWIG_IsOK(ecode2)) {
13064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13065 }
13066 arg2 = static_cast< int >(val2);
13067 }
13068 if (obj2) {
13069 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13070 if (!SWIG_IsOK(ecode3)) {
13071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13072 }
13073 arg3 = static_cast< bool >(val3);
13074 }
13075 {
13076 PyThreadState* __tstate = wxPyBeginAllowThreads();
13077 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13078 wxPyEndAllowThreads(__tstate);
13079 if (PyErr_Occurred()) SWIG_fail;
13080 }
13081 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13082 return resultobj;
13083 fail:
13084 return NULL;
13085 }
13086
13087
13088 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13089 PyObject *resultobj = 0;
13090 wxBitmap *arg1 = 0 ;
13091 wxImage *result = 0 ;
13092 void *argp1 = 0 ;
13093 int res1 = 0 ;
13094 PyObject * obj0 = 0 ;
13095 char * kwnames[] = {
13096 (char *) "bitmap", NULL
13097 };
13098
13099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13100 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13101 if (!SWIG_IsOK(res1)) {
13102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13103 }
13104 if (!argp1) {
13105 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13106 }
13107 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13108 {
13109 if (!wxPyCheckForApp()) SWIG_fail;
13110 PyThreadState* __tstate = wxPyBeginAllowThreads();
13111 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13112 wxPyEndAllowThreads(__tstate);
13113 if (PyErr_Occurred()) SWIG_fail;
13114 }
13115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13116 return resultobj;
13117 fail:
13118 return NULL;
13119 }
13120
13121
13122 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13123 PyObject *resultobj = 0;
13124 int arg1 ;
13125 int arg2 ;
13126 buffer arg3 ;
13127 int arg4 ;
13128 wxImage *result = 0 ;
13129 int val1 ;
13130 int ecode1 = 0 ;
13131 int val2 ;
13132 int ecode2 = 0 ;
13133 PyObject * obj0 = 0 ;
13134 PyObject * obj1 = 0 ;
13135 PyObject * obj2 = 0 ;
13136 char * kwnames[] = {
13137 (char *) "width",(char *) "height",(char *) "data", NULL
13138 };
13139
13140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13141 ecode1 = SWIG_AsVal_int(obj0, &val1);
13142 if (!SWIG_IsOK(ecode1)) {
13143 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13144 }
13145 arg1 = static_cast< int >(val1);
13146 ecode2 = SWIG_AsVal_int(obj1, &val2);
13147 if (!SWIG_IsOK(ecode2)) {
13148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13149 }
13150 arg2 = static_cast< int >(val2);
13151 {
13152 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13153 }
13154 {
13155 PyThreadState* __tstate = wxPyBeginAllowThreads();
13156 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13161 return resultobj;
13162 fail:
13163 return NULL;
13164 }
13165
13166
13167 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13168 PyObject *resultobj = 0;
13169 int arg1 ;
13170 int arg2 ;
13171 buffer arg3 ;
13172 int arg4 ;
13173 buffer arg5 ;
13174 int arg6 ;
13175 wxImage *result = 0 ;
13176 int val1 ;
13177 int ecode1 = 0 ;
13178 int val2 ;
13179 int ecode2 = 0 ;
13180 PyObject * obj0 = 0 ;
13181 PyObject * obj1 = 0 ;
13182 PyObject * obj2 = 0 ;
13183 PyObject * obj3 = 0 ;
13184 char * kwnames[] = {
13185 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13186 };
13187
13188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13189 ecode1 = SWIG_AsVal_int(obj0, &val1);
13190 if (!SWIG_IsOK(ecode1)) {
13191 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13192 }
13193 arg1 = static_cast< int >(val1);
13194 ecode2 = SWIG_AsVal_int(obj1, &val2);
13195 if (!SWIG_IsOK(ecode2)) {
13196 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13197 }
13198 arg2 = static_cast< int >(val2);
13199 {
13200 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13201 }
13202 {
13203 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13204 }
13205 {
13206 PyThreadState* __tstate = wxPyBeginAllowThreads();
13207 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13208 wxPyEndAllowThreads(__tstate);
13209 if (PyErr_Occurred()) SWIG_fail;
13210 }
13211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13212 return resultobj;
13213 fail:
13214 return NULL;
13215 }
13216
13217
13218 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13219 PyObject *resultobj = 0;
13220 wxImage *arg1 = (wxImage *) 0 ;
13221 int arg2 ;
13222 int arg3 ;
13223 bool arg4 = (bool) true ;
13224 void *argp1 = 0 ;
13225 int res1 = 0 ;
13226 int val2 ;
13227 int ecode2 = 0 ;
13228 int val3 ;
13229 int ecode3 = 0 ;
13230 bool val4 ;
13231 int ecode4 = 0 ;
13232 PyObject * obj0 = 0 ;
13233 PyObject * obj1 = 0 ;
13234 PyObject * obj2 = 0 ;
13235 PyObject * obj3 = 0 ;
13236 char * kwnames[] = {
13237 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13238 };
13239
13240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13242 if (!SWIG_IsOK(res1)) {
13243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13244 }
13245 arg1 = reinterpret_cast< wxImage * >(argp1);
13246 ecode2 = SWIG_AsVal_int(obj1, &val2);
13247 if (!SWIG_IsOK(ecode2)) {
13248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13249 }
13250 arg2 = static_cast< int >(val2);
13251 ecode3 = SWIG_AsVal_int(obj2, &val3);
13252 if (!SWIG_IsOK(ecode3)) {
13253 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13254 }
13255 arg3 = static_cast< int >(val3);
13256 if (obj3) {
13257 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13258 if (!SWIG_IsOK(ecode4)) {
13259 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13260 }
13261 arg4 = static_cast< bool >(val4);
13262 }
13263 {
13264 PyThreadState* __tstate = wxPyBeginAllowThreads();
13265 (arg1)->Create(arg2,arg3,arg4);
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 resultobj = SWIG_Py_Void();
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13277 PyObject *resultobj = 0;
13278 wxImage *arg1 = (wxImage *) 0 ;
13279 void *argp1 = 0 ;
13280 int res1 = 0 ;
13281 PyObject *swig_obj[1] ;
13282
13283 if (!args) SWIG_fail;
13284 swig_obj[0] = args;
13285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13286 if (!SWIG_IsOK(res1)) {
13287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13288 }
13289 arg1 = reinterpret_cast< wxImage * >(argp1);
13290 {
13291 PyThreadState* __tstate = wxPyBeginAllowThreads();
13292 (arg1)->Destroy();
13293 wxPyEndAllowThreads(__tstate);
13294 if (PyErr_Occurred()) SWIG_fail;
13295 }
13296 resultobj = SWIG_Py_Void();
13297 return resultobj;
13298 fail:
13299 return NULL;
13300 }
13301
13302
13303 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13304 PyObject *resultobj = 0;
13305 wxImage *arg1 = (wxImage *) 0 ;
13306 int arg2 ;
13307 int arg3 ;
13308 SwigValueWrapper<wxImage > result;
13309 void *argp1 = 0 ;
13310 int res1 = 0 ;
13311 int val2 ;
13312 int ecode2 = 0 ;
13313 int val3 ;
13314 int ecode3 = 0 ;
13315 PyObject * obj0 = 0 ;
13316 PyObject * obj1 = 0 ;
13317 PyObject * obj2 = 0 ;
13318 char * kwnames[] = {
13319 (char *) "self",(char *) "width",(char *) "height", NULL
13320 };
13321
13322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13324 if (!SWIG_IsOK(res1)) {
13325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13326 }
13327 arg1 = reinterpret_cast< wxImage * >(argp1);
13328 ecode2 = SWIG_AsVal_int(obj1, &val2);
13329 if (!SWIG_IsOK(ecode2)) {
13330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13331 }
13332 arg2 = static_cast< int >(val2);
13333 ecode3 = SWIG_AsVal_int(obj2, &val3);
13334 if (!SWIG_IsOK(ecode3)) {
13335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13336 }
13337 arg3 = static_cast< int >(val3);
13338 {
13339 PyThreadState* __tstate = wxPyBeginAllowThreads();
13340 result = (arg1)->Scale(arg2,arg3);
13341 wxPyEndAllowThreads(__tstate);
13342 if (PyErr_Occurred()) SWIG_fail;
13343 }
13344 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13345 return resultobj;
13346 fail:
13347 return NULL;
13348 }
13349
13350
13351 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13352 PyObject *resultobj = 0;
13353 wxImage *arg1 = (wxImage *) 0 ;
13354 int arg2 ;
13355 int arg3 ;
13356 SwigValueWrapper<wxImage > result;
13357 void *argp1 = 0 ;
13358 int res1 = 0 ;
13359 int val2 ;
13360 int ecode2 = 0 ;
13361 int val3 ;
13362 int ecode3 = 0 ;
13363 PyObject * obj0 = 0 ;
13364 PyObject * obj1 = 0 ;
13365 PyObject * obj2 = 0 ;
13366 char * kwnames[] = {
13367 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13368 };
13369
13370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13372 if (!SWIG_IsOK(res1)) {
13373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13374 }
13375 arg1 = reinterpret_cast< wxImage * >(argp1);
13376 ecode2 = SWIG_AsVal_int(obj1, &val2);
13377 if (!SWIG_IsOK(ecode2)) {
13378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13379 }
13380 arg2 = static_cast< int >(val2);
13381 ecode3 = SWIG_AsVal_int(obj2, &val3);
13382 if (!SWIG_IsOK(ecode3)) {
13383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13384 }
13385 arg3 = static_cast< int >(val3);
13386 {
13387 PyThreadState* __tstate = wxPyBeginAllowThreads();
13388 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13389 wxPyEndAllowThreads(__tstate);
13390 if (PyErr_Occurred()) SWIG_fail;
13391 }
13392 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13393 return resultobj;
13394 fail:
13395 return NULL;
13396 }
13397
13398
13399 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13400 PyObject *resultobj = 0;
13401 wxImage *arg1 = (wxImage *) 0 ;
13402 int arg2 ;
13403 int arg3 ;
13404 wxImage *result = 0 ;
13405 void *argp1 = 0 ;
13406 int res1 = 0 ;
13407 int val2 ;
13408 int ecode2 = 0 ;
13409 int val3 ;
13410 int ecode3 = 0 ;
13411 PyObject * obj0 = 0 ;
13412 PyObject * obj1 = 0 ;
13413 PyObject * obj2 = 0 ;
13414 char * kwnames[] = {
13415 (char *) "self",(char *) "width",(char *) "height", NULL
13416 };
13417
13418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13420 if (!SWIG_IsOK(res1)) {
13421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13422 }
13423 arg1 = reinterpret_cast< wxImage * >(argp1);
13424 ecode2 = SWIG_AsVal_int(obj1, &val2);
13425 if (!SWIG_IsOK(ecode2)) {
13426 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13427 }
13428 arg2 = static_cast< int >(val2);
13429 ecode3 = SWIG_AsVal_int(obj2, &val3);
13430 if (!SWIG_IsOK(ecode3)) {
13431 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13432 }
13433 arg3 = static_cast< int >(val3);
13434 {
13435 PyThreadState* __tstate = wxPyBeginAllowThreads();
13436 {
13437 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13438 result = (wxImage *) &_result_ref;
13439 }
13440 wxPyEndAllowThreads(__tstate);
13441 if (PyErr_Occurred()) SWIG_fail;
13442 }
13443 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13444 return resultobj;
13445 fail:
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13451 PyObject *resultobj = 0;
13452 wxImage *arg1 = (wxImage *) 0 ;
13453 wxSize *arg2 = 0 ;
13454 wxPoint *arg3 = 0 ;
13455 int arg4 = (int) -1 ;
13456 int arg5 = (int) -1 ;
13457 int arg6 = (int) -1 ;
13458 wxImage *result = 0 ;
13459 void *argp1 = 0 ;
13460 int res1 = 0 ;
13461 wxSize temp2 ;
13462 wxPoint temp3 ;
13463 int val4 ;
13464 int ecode4 = 0 ;
13465 int val5 ;
13466 int ecode5 = 0 ;
13467 int val6 ;
13468 int ecode6 = 0 ;
13469 PyObject * obj0 = 0 ;
13470 PyObject * obj1 = 0 ;
13471 PyObject * obj2 = 0 ;
13472 PyObject * obj3 = 0 ;
13473 PyObject * obj4 = 0 ;
13474 PyObject * obj5 = 0 ;
13475 char * kwnames[] = {
13476 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13477 };
13478
13479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13481 if (!SWIG_IsOK(res1)) {
13482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13483 }
13484 arg1 = reinterpret_cast< wxImage * >(argp1);
13485 {
13486 arg2 = &temp2;
13487 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13488 }
13489 {
13490 arg3 = &temp3;
13491 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13492 }
13493 if (obj3) {
13494 ecode4 = SWIG_AsVal_int(obj3, &val4);
13495 if (!SWIG_IsOK(ecode4)) {
13496 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13497 }
13498 arg4 = static_cast< int >(val4);
13499 }
13500 if (obj4) {
13501 ecode5 = SWIG_AsVal_int(obj4, &val5);
13502 if (!SWIG_IsOK(ecode5)) {
13503 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13504 }
13505 arg5 = static_cast< int >(val5);
13506 }
13507 if (obj5) {
13508 ecode6 = SWIG_AsVal_int(obj5, &val6);
13509 if (!SWIG_IsOK(ecode6)) {
13510 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13511 }
13512 arg6 = static_cast< int >(val6);
13513 }
13514 {
13515 PyThreadState* __tstate = wxPyBeginAllowThreads();
13516 {
13517 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13518 result = (wxImage *) &_result_ref;
13519 }
13520 wxPyEndAllowThreads(__tstate);
13521 if (PyErr_Occurred()) SWIG_fail;
13522 }
13523 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13524 return resultobj;
13525 fail:
13526 return NULL;
13527 }
13528
13529
13530 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13531 PyObject *resultobj = 0;
13532 wxImage *arg1 = (wxImage *) 0 ;
13533 int arg2 ;
13534 int arg3 ;
13535 byte arg4 ;
13536 byte arg5 ;
13537 byte arg6 ;
13538 void *argp1 = 0 ;
13539 int res1 = 0 ;
13540 int val2 ;
13541 int ecode2 = 0 ;
13542 int val3 ;
13543 int ecode3 = 0 ;
13544 unsigned char val4 ;
13545 int ecode4 = 0 ;
13546 unsigned char val5 ;
13547 int ecode5 = 0 ;
13548 unsigned char val6 ;
13549 int ecode6 = 0 ;
13550 PyObject * obj0 = 0 ;
13551 PyObject * obj1 = 0 ;
13552 PyObject * obj2 = 0 ;
13553 PyObject * obj3 = 0 ;
13554 PyObject * obj4 = 0 ;
13555 PyObject * obj5 = 0 ;
13556 char * kwnames[] = {
13557 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13558 };
13559
13560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13562 if (!SWIG_IsOK(res1)) {
13563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13564 }
13565 arg1 = reinterpret_cast< wxImage * >(argp1);
13566 ecode2 = SWIG_AsVal_int(obj1, &val2);
13567 if (!SWIG_IsOK(ecode2)) {
13568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13569 }
13570 arg2 = static_cast< int >(val2);
13571 ecode3 = SWIG_AsVal_int(obj2, &val3);
13572 if (!SWIG_IsOK(ecode3)) {
13573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13574 }
13575 arg3 = static_cast< int >(val3);
13576 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13577 if (!SWIG_IsOK(ecode4)) {
13578 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13579 }
13580 arg4 = static_cast< byte >(val4);
13581 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13582 if (!SWIG_IsOK(ecode5)) {
13583 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13584 }
13585 arg5 = static_cast< byte >(val5);
13586 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13587 if (!SWIG_IsOK(ecode6)) {
13588 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13589 }
13590 arg6 = static_cast< byte >(val6);
13591 {
13592 PyThreadState* __tstate = wxPyBeginAllowThreads();
13593 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13594 wxPyEndAllowThreads(__tstate);
13595 if (PyErr_Occurred()) SWIG_fail;
13596 }
13597 resultobj = SWIG_Py_Void();
13598 return resultobj;
13599 fail:
13600 return NULL;
13601 }
13602
13603
13604 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13605 PyObject *resultobj = 0;
13606 wxImage *arg1 = (wxImage *) 0 ;
13607 wxRect *arg2 = 0 ;
13608 byte arg3 ;
13609 byte arg4 ;
13610 byte arg5 ;
13611 void *argp1 = 0 ;
13612 int res1 = 0 ;
13613 wxRect temp2 ;
13614 unsigned char val3 ;
13615 int ecode3 = 0 ;
13616 unsigned char val4 ;
13617 int ecode4 = 0 ;
13618 unsigned char val5 ;
13619 int ecode5 = 0 ;
13620 PyObject * obj0 = 0 ;
13621 PyObject * obj1 = 0 ;
13622 PyObject * obj2 = 0 ;
13623 PyObject * obj3 = 0 ;
13624 PyObject * obj4 = 0 ;
13625 char * kwnames[] = {
13626 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13627 };
13628
13629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13631 if (!SWIG_IsOK(res1)) {
13632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13633 }
13634 arg1 = reinterpret_cast< wxImage * >(argp1);
13635 {
13636 arg2 = &temp2;
13637 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13638 }
13639 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13640 if (!SWIG_IsOK(ecode3)) {
13641 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13642 }
13643 arg3 = static_cast< byte >(val3);
13644 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13645 if (!SWIG_IsOK(ecode4)) {
13646 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13647 }
13648 arg4 = static_cast< byte >(val4);
13649 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13650 if (!SWIG_IsOK(ecode5)) {
13651 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13652 }
13653 arg5 = static_cast< byte >(val5);
13654 {
13655 PyThreadState* __tstate = wxPyBeginAllowThreads();
13656 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13657 wxPyEndAllowThreads(__tstate);
13658 if (PyErr_Occurred()) SWIG_fail;
13659 }
13660 resultobj = SWIG_Py_Void();
13661 return resultobj;
13662 fail:
13663 return NULL;
13664 }
13665
13666
13667 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13668 PyObject *resultobj = 0;
13669 wxImage *arg1 = (wxImage *) 0 ;
13670 int arg2 ;
13671 int arg3 ;
13672 byte result;
13673 void *argp1 = 0 ;
13674 int res1 = 0 ;
13675 int val2 ;
13676 int ecode2 = 0 ;
13677 int val3 ;
13678 int ecode3 = 0 ;
13679 PyObject * obj0 = 0 ;
13680 PyObject * obj1 = 0 ;
13681 PyObject * obj2 = 0 ;
13682 char * kwnames[] = {
13683 (char *) "self",(char *) "x",(char *) "y", NULL
13684 };
13685
13686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13688 if (!SWIG_IsOK(res1)) {
13689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13690 }
13691 arg1 = reinterpret_cast< wxImage * >(argp1);
13692 ecode2 = SWIG_AsVal_int(obj1, &val2);
13693 if (!SWIG_IsOK(ecode2)) {
13694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13695 }
13696 arg2 = static_cast< int >(val2);
13697 ecode3 = SWIG_AsVal_int(obj2, &val3);
13698 if (!SWIG_IsOK(ecode3)) {
13699 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13700 }
13701 arg3 = static_cast< int >(val3);
13702 {
13703 PyThreadState* __tstate = wxPyBeginAllowThreads();
13704 result = (byte)(arg1)->GetRed(arg2,arg3);
13705 wxPyEndAllowThreads(__tstate);
13706 if (PyErr_Occurred()) SWIG_fail;
13707 }
13708 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13709 return resultobj;
13710 fail:
13711 return NULL;
13712 }
13713
13714
13715 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13716 PyObject *resultobj = 0;
13717 wxImage *arg1 = (wxImage *) 0 ;
13718 int arg2 ;
13719 int arg3 ;
13720 byte result;
13721 void *argp1 = 0 ;
13722 int res1 = 0 ;
13723 int val2 ;
13724 int ecode2 = 0 ;
13725 int val3 ;
13726 int ecode3 = 0 ;
13727 PyObject * obj0 = 0 ;
13728 PyObject * obj1 = 0 ;
13729 PyObject * obj2 = 0 ;
13730 char * kwnames[] = {
13731 (char *) "self",(char *) "x",(char *) "y", NULL
13732 };
13733
13734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13736 if (!SWIG_IsOK(res1)) {
13737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13738 }
13739 arg1 = reinterpret_cast< wxImage * >(argp1);
13740 ecode2 = SWIG_AsVal_int(obj1, &val2);
13741 if (!SWIG_IsOK(ecode2)) {
13742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13743 }
13744 arg2 = static_cast< int >(val2);
13745 ecode3 = SWIG_AsVal_int(obj2, &val3);
13746 if (!SWIG_IsOK(ecode3)) {
13747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13748 }
13749 arg3 = static_cast< int >(val3);
13750 {
13751 PyThreadState* __tstate = wxPyBeginAllowThreads();
13752 result = (byte)(arg1)->GetGreen(arg2,arg3);
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13757 return resultobj;
13758 fail:
13759 return NULL;
13760 }
13761
13762
13763 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj = 0;
13765 wxImage *arg1 = (wxImage *) 0 ;
13766 int arg2 ;
13767 int arg3 ;
13768 byte result;
13769 void *argp1 = 0 ;
13770 int res1 = 0 ;
13771 int val2 ;
13772 int ecode2 = 0 ;
13773 int val3 ;
13774 int ecode3 = 0 ;
13775 PyObject * obj0 = 0 ;
13776 PyObject * obj1 = 0 ;
13777 PyObject * obj2 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "self",(char *) "x",(char *) "y", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13784 if (!SWIG_IsOK(res1)) {
13785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13786 }
13787 arg1 = reinterpret_cast< wxImage * >(argp1);
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 ecode3 = SWIG_AsVal_int(obj2, &val3);
13794 if (!SWIG_IsOK(ecode3)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13796 }
13797 arg3 = static_cast< int >(val3);
13798 {
13799 PyThreadState* __tstate = wxPyBeginAllowThreads();
13800 result = (byte)(arg1)->GetBlue(arg2,arg3);
13801 wxPyEndAllowThreads(__tstate);
13802 if (PyErr_Occurred()) SWIG_fail;
13803 }
13804 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13805 return resultobj;
13806 fail:
13807 return NULL;
13808 }
13809
13810
13811 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13812 PyObject *resultobj = 0;
13813 wxImage *arg1 = (wxImage *) 0 ;
13814 int arg2 ;
13815 int arg3 ;
13816 byte arg4 ;
13817 void *argp1 = 0 ;
13818 int res1 = 0 ;
13819 int val2 ;
13820 int ecode2 = 0 ;
13821 int val3 ;
13822 int ecode3 = 0 ;
13823 unsigned char val4 ;
13824 int ecode4 = 0 ;
13825 PyObject * obj0 = 0 ;
13826 PyObject * obj1 = 0 ;
13827 PyObject * obj2 = 0 ;
13828 PyObject * obj3 = 0 ;
13829 char * kwnames[] = {
13830 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13831 };
13832
13833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13835 if (!SWIG_IsOK(res1)) {
13836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13837 }
13838 arg1 = reinterpret_cast< wxImage * >(argp1);
13839 ecode2 = SWIG_AsVal_int(obj1, &val2);
13840 if (!SWIG_IsOK(ecode2)) {
13841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13842 }
13843 arg2 = static_cast< int >(val2);
13844 ecode3 = SWIG_AsVal_int(obj2, &val3);
13845 if (!SWIG_IsOK(ecode3)) {
13846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13847 }
13848 arg3 = static_cast< int >(val3);
13849 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13850 if (!SWIG_IsOK(ecode4)) {
13851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13852 }
13853 arg4 = static_cast< byte >(val4);
13854 {
13855 PyThreadState* __tstate = wxPyBeginAllowThreads();
13856 (arg1)->SetAlpha(arg2,arg3,arg4);
13857 wxPyEndAllowThreads(__tstate);
13858 if (PyErr_Occurred()) SWIG_fail;
13859 }
13860 resultobj = SWIG_Py_Void();
13861 return resultobj;
13862 fail:
13863 return NULL;
13864 }
13865
13866
13867 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13868 PyObject *resultobj = 0;
13869 wxImage *arg1 = (wxImage *) 0 ;
13870 int arg2 ;
13871 int arg3 ;
13872 byte result;
13873 void *argp1 = 0 ;
13874 int res1 = 0 ;
13875 int val2 ;
13876 int ecode2 = 0 ;
13877 int val3 ;
13878 int ecode3 = 0 ;
13879 PyObject * obj0 = 0 ;
13880 PyObject * obj1 = 0 ;
13881 PyObject * obj2 = 0 ;
13882 char * kwnames[] = {
13883 (char *) "self",(char *) "x",(char *) "y", NULL
13884 };
13885
13886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13888 if (!SWIG_IsOK(res1)) {
13889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13890 }
13891 arg1 = reinterpret_cast< wxImage * >(argp1);
13892 ecode2 = SWIG_AsVal_int(obj1, &val2);
13893 if (!SWIG_IsOK(ecode2)) {
13894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
13895 }
13896 arg2 = static_cast< int >(val2);
13897 ecode3 = SWIG_AsVal_int(obj2, &val3);
13898 if (!SWIG_IsOK(ecode3)) {
13899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
13900 }
13901 arg3 = static_cast< int >(val3);
13902 {
13903 PyThreadState* __tstate = wxPyBeginAllowThreads();
13904 result = (byte)(arg1)->GetAlpha(arg2,arg3);
13905 wxPyEndAllowThreads(__tstate);
13906 if (PyErr_Occurred()) SWIG_fail;
13907 }
13908 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13909 return resultobj;
13910 fail:
13911 return NULL;
13912 }
13913
13914
13915 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13916 PyObject *resultobj = 0;
13917 wxImage *arg1 = (wxImage *) 0 ;
13918 bool result;
13919 void *argp1 = 0 ;
13920 int res1 = 0 ;
13921 PyObject *swig_obj[1] ;
13922
13923 if (!args) SWIG_fail;
13924 swig_obj[0] = args;
13925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13926 if (!SWIG_IsOK(res1)) {
13927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13928 }
13929 arg1 = reinterpret_cast< wxImage * >(argp1);
13930 {
13931 PyThreadState* __tstate = wxPyBeginAllowThreads();
13932 result = (bool)(arg1)->HasAlpha();
13933 wxPyEndAllowThreads(__tstate);
13934 if (PyErr_Occurred()) SWIG_fail;
13935 }
13936 {
13937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13938 }
13939 return resultobj;
13940 fail:
13941 return NULL;
13942 }
13943
13944
13945 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13946 PyObject *resultobj = 0;
13947 wxImage *arg1 = (wxImage *) 0 ;
13948 void *argp1 = 0 ;
13949 int res1 = 0 ;
13950 PyObject *swig_obj[1] ;
13951
13952 if (!args) SWIG_fail;
13953 swig_obj[0] = args;
13954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13955 if (!SWIG_IsOK(res1)) {
13956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13957 }
13958 arg1 = reinterpret_cast< wxImage * >(argp1);
13959 {
13960 PyThreadState* __tstate = wxPyBeginAllowThreads();
13961 (arg1)->InitAlpha();
13962 wxPyEndAllowThreads(__tstate);
13963 if (PyErr_Occurred()) SWIG_fail;
13964 }
13965 resultobj = SWIG_Py_Void();
13966 return resultobj;
13967 fail:
13968 return NULL;
13969 }
13970
13971
13972 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13973 PyObject *resultobj = 0;
13974 wxImage *arg1 = (wxImage *) 0 ;
13975 int arg2 ;
13976 int arg3 ;
13977 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
13978 bool result;
13979 void *argp1 = 0 ;
13980 int res1 = 0 ;
13981 int val2 ;
13982 int ecode2 = 0 ;
13983 int val3 ;
13984 int ecode3 = 0 ;
13985 unsigned char val4 ;
13986 int ecode4 = 0 ;
13987 PyObject * obj0 = 0 ;
13988 PyObject * obj1 = 0 ;
13989 PyObject * obj2 = 0 ;
13990 PyObject * obj3 = 0 ;
13991 char * kwnames[] = {
13992 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
13993 };
13994
13995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13997 if (!SWIG_IsOK(res1)) {
13998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
13999 }
14000 arg1 = reinterpret_cast< wxImage * >(argp1);
14001 ecode2 = SWIG_AsVal_int(obj1, &val2);
14002 if (!SWIG_IsOK(ecode2)) {
14003 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14004 }
14005 arg2 = static_cast< int >(val2);
14006 ecode3 = SWIG_AsVal_int(obj2, &val3);
14007 if (!SWIG_IsOK(ecode3)) {
14008 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14009 }
14010 arg3 = static_cast< int >(val3);
14011 if (obj3) {
14012 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14013 if (!SWIG_IsOK(ecode4)) {
14014 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14015 }
14016 arg4 = static_cast< byte >(val4);
14017 }
14018 {
14019 PyThreadState* __tstate = wxPyBeginAllowThreads();
14020 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 {
14025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14026 }
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj = 0;
14035 wxImage *arg1 = (wxImage *) 0 ;
14036 byte *arg2 = (byte *) 0 ;
14037 byte *arg3 = (byte *) 0 ;
14038 byte *arg4 = (byte *) 0 ;
14039 byte arg5 = (byte) 0 ;
14040 byte arg6 = (byte) 0 ;
14041 byte arg7 = (byte) 0 ;
14042 bool result;
14043 void *argp1 = 0 ;
14044 int res1 = 0 ;
14045 byte temp2 ;
14046 int res2 = SWIG_TMPOBJ ;
14047 byte temp3 ;
14048 int res3 = SWIG_TMPOBJ ;
14049 byte temp4 ;
14050 int res4 = SWIG_TMPOBJ ;
14051 unsigned char val5 ;
14052 int ecode5 = 0 ;
14053 unsigned char val6 ;
14054 int ecode6 = 0 ;
14055 unsigned char val7 ;
14056 int ecode7 = 0 ;
14057 PyObject * obj0 = 0 ;
14058 PyObject * obj1 = 0 ;
14059 PyObject * obj2 = 0 ;
14060 PyObject * obj3 = 0 ;
14061 char * kwnames[] = {
14062 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14063 };
14064
14065 arg2 = &temp2;
14066 arg3 = &temp3;
14067 arg4 = &temp4;
14068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14070 if (!SWIG_IsOK(res1)) {
14071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14072 }
14073 arg1 = reinterpret_cast< wxImage * >(argp1);
14074 if (obj1) {
14075 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14076 if (!SWIG_IsOK(ecode5)) {
14077 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14078 }
14079 arg5 = static_cast< byte >(val5);
14080 }
14081 if (obj2) {
14082 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14083 if (!SWIG_IsOK(ecode6)) {
14084 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14085 }
14086 arg6 = static_cast< byte >(val6);
14087 }
14088 if (obj3) {
14089 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14090 if (!SWIG_IsOK(ecode7)) {
14091 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14092 }
14093 arg7 = static_cast< byte >(val7);
14094 }
14095 {
14096 PyThreadState* __tstate = wxPyBeginAllowThreads();
14097 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14098 wxPyEndAllowThreads(__tstate);
14099 if (PyErr_Occurred()) SWIG_fail;
14100 }
14101 {
14102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14103 }
14104 if (SWIG_IsTmpObj(res2)) {
14105 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14106 } else {
14107 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14108 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14109 }
14110 if (SWIG_IsTmpObj(res3)) {
14111 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14112 } else {
14113 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14114 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14115 }
14116 if (SWIG_IsTmpObj(res4)) {
14117 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14118 } else {
14119 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14120 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14121 }
14122 return resultobj;
14123 fail:
14124 return NULL;
14125 }
14126
14127
14128 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14129 PyObject *resultobj = 0;
14130 wxImage *arg1 = (wxImage *) 0 ;
14131 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14132 bool result;
14133 void *argp1 = 0 ;
14134 int res1 = 0 ;
14135 unsigned char val2 ;
14136 int ecode2 = 0 ;
14137 PyObject * obj0 = 0 ;
14138 PyObject * obj1 = 0 ;
14139 char * kwnames[] = {
14140 (char *) "self",(char *) "threshold", NULL
14141 };
14142
14143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14145 if (!SWIG_IsOK(res1)) {
14146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14147 }
14148 arg1 = reinterpret_cast< wxImage * >(argp1);
14149 if (obj1) {
14150 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14151 if (!SWIG_IsOK(ecode2)) {
14152 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14153 }
14154 arg2 = static_cast< byte >(val2);
14155 }
14156 {
14157 PyThreadState* __tstate = wxPyBeginAllowThreads();
14158 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14159 wxPyEndAllowThreads(__tstate);
14160 if (PyErr_Occurred()) SWIG_fail;
14161 }
14162 {
14163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14164 }
14165 return resultobj;
14166 fail:
14167 return NULL;
14168 }
14169
14170
14171 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14172 PyObject *resultobj = 0;
14173 wxImage *arg1 = (wxImage *) 0 ;
14174 byte arg2 ;
14175 byte arg3 ;
14176 byte arg4 ;
14177 bool result;
14178 void *argp1 = 0 ;
14179 int res1 = 0 ;
14180 unsigned char val2 ;
14181 int ecode2 = 0 ;
14182 unsigned char val3 ;
14183 int ecode3 = 0 ;
14184 unsigned char val4 ;
14185 int ecode4 = 0 ;
14186 PyObject * obj0 = 0 ;
14187 PyObject * obj1 = 0 ;
14188 PyObject * obj2 = 0 ;
14189 PyObject * obj3 = 0 ;
14190 char * kwnames[] = {
14191 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14192 };
14193
14194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14196 if (!SWIG_IsOK(res1)) {
14197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14198 }
14199 arg1 = reinterpret_cast< wxImage * >(argp1);
14200 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14201 if (!SWIG_IsOK(ecode2)) {
14202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14203 }
14204 arg2 = static_cast< byte >(val2);
14205 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14206 if (!SWIG_IsOK(ecode3)) {
14207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14208 }
14209 arg3 = static_cast< byte >(val3);
14210 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14211 if (!SWIG_IsOK(ecode4)) {
14212 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14213 }
14214 arg4 = static_cast< byte >(val4);
14215 {
14216 PyThreadState* __tstate = wxPyBeginAllowThreads();
14217 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14218 wxPyEndAllowThreads(__tstate);
14219 if (PyErr_Occurred()) SWIG_fail;
14220 }
14221 {
14222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14223 }
14224 return resultobj;
14225 fail:
14226 return NULL;
14227 }
14228
14229
14230 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14231 PyObject *resultobj = 0;
14232 wxImage *arg1 = (wxImage *) 0 ;
14233 wxImage *arg2 = 0 ;
14234 byte arg3 ;
14235 byte arg4 ;
14236 byte arg5 ;
14237 bool result;
14238 void *argp1 = 0 ;
14239 int res1 = 0 ;
14240 void *argp2 = 0 ;
14241 int res2 = 0 ;
14242 unsigned char val3 ;
14243 int ecode3 = 0 ;
14244 unsigned char val4 ;
14245 int ecode4 = 0 ;
14246 unsigned char val5 ;
14247 int ecode5 = 0 ;
14248 PyObject * obj0 = 0 ;
14249 PyObject * obj1 = 0 ;
14250 PyObject * obj2 = 0 ;
14251 PyObject * obj3 = 0 ;
14252 PyObject * obj4 = 0 ;
14253 char * kwnames[] = {
14254 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14255 };
14256
14257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14259 if (!SWIG_IsOK(res1)) {
14260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14261 }
14262 arg1 = reinterpret_cast< wxImage * >(argp1);
14263 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14264 if (!SWIG_IsOK(res2)) {
14265 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14266 }
14267 if (!argp2) {
14268 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14269 }
14270 arg2 = reinterpret_cast< wxImage * >(argp2);
14271 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14272 if (!SWIG_IsOK(ecode3)) {
14273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14274 }
14275 arg3 = static_cast< byte >(val3);
14276 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14277 if (!SWIG_IsOK(ecode4)) {
14278 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14279 }
14280 arg4 = static_cast< byte >(val4);
14281 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14282 if (!SWIG_IsOK(ecode5)) {
14283 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14284 }
14285 arg5 = static_cast< byte >(val5);
14286 {
14287 PyThreadState* __tstate = wxPyBeginAllowThreads();
14288 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14289 wxPyEndAllowThreads(__tstate);
14290 if (PyErr_Occurred()) SWIG_fail;
14291 }
14292 {
14293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14294 }
14295 return resultobj;
14296 fail:
14297 return NULL;
14298 }
14299
14300
14301 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14302 PyObject *resultobj = 0;
14303 wxString *arg1 = 0 ;
14304 bool result;
14305 bool temp1 = false ;
14306 PyObject * obj0 = 0 ;
14307 char * kwnames[] = {
14308 (char *) "filename", NULL
14309 };
14310
14311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14312 {
14313 arg1 = wxString_in_helper(obj0);
14314 if (arg1 == NULL) SWIG_fail;
14315 temp1 = true;
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14325 }
14326 {
14327 if (temp1)
14328 delete arg1;
14329 }
14330 return resultobj;
14331 fail:
14332 {
14333 if (temp1)
14334 delete arg1;
14335 }
14336 return NULL;
14337 }
14338
14339
14340 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = 0;
14342 wxString *arg1 = 0 ;
14343 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14344 int result;
14345 bool temp1 = false ;
14346 long val2 ;
14347 int ecode2 = 0 ;
14348 PyObject * obj0 = 0 ;
14349 PyObject * obj1 = 0 ;
14350 char * kwnames[] = {
14351 (char *) "filename",(char *) "type", NULL
14352 };
14353
14354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14355 {
14356 arg1 = wxString_in_helper(obj0);
14357 if (arg1 == NULL) SWIG_fail;
14358 temp1 = true;
14359 }
14360 if (obj1) {
14361 ecode2 = SWIG_AsVal_long(obj1, &val2);
14362 if (!SWIG_IsOK(ecode2)) {
14363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14364 }
14365 arg2 = static_cast< long >(val2);
14366 }
14367 {
14368 PyThreadState* __tstate = wxPyBeginAllowThreads();
14369 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14370 wxPyEndAllowThreads(__tstate);
14371 if (PyErr_Occurred()) SWIG_fail;
14372 }
14373 resultobj = SWIG_From_int(static_cast< int >(result));
14374 {
14375 if (temp1)
14376 delete arg1;
14377 }
14378 return resultobj;
14379 fail:
14380 {
14381 if (temp1)
14382 delete arg1;
14383 }
14384 return NULL;
14385 }
14386
14387
14388 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14389 PyObject *resultobj = 0;
14390 wxImage *arg1 = (wxImage *) 0 ;
14391 wxString *arg2 = 0 ;
14392 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14393 int arg4 = (int) -1 ;
14394 bool result;
14395 void *argp1 = 0 ;
14396 int res1 = 0 ;
14397 bool temp2 = false ;
14398 long val3 ;
14399 int ecode3 = 0 ;
14400 int val4 ;
14401 int ecode4 = 0 ;
14402 PyObject * obj0 = 0 ;
14403 PyObject * obj1 = 0 ;
14404 PyObject * obj2 = 0 ;
14405 PyObject * obj3 = 0 ;
14406 char * kwnames[] = {
14407 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14408 };
14409
14410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14412 if (!SWIG_IsOK(res1)) {
14413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14414 }
14415 arg1 = reinterpret_cast< wxImage * >(argp1);
14416 {
14417 arg2 = wxString_in_helper(obj1);
14418 if (arg2 == NULL) SWIG_fail;
14419 temp2 = true;
14420 }
14421 if (obj2) {
14422 ecode3 = SWIG_AsVal_long(obj2, &val3);
14423 if (!SWIG_IsOK(ecode3)) {
14424 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14425 }
14426 arg3 = static_cast< long >(val3);
14427 }
14428 if (obj3) {
14429 ecode4 = SWIG_AsVal_int(obj3, &val4);
14430 if (!SWIG_IsOK(ecode4)) {
14431 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14432 }
14433 arg4 = static_cast< int >(val4);
14434 }
14435 {
14436 PyThreadState* __tstate = wxPyBeginAllowThreads();
14437 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14438 wxPyEndAllowThreads(__tstate);
14439 if (PyErr_Occurred()) SWIG_fail;
14440 }
14441 {
14442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14443 }
14444 {
14445 if (temp2)
14446 delete arg2;
14447 }
14448 return resultobj;
14449 fail:
14450 {
14451 if (temp2)
14452 delete arg2;
14453 }
14454 return NULL;
14455 }
14456
14457
14458 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14459 PyObject *resultobj = 0;
14460 wxImage *arg1 = (wxImage *) 0 ;
14461 wxString *arg2 = 0 ;
14462 wxString *arg3 = 0 ;
14463 int arg4 = (int) -1 ;
14464 bool result;
14465 void *argp1 = 0 ;
14466 int res1 = 0 ;
14467 bool temp2 = false ;
14468 bool temp3 = false ;
14469 int val4 ;
14470 int ecode4 = 0 ;
14471 PyObject * obj0 = 0 ;
14472 PyObject * obj1 = 0 ;
14473 PyObject * obj2 = 0 ;
14474 PyObject * obj3 = 0 ;
14475 char * kwnames[] = {
14476 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14477 };
14478
14479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14483 }
14484 arg1 = reinterpret_cast< wxImage * >(argp1);
14485 {
14486 arg2 = wxString_in_helper(obj1);
14487 if (arg2 == NULL) SWIG_fail;
14488 temp2 = true;
14489 }
14490 {
14491 arg3 = wxString_in_helper(obj2);
14492 if (arg3 == NULL) SWIG_fail;
14493 temp3 = true;
14494 }
14495 if (obj3) {
14496 ecode4 = SWIG_AsVal_int(obj3, &val4);
14497 if (!SWIG_IsOK(ecode4)) {
14498 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14499 }
14500 arg4 = static_cast< int >(val4);
14501 }
14502 {
14503 PyThreadState* __tstate = wxPyBeginAllowThreads();
14504 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14505 wxPyEndAllowThreads(__tstate);
14506 if (PyErr_Occurred()) SWIG_fail;
14507 }
14508 {
14509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14510 }
14511 {
14512 if (temp2)
14513 delete arg2;
14514 }
14515 {
14516 if (temp3)
14517 delete arg3;
14518 }
14519 return resultobj;
14520 fail:
14521 {
14522 if (temp2)
14523 delete arg2;
14524 }
14525 {
14526 if (temp3)
14527 delete arg3;
14528 }
14529 return NULL;
14530 }
14531
14532
14533 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14534 PyObject *resultobj = 0;
14535 wxImage *arg1 = (wxImage *) 0 ;
14536 wxString *arg2 = 0 ;
14537 int arg3 ;
14538 bool result;
14539 void *argp1 = 0 ;
14540 int res1 = 0 ;
14541 bool temp2 = false ;
14542 int val3 ;
14543 int ecode3 = 0 ;
14544 PyObject * obj0 = 0 ;
14545 PyObject * obj1 = 0 ;
14546 PyObject * obj2 = 0 ;
14547 char * kwnames[] = {
14548 (char *) "self",(char *) "name",(char *) "type", NULL
14549 };
14550
14551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14553 if (!SWIG_IsOK(res1)) {
14554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14555 }
14556 arg1 = reinterpret_cast< wxImage * >(argp1);
14557 {
14558 arg2 = wxString_in_helper(obj1);
14559 if (arg2 == NULL) SWIG_fail;
14560 temp2 = true;
14561 }
14562 ecode3 = SWIG_AsVal_int(obj2, &val3);
14563 if (!SWIG_IsOK(ecode3)) {
14564 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14565 }
14566 arg3 = static_cast< int >(val3);
14567 {
14568 PyThreadState* __tstate = wxPyBeginAllowThreads();
14569 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14570 wxPyEndAllowThreads(__tstate);
14571 if (PyErr_Occurred()) SWIG_fail;
14572 }
14573 {
14574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14575 }
14576 {
14577 if (temp2)
14578 delete arg2;
14579 }
14580 return resultobj;
14581 fail:
14582 {
14583 if (temp2)
14584 delete arg2;
14585 }
14586 return NULL;
14587 }
14588
14589
14590 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14591 PyObject *resultobj = 0;
14592 wxImage *arg1 = (wxImage *) 0 ;
14593 wxString *arg2 = 0 ;
14594 wxString *arg3 = 0 ;
14595 bool result;
14596 void *argp1 = 0 ;
14597 int res1 = 0 ;
14598 bool temp2 = false ;
14599 bool temp3 = false ;
14600 PyObject * obj0 = 0 ;
14601 PyObject * obj1 = 0 ;
14602 PyObject * obj2 = 0 ;
14603 char * kwnames[] = {
14604 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14605 };
14606
14607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14608 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14609 if (!SWIG_IsOK(res1)) {
14610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14611 }
14612 arg1 = reinterpret_cast< wxImage * >(argp1);
14613 {
14614 arg2 = wxString_in_helper(obj1);
14615 if (arg2 == NULL) SWIG_fail;
14616 temp2 = true;
14617 }
14618 {
14619 arg3 = wxString_in_helper(obj2);
14620 if (arg3 == NULL) SWIG_fail;
14621 temp3 = true;
14622 }
14623 {
14624 PyThreadState* __tstate = wxPyBeginAllowThreads();
14625 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14626 wxPyEndAllowThreads(__tstate);
14627 if (PyErr_Occurred()) SWIG_fail;
14628 }
14629 {
14630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14631 }
14632 {
14633 if (temp2)
14634 delete arg2;
14635 }
14636 {
14637 if (temp3)
14638 delete arg3;
14639 }
14640 return resultobj;
14641 fail:
14642 {
14643 if (temp2)
14644 delete arg2;
14645 }
14646 {
14647 if (temp3)
14648 delete arg3;
14649 }
14650 return NULL;
14651 }
14652
14653
14654 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14655 PyObject *resultobj = 0;
14656 wxInputStream *arg1 = 0 ;
14657 bool result;
14658 wxPyInputStream *temp1 ;
14659 bool created1 ;
14660 PyObject * obj0 = 0 ;
14661 char * kwnames[] = {
14662 (char *) "stream", NULL
14663 };
14664
14665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14666 {
14667 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14668 arg1 = temp1->m_wxis;
14669 created1 = false;
14670 } else {
14671 PyErr_Clear(); // clear the failure of the wxPyConvert above
14672 arg1 = wxPyCBInputStream_create(obj0, false);
14673 if (arg1 == NULL) {
14674 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14675 SWIG_fail;
14676 }
14677 created1 = true;
14678 }
14679 }
14680 {
14681 PyThreadState* __tstate = wxPyBeginAllowThreads();
14682 result = (bool)wxImage::CanRead(*arg1);
14683 wxPyEndAllowThreads(__tstate);
14684 if (PyErr_Occurred()) SWIG_fail;
14685 }
14686 {
14687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14688 }
14689 {
14690 if (created1) delete arg1;
14691 }
14692 return resultobj;
14693 fail:
14694 {
14695 if (created1) delete arg1;
14696 }
14697 return NULL;
14698 }
14699
14700
14701 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14702 PyObject *resultobj = 0;
14703 wxImage *arg1 = (wxImage *) 0 ;
14704 wxInputStream *arg2 = 0 ;
14705 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14706 int arg4 = (int) -1 ;
14707 bool result;
14708 void *argp1 = 0 ;
14709 int res1 = 0 ;
14710 wxPyInputStream *temp2 ;
14711 bool created2 ;
14712 long val3 ;
14713 int ecode3 = 0 ;
14714 int val4 ;
14715 int ecode4 = 0 ;
14716 PyObject * obj0 = 0 ;
14717 PyObject * obj1 = 0 ;
14718 PyObject * obj2 = 0 ;
14719 PyObject * obj3 = 0 ;
14720 char * kwnames[] = {
14721 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14722 };
14723
14724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14726 if (!SWIG_IsOK(res1)) {
14727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14728 }
14729 arg1 = reinterpret_cast< wxImage * >(argp1);
14730 {
14731 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14732 arg2 = temp2->m_wxis;
14733 created2 = false;
14734 } else {
14735 PyErr_Clear(); // clear the failure of the wxPyConvert above
14736 arg2 = wxPyCBInputStream_create(obj1, false);
14737 if (arg2 == NULL) {
14738 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14739 SWIG_fail;
14740 }
14741 created2 = true;
14742 }
14743 }
14744 if (obj2) {
14745 ecode3 = SWIG_AsVal_long(obj2, &val3);
14746 if (!SWIG_IsOK(ecode3)) {
14747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14748 }
14749 arg3 = static_cast< long >(val3);
14750 }
14751 if (obj3) {
14752 ecode4 = SWIG_AsVal_int(obj3, &val4);
14753 if (!SWIG_IsOK(ecode4)) {
14754 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14755 }
14756 arg4 = static_cast< int >(val4);
14757 }
14758 {
14759 PyThreadState* __tstate = wxPyBeginAllowThreads();
14760 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14761 wxPyEndAllowThreads(__tstate);
14762 if (PyErr_Occurred()) SWIG_fail;
14763 }
14764 {
14765 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14766 }
14767 {
14768 if (created2) delete arg2;
14769 }
14770 return resultobj;
14771 fail:
14772 {
14773 if (created2) delete arg2;
14774 }
14775 return NULL;
14776 }
14777
14778
14779 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14780 PyObject *resultobj = 0;
14781 wxImage *arg1 = (wxImage *) 0 ;
14782 wxInputStream *arg2 = 0 ;
14783 wxString *arg3 = 0 ;
14784 int arg4 = (int) -1 ;
14785 bool result;
14786 void *argp1 = 0 ;
14787 int res1 = 0 ;
14788 wxPyInputStream *temp2 ;
14789 bool created2 ;
14790 bool temp3 = false ;
14791 int val4 ;
14792 int ecode4 = 0 ;
14793 PyObject * obj0 = 0 ;
14794 PyObject * obj1 = 0 ;
14795 PyObject * obj2 = 0 ;
14796 PyObject * obj3 = 0 ;
14797 char * kwnames[] = {
14798 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14799 };
14800
14801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14802 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14803 if (!SWIG_IsOK(res1)) {
14804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14805 }
14806 arg1 = reinterpret_cast< wxImage * >(argp1);
14807 {
14808 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14809 arg2 = temp2->m_wxis;
14810 created2 = false;
14811 } else {
14812 PyErr_Clear(); // clear the failure of the wxPyConvert above
14813 arg2 = wxPyCBInputStream_create(obj1, false);
14814 if (arg2 == NULL) {
14815 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14816 SWIG_fail;
14817 }
14818 created2 = true;
14819 }
14820 }
14821 {
14822 arg3 = wxString_in_helper(obj2);
14823 if (arg3 == NULL) SWIG_fail;
14824 temp3 = true;
14825 }
14826 if (obj3) {
14827 ecode4 = SWIG_AsVal_int(obj3, &val4);
14828 if (!SWIG_IsOK(ecode4)) {
14829 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14830 }
14831 arg4 = static_cast< int >(val4);
14832 }
14833 {
14834 PyThreadState* __tstate = wxPyBeginAllowThreads();
14835 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 {
14840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14841 }
14842 {
14843 if (created2) delete arg2;
14844 }
14845 {
14846 if (temp3)
14847 delete arg3;
14848 }
14849 return resultobj;
14850 fail:
14851 {
14852 if (created2) delete arg2;
14853 }
14854 {
14855 if (temp3)
14856 delete arg3;
14857 }
14858 return NULL;
14859 }
14860
14861
14862 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14863 PyObject *resultobj = 0;
14864 wxImage *arg1 = (wxImage *) 0 ;
14865 bool result;
14866 void *argp1 = 0 ;
14867 int res1 = 0 ;
14868 PyObject *swig_obj[1] ;
14869
14870 if (!args) SWIG_fail;
14871 swig_obj[0] = args;
14872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14873 if (!SWIG_IsOK(res1)) {
14874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14875 }
14876 arg1 = reinterpret_cast< wxImage * >(argp1);
14877 {
14878 PyThreadState* __tstate = wxPyBeginAllowThreads();
14879 result = (bool)(arg1)->Ok();
14880 wxPyEndAllowThreads(__tstate);
14881 if (PyErr_Occurred()) SWIG_fail;
14882 }
14883 {
14884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14885 }
14886 return resultobj;
14887 fail:
14888 return NULL;
14889 }
14890
14891
14892 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14893 PyObject *resultobj = 0;
14894 wxImage *arg1 = (wxImage *) 0 ;
14895 int result;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 PyObject *swig_obj[1] ;
14899
14900 if (!args) SWIG_fail;
14901 swig_obj[0] = args;
14902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14903 if (!SWIG_IsOK(res1)) {
14904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
14905 }
14906 arg1 = reinterpret_cast< wxImage * >(argp1);
14907 {
14908 PyThreadState* __tstate = wxPyBeginAllowThreads();
14909 result = (int)(arg1)->GetWidth();
14910 wxPyEndAllowThreads(__tstate);
14911 if (PyErr_Occurred()) SWIG_fail;
14912 }
14913 resultobj = SWIG_From_int(static_cast< int >(result));
14914 return resultobj;
14915 fail:
14916 return NULL;
14917 }
14918
14919
14920 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14921 PyObject *resultobj = 0;
14922 wxImage *arg1 = (wxImage *) 0 ;
14923 int result;
14924 void *argp1 = 0 ;
14925 int res1 = 0 ;
14926 PyObject *swig_obj[1] ;
14927
14928 if (!args) SWIG_fail;
14929 swig_obj[0] = args;
14930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14931 if (!SWIG_IsOK(res1)) {
14932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
14933 }
14934 arg1 = reinterpret_cast< wxImage * >(argp1);
14935 {
14936 PyThreadState* __tstate = wxPyBeginAllowThreads();
14937 result = (int)(arg1)->GetHeight();
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 resultobj = SWIG_From_int(static_cast< int >(result));
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14949 PyObject *resultobj = 0;
14950 wxImage *arg1 = (wxImage *) 0 ;
14951 wxSize result;
14952 void *argp1 = 0 ;
14953 int res1 = 0 ;
14954 PyObject *swig_obj[1] ;
14955
14956 if (!args) SWIG_fail;
14957 swig_obj[0] = args;
14958 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14959 if (!SWIG_IsOK(res1)) {
14960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
14961 }
14962 arg1 = reinterpret_cast< wxImage * >(argp1);
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 result = wxImage_GetSize(arg1);
14966 wxPyEndAllowThreads(__tstate);
14967 if (PyErr_Occurred()) SWIG_fail;
14968 }
14969 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
14970 return resultobj;
14971 fail:
14972 return NULL;
14973 }
14974
14975
14976 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14977 PyObject *resultobj = 0;
14978 wxImage *arg1 = (wxImage *) 0 ;
14979 wxRect *arg2 = 0 ;
14980 SwigValueWrapper<wxImage > result;
14981 void *argp1 = 0 ;
14982 int res1 = 0 ;
14983 wxRect temp2 ;
14984 PyObject * obj0 = 0 ;
14985 PyObject * obj1 = 0 ;
14986 char * kwnames[] = {
14987 (char *) "self",(char *) "rect", NULL
14988 };
14989
14990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
14991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14992 if (!SWIG_IsOK(res1)) {
14993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
14994 }
14995 arg1 = reinterpret_cast< wxImage * >(argp1);
14996 {
14997 arg2 = &temp2;
14998 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
14999 }
15000 {
15001 PyThreadState* __tstate = wxPyBeginAllowThreads();
15002 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15003 wxPyEndAllowThreads(__tstate);
15004 if (PyErr_Occurred()) SWIG_fail;
15005 }
15006 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15007 return resultobj;
15008 fail:
15009 return NULL;
15010 }
15011
15012
15013 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15014 PyObject *resultobj = 0;
15015 wxImage *arg1 = (wxImage *) 0 ;
15016 wxSize *arg2 = 0 ;
15017 wxPoint *arg3 = 0 ;
15018 int arg4 = (int) -1 ;
15019 int arg5 = (int) -1 ;
15020 int arg6 = (int) -1 ;
15021 SwigValueWrapper<wxImage > result;
15022 void *argp1 = 0 ;
15023 int res1 = 0 ;
15024 wxSize temp2 ;
15025 wxPoint temp3 ;
15026 int val4 ;
15027 int ecode4 = 0 ;
15028 int val5 ;
15029 int ecode5 = 0 ;
15030 int val6 ;
15031 int ecode6 = 0 ;
15032 PyObject * obj0 = 0 ;
15033 PyObject * obj1 = 0 ;
15034 PyObject * obj2 = 0 ;
15035 PyObject * obj3 = 0 ;
15036 PyObject * obj4 = 0 ;
15037 PyObject * obj5 = 0 ;
15038 char * kwnames[] = {
15039 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15040 };
15041
15042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15044 if (!SWIG_IsOK(res1)) {
15045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15046 }
15047 arg1 = reinterpret_cast< wxImage * >(argp1);
15048 {
15049 arg2 = &temp2;
15050 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15051 }
15052 {
15053 arg3 = &temp3;
15054 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15055 }
15056 if (obj3) {
15057 ecode4 = SWIG_AsVal_int(obj3, &val4);
15058 if (!SWIG_IsOK(ecode4)) {
15059 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15060 }
15061 arg4 = static_cast< int >(val4);
15062 }
15063 if (obj4) {
15064 ecode5 = SWIG_AsVal_int(obj4, &val5);
15065 if (!SWIG_IsOK(ecode5)) {
15066 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15067 }
15068 arg5 = static_cast< int >(val5);
15069 }
15070 if (obj5) {
15071 ecode6 = SWIG_AsVal_int(obj5, &val6);
15072 if (!SWIG_IsOK(ecode6)) {
15073 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15074 }
15075 arg6 = static_cast< int >(val6);
15076 }
15077 {
15078 PyThreadState* __tstate = wxPyBeginAllowThreads();
15079 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15080 wxPyEndAllowThreads(__tstate);
15081 if (PyErr_Occurred()) SWIG_fail;
15082 }
15083 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15091 PyObject *resultobj = 0;
15092 wxImage *arg1 = (wxImage *) 0 ;
15093 SwigValueWrapper<wxImage > result;
15094 void *argp1 = 0 ;
15095 int res1 = 0 ;
15096 PyObject *swig_obj[1] ;
15097
15098 if (!args) SWIG_fail;
15099 swig_obj[0] = args;
15100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15101 if (!SWIG_IsOK(res1)) {
15102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15103 }
15104 arg1 = reinterpret_cast< wxImage * >(argp1);
15105 {
15106 PyThreadState* __tstate = wxPyBeginAllowThreads();
15107 result = (arg1)->Copy();
15108 wxPyEndAllowThreads(__tstate);
15109 if (PyErr_Occurred()) SWIG_fail;
15110 }
15111 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj = 0;
15120 wxImage *arg1 = (wxImage *) 0 ;
15121 wxImage *arg2 = 0 ;
15122 int arg3 ;
15123 int arg4 ;
15124 void *argp1 = 0 ;
15125 int res1 = 0 ;
15126 void *argp2 = 0 ;
15127 int res2 = 0 ;
15128 int val3 ;
15129 int ecode3 = 0 ;
15130 int val4 ;
15131 int ecode4 = 0 ;
15132 PyObject * obj0 = 0 ;
15133 PyObject * obj1 = 0 ;
15134 PyObject * obj2 = 0 ;
15135 PyObject * obj3 = 0 ;
15136 char * kwnames[] = {
15137 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15138 };
15139
15140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15142 if (!SWIG_IsOK(res1)) {
15143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15144 }
15145 arg1 = reinterpret_cast< wxImage * >(argp1);
15146 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15147 if (!SWIG_IsOK(res2)) {
15148 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15149 }
15150 if (!argp2) {
15151 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15152 }
15153 arg2 = reinterpret_cast< wxImage * >(argp2);
15154 ecode3 = SWIG_AsVal_int(obj2, &val3);
15155 if (!SWIG_IsOK(ecode3)) {
15156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15157 }
15158 arg3 = static_cast< int >(val3);
15159 ecode4 = SWIG_AsVal_int(obj3, &val4);
15160 if (!SWIG_IsOK(ecode4)) {
15161 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15162 }
15163 arg4 = static_cast< int >(val4);
15164 {
15165 PyThreadState* __tstate = wxPyBeginAllowThreads();
15166 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15167 wxPyEndAllowThreads(__tstate);
15168 if (PyErr_Occurred()) SWIG_fail;
15169 }
15170 resultobj = SWIG_Py_Void();
15171 return resultobj;
15172 fail:
15173 return NULL;
15174 }
15175
15176
15177 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15178 PyObject *resultobj = 0;
15179 wxImage *arg1 = (wxImage *) 0 ;
15180 PyObject *result = 0 ;
15181 void *argp1 = 0 ;
15182 int res1 = 0 ;
15183 PyObject *swig_obj[1] ;
15184
15185 if (!args) SWIG_fail;
15186 swig_obj[0] = args;
15187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15188 if (!SWIG_IsOK(res1)) {
15189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15190 }
15191 arg1 = reinterpret_cast< wxImage * >(argp1);
15192 {
15193 PyThreadState* __tstate = wxPyBeginAllowThreads();
15194 result = (PyObject *)wxImage_GetData(arg1);
15195 wxPyEndAllowThreads(__tstate);
15196 if (PyErr_Occurred()) SWIG_fail;
15197 }
15198 resultobj = result;
15199 return resultobj;
15200 fail:
15201 return NULL;
15202 }
15203
15204
15205 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15206 PyObject *resultobj = 0;
15207 wxImage *arg1 = (wxImage *) 0 ;
15208 buffer arg2 ;
15209 int arg3 ;
15210 void *argp1 = 0 ;
15211 int res1 = 0 ;
15212 PyObject * obj0 = 0 ;
15213 PyObject * obj1 = 0 ;
15214 char * kwnames[] = {
15215 (char *) "self",(char *) "data", NULL
15216 };
15217
15218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15220 if (!SWIG_IsOK(res1)) {
15221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15222 }
15223 arg1 = reinterpret_cast< wxImage * >(argp1);
15224 {
15225 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15226 }
15227 {
15228 PyThreadState* __tstate = wxPyBeginAllowThreads();
15229 wxImage_SetData(arg1,arg2,arg3);
15230 wxPyEndAllowThreads(__tstate);
15231 if (PyErr_Occurred()) SWIG_fail;
15232 }
15233 resultobj = SWIG_Py_Void();
15234 return resultobj;
15235 fail:
15236 return NULL;
15237 }
15238
15239
15240 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15241 PyObject *resultobj = 0;
15242 wxImage *arg1 = (wxImage *) 0 ;
15243 PyObject *result = 0 ;
15244 void *argp1 = 0 ;
15245 int res1 = 0 ;
15246 PyObject *swig_obj[1] ;
15247
15248 if (!args) SWIG_fail;
15249 swig_obj[0] = args;
15250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15251 if (!SWIG_IsOK(res1)) {
15252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15253 }
15254 arg1 = reinterpret_cast< wxImage * >(argp1);
15255 {
15256 PyThreadState* __tstate = wxPyBeginAllowThreads();
15257 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 resultobj = result;
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj = 0;
15270 wxImage *arg1 = (wxImage *) 0 ;
15271 buffer arg2 ;
15272 int arg3 ;
15273 void *argp1 = 0 ;
15274 int res1 = 0 ;
15275 PyObject * obj0 = 0 ;
15276 PyObject * obj1 = 0 ;
15277 char * kwnames[] = {
15278 (char *) "self",(char *) "data", NULL
15279 };
15280
15281 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15282 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15283 if (!SWIG_IsOK(res1)) {
15284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15285 }
15286 arg1 = reinterpret_cast< wxImage * >(argp1);
15287 {
15288 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15289 }
15290 {
15291 PyThreadState* __tstate = wxPyBeginAllowThreads();
15292 wxImage_SetDataBuffer(arg1,arg2,arg3);
15293 wxPyEndAllowThreads(__tstate);
15294 if (PyErr_Occurred()) SWIG_fail;
15295 }
15296 resultobj = SWIG_Py_Void();
15297 return resultobj;
15298 fail:
15299 return NULL;
15300 }
15301
15302
15303 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15304 PyObject *resultobj = 0;
15305 wxImage *arg1 = (wxImage *) 0 ;
15306 PyObject *result = 0 ;
15307 void *argp1 = 0 ;
15308 int res1 = 0 ;
15309 PyObject *swig_obj[1] ;
15310
15311 if (!args) SWIG_fail;
15312 swig_obj[0] = args;
15313 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15314 if (!SWIG_IsOK(res1)) {
15315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15316 }
15317 arg1 = reinterpret_cast< wxImage * >(argp1);
15318 {
15319 PyThreadState* __tstate = wxPyBeginAllowThreads();
15320 result = (PyObject *)wxImage_GetAlphaData(arg1);
15321 wxPyEndAllowThreads(__tstate);
15322 if (PyErr_Occurred()) SWIG_fail;
15323 }
15324 resultobj = result;
15325 return resultobj;
15326 fail:
15327 return NULL;
15328 }
15329
15330
15331 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15332 PyObject *resultobj = 0;
15333 wxImage *arg1 = (wxImage *) 0 ;
15334 buffer arg2 ;
15335 int arg3 ;
15336 void *argp1 = 0 ;
15337 int res1 = 0 ;
15338 PyObject * obj0 = 0 ;
15339 PyObject * obj1 = 0 ;
15340 char * kwnames[] = {
15341 (char *) "self",(char *) "alpha", NULL
15342 };
15343
15344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15346 if (!SWIG_IsOK(res1)) {
15347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15348 }
15349 arg1 = reinterpret_cast< wxImage * >(argp1);
15350 {
15351 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15352 }
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 wxImage_SetAlphaData(arg1,arg2,arg3);
15356 wxPyEndAllowThreads(__tstate);
15357 if (PyErr_Occurred()) SWIG_fail;
15358 }
15359 resultobj = SWIG_Py_Void();
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367 PyObject *resultobj = 0;
15368 wxImage *arg1 = (wxImage *) 0 ;
15369 PyObject *result = 0 ;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 PyObject *swig_obj[1] ;
15373
15374 if (!args) SWIG_fail;
15375 swig_obj[0] = args;
15376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15377 if (!SWIG_IsOK(res1)) {
15378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15379 }
15380 arg1 = reinterpret_cast< wxImage * >(argp1);
15381 {
15382 PyThreadState* __tstate = wxPyBeginAllowThreads();
15383 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15384 wxPyEndAllowThreads(__tstate);
15385 if (PyErr_Occurred()) SWIG_fail;
15386 }
15387 resultobj = result;
15388 return resultobj;
15389 fail:
15390 return NULL;
15391 }
15392
15393
15394 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15395 PyObject *resultobj = 0;
15396 wxImage *arg1 = (wxImage *) 0 ;
15397 buffer arg2 ;
15398 int arg3 ;
15399 void *argp1 = 0 ;
15400 int res1 = 0 ;
15401 PyObject * obj0 = 0 ;
15402 PyObject * obj1 = 0 ;
15403 char * kwnames[] = {
15404 (char *) "self",(char *) "alpha", NULL
15405 };
15406
15407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15409 if (!SWIG_IsOK(res1)) {
15410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15411 }
15412 arg1 = reinterpret_cast< wxImage * >(argp1);
15413 {
15414 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15415 }
15416 {
15417 PyThreadState* __tstate = wxPyBeginAllowThreads();
15418 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15419 wxPyEndAllowThreads(__tstate);
15420 if (PyErr_Occurred()) SWIG_fail;
15421 }
15422 resultobj = SWIG_Py_Void();
15423 return resultobj;
15424 fail:
15425 return NULL;
15426 }
15427
15428
15429 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15430 PyObject *resultobj = 0;
15431 wxImage *arg1 = (wxImage *) 0 ;
15432 byte arg2 ;
15433 byte arg3 ;
15434 byte arg4 ;
15435 void *argp1 = 0 ;
15436 int res1 = 0 ;
15437 unsigned char val2 ;
15438 int ecode2 = 0 ;
15439 unsigned char val3 ;
15440 int ecode3 = 0 ;
15441 unsigned char val4 ;
15442 int ecode4 = 0 ;
15443 PyObject * obj0 = 0 ;
15444 PyObject * obj1 = 0 ;
15445 PyObject * obj2 = 0 ;
15446 PyObject * obj3 = 0 ;
15447 char * kwnames[] = {
15448 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15449 };
15450
15451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15453 if (!SWIG_IsOK(res1)) {
15454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15455 }
15456 arg1 = reinterpret_cast< wxImage * >(argp1);
15457 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15458 if (!SWIG_IsOK(ecode2)) {
15459 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15460 }
15461 arg2 = static_cast< byte >(val2);
15462 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15463 if (!SWIG_IsOK(ecode3)) {
15464 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15465 }
15466 arg3 = static_cast< byte >(val3);
15467 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15468 if (!SWIG_IsOK(ecode4)) {
15469 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15470 }
15471 arg4 = static_cast< byte >(val4);
15472 {
15473 PyThreadState* __tstate = wxPyBeginAllowThreads();
15474 (arg1)->SetMaskColour(arg2,arg3,arg4);
15475 wxPyEndAllowThreads(__tstate);
15476 if (PyErr_Occurred()) SWIG_fail;
15477 }
15478 resultobj = SWIG_Py_Void();
15479 return resultobj;
15480 fail:
15481 return NULL;
15482 }
15483
15484
15485 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15486 PyObject *resultobj = 0;
15487 wxImage *arg1 = (wxImage *) 0 ;
15488 byte *arg2 = (byte *) 0 ;
15489 byte *arg3 = (byte *) 0 ;
15490 byte *arg4 = (byte *) 0 ;
15491 void *argp1 = 0 ;
15492 int res1 = 0 ;
15493 byte temp2 ;
15494 int res2 = SWIG_TMPOBJ ;
15495 byte temp3 ;
15496 int res3 = SWIG_TMPOBJ ;
15497 byte temp4 ;
15498 int res4 = SWIG_TMPOBJ ;
15499 PyObject *swig_obj[1] ;
15500
15501 arg2 = &temp2;
15502 arg3 = &temp3;
15503 arg4 = &temp4;
15504 if (!args) SWIG_fail;
15505 swig_obj[0] = args;
15506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15507 if (!SWIG_IsOK(res1)) {
15508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15509 }
15510 arg1 = reinterpret_cast< wxImage * >(argp1);
15511 {
15512 PyThreadState* __tstate = wxPyBeginAllowThreads();
15513 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15514 wxPyEndAllowThreads(__tstate);
15515 if (PyErr_Occurred()) SWIG_fail;
15516 }
15517 resultobj = SWIG_Py_Void();
15518 if (SWIG_IsTmpObj(res2)) {
15519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15520 } else {
15521 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15523 }
15524 if (SWIG_IsTmpObj(res3)) {
15525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15526 } else {
15527 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15529 }
15530 if (SWIG_IsTmpObj(res4)) {
15531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15532 } else {
15533 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15535 }
15536 return resultobj;
15537 fail:
15538 return NULL;
15539 }
15540
15541
15542 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15543 PyObject *resultobj = 0;
15544 wxImage *arg1 = (wxImage *) 0 ;
15545 byte result;
15546 void *argp1 = 0 ;
15547 int res1 = 0 ;
15548 PyObject *swig_obj[1] ;
15549
15550 if (!args) SWIG_fail;
15551 swig_obj[0] = args;
15552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15553 if (!SWIG_IsOK(res1)) {
15554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15555 }
15556 arg1 = reinterpret_cast< wxImage * >(argp1);
15557 {
15558 PyThreadState* __tstate = wxPyBeginAllowThreads();
15559 result = (byte)(arg1)->GetMaskRed();
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15571 PyObject *resultobj = 0;
15572 wxImage *arg1 = (wxImage *) 0 ;
15573 byte result;
15574 void *argp1 = 0 ;
15575 int res1 = 0 ;
15576 PyObject *swig_obj[1] ;
15577
15578 if (!args) SWIG_fail;
15579 swig_obj[0] = args;
15580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15581 if (!SWIG_IsOK(res1)) {
15582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15583 }
15584 arg1 = reinterpret_cast< wxImage * >(argp1);
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (byte)(arg1)->GetMaskGreen();
15588 wxPyEndAllowThreads(__tstate);
15589 if (PyErr_Occurred()) SWIG_fail;
15590 }
15591 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15592 return resultobj;
15593 fail:
15594 return NULL;
15595 }
15596
15597
15598 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15599 PyObject *resultobj = 0;
15600 wxImage *arg1 = (wxImage *) 0 ;
15601 byte result;
15602 void *argp1 = 0 ;
15603 int res1 = 0 ;
15604 PyObject *swig_obj[1] ;
15605
15606 if (!args) SWIG_fail;
15607 swig_obj[0] = args;
15608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15609 if (!SWIG_IsOK(res1)) {
15610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15611 }
15612 arg1 = reinterpret_cast< wxImage * >(argp1);
15613 {
15614 PyThreadState* __tstate = wxPyBeginAllowThreads();
15615 result = (byte)(arg1)->GetMaskBlue();
15616 wxPyEndAllowThreads(__tstate);
15617 if (PyErr_Occurred()) SWIG_fail;
15618 }
15619 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15620 return resultobj;
15621 fail:
15622 return NULL;
15623 }
15624
15625
15626 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15627 PyObject *resultobj = 0;
15628 wxImage *arg1 = (wxImage *) 0 ;
15629 bool arg2 = (bool) true ;
15630 void *argp1 = 0 ;
15631 int res1 = 0 ;
15632 bool val2 ;
15633 int ecode2 = 0 ;
15634 PyObject * obj0 = 0 ;
15635 PyObject * obj1 = 0 ;
15636 char * kwnames[] = {
15637 (char *) "self",(char *) "mask", NULL
15638 };
15639
15640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15642 if (!SWIG_IsOK(res1)) {
15643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15644 }
15645 arg1 = reinterpret_cast< wxImage * >(argp1);
15646 if (obj1) {
15647 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15648 if (!SWIG_IsOK(ecode2)) {
15649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15650 }
15651 arg2 = static_cast< bool >(val2);
15652 }
15653 {
15654 PyThreadState* __tstate = wxPyBeginAllowThreads();
15655 (arg1)->SetMask(arg2);
15656 wxPyEndAllowThreads(__tstate);
15657 if (PyErr_Occurred()) SWIG_fail;
15658 }
15659 resultobj = SWIG_Py_Void();
15660 return resultobj;
15661 fail:
15662 return NULL;
15663 }
15664
15665
15666 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15667 PyObject *resultobj = 0;
15668 wxImage *arg1 = (wxImage *) 0 ;
15669 bool result;
15670 void *argp1 = 0 ;
15671 int res1 = 0 ;
15672 PyObject *swig_obj[1] ;
15673
15674 if (!args) SWIG_fail;
15675 swig_obj[0] = args;
15676 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15677 if (!SWIG_IsOK(res1)) {
15678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15679 }
15680 arg1 = reinterpret_cast< wxImage * >(argp1);
15681 {
15682 PyThreadState* __tstate = wxPyBeginAllowThreads();
15683 result = (bool)(arg1)->HasMask();
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 {
15688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15689 }
15690 return resultobj;
15691 fail:
15692 return NULL;
15693 }
15694
15695
15696 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15697 PyObject *resultobj = 0;
15698 wxImage *arg1 = (wxImage *) 0 ;
15699 double arg2 ;
15700 wxPoint *arg3 = 0 ;
15701 bool arg4 = (bool) true ;
15702 wxPoint *arg5 = (wxPoint *) NULL ;
15703 SwigValueWrapper<wxImage > result;
15704 void *argp1 = 0 ;
15705 int res1 = 0 ;
15706 double val2 ;
15707 int ecode2 = 0 ;
15708 wxPoint temp3 ;
15709 bool val4 ;
15710 int ecode4 = 0 ;
15711 void *argp5 = 0 ;
15712 int res5 = 0 ;
15713 PyObject * obj0 = 0 ;
15714 PyObject * obj1 = 0 ;
15715 PyObject * obj2 = 0 ;
15716 PyObject * obj3 = 0 ;
15717 PyObject * obj4 = 0 ;
15718 char * kwnames[] = {
15719 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15720 };
15721
15722 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15723 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15724 if (!SWIG_IsOK(res1)) {
15725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15726 }
15727 arg1 = reinterpret_cast< wxImage * >(argp1);
15728 ecode2 = SWIG_AsVal_double(obj1, &val2);
15729 if (!SWIG_IsOK(ecode2)) {
15730 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15731 }
15732 arg2 = static_cast< double >(val2);
15733 {
15734 arg3 = &temp3;
15735 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15736 }
15737 if (obj3) {
15738 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15739 if (!SWIG_IsOK(ecode4)) {
15740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15741 }
15742 arg4 = static_cast< bool >(val4);
15743 }
15744 if (obj4) {
15745 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15746 if (!SWIG_IsOK(res5)) {
15747 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15748 }
15749 arg5 = reinterpret_cast< wxPoint * >(argp5);
15750 }
15751 {
15752 PyThreadState* __tstate = wxPyBeginAllowThreads();
15753 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15754 wxPyEndAllowThreads(__tstate);
15755 if (PyErr_Occurred()) SWIG_fail;
15756 }
15757 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15765 PyObject *resultobj = 0;
15766 wxImage *arg1 = (wxImage *) 0 ;
15767 bool arg2 = (bool) true ;
15768 SwigValueWrapper<wxImage > result;
15769 void *argp1 = 0 ;
15770 int res1 = 0 ;
15771 bool val2 ;
15772 int ecode2 = 0 ;
15773 PyObject * obj0 = 0 ;
15774 PyObject * obj1 = 0 ;
15775 char * kwnames[] = {
15776 (char *) "self",(char *) "clockwise", NULL
15777 };
15778
15779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15781 if (!SWIG_IsOK(res1)) {
15782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15783 }
15784 arg1 = reinterpret_cast< wxImage * >(argp1);
15785 if (obj1) {
15786 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15787 if (!SWIG_IsOK(ecode2)) {
15788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15789 }
15790 arg2 = static_cast< bool >(val2);
15791 }
15792 {
15793 PyThreadState* __tstate = wxPyBeginAllowThreads();
15794 result = (arg1)->Rotate90(arg2);
15795 wxPyEndAllowThreads(__tstate);
15796 if (PyErr_Occurred()) SWIG_fail;
15797 }
15798 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15799 return resultobj;
15800 fail:
15801 return NULL;
15802 }
15803
15804
15805 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15806 PyObject *resultobj = 0;
15807 wxImage *arg1 = (wxImage *) 0 ;
15808 bool arg2 = (bool) true ;
15809 SwigValueWrapper<wxImage > result;
15810 void *argp1 = 0 ;
15811 int res1 = 0 ;
15812 bool val2 ;
15813 int ecode2 = 0 ;
15814 PyObject * obj0 = 0 ;
15815 PyObject * obj1 = 0 ;
15816 char * kwnames[] = {
15817 (char *) "self",(char *) "horizontally", NULL
15818 };
15819
15820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15822 if (!SWIG_IsOK(res1)) {
15823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15824 }
15825 arg1 = reinterpret_cast< wxImage * >(argp1);
15826 if (obj1) {
15827 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15828 if (!SWIG_IsOK(ecode2)) {
15829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15830 }
15831 arg2 = static_cast< bool >(val2);
15832 }
15833 {
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (arg1)->Mirror(arg2);
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 wxImage *arg1 = (wxImage *) 0 ;
15849 byte arg2 ;
15850 byte arg3 ;
15851 byte arg4 ;
15852 byte arg5 ;
15853 byte arg6 ;
15854 byte arg7 ;
15855 void *argp1 = 0 ;
15856 int res1 = 0 ;
15857 unsigned char val2 ;
15858 int ecode2 = 0 ;
15859 unsigned char val3 ;
15860 int ecode3 = 0 ;
15861 unsigned char val4 ;
15862 int ecode4 = 0 ;
15863 unsigned char val5 ;
15864 int ecode5 = 0 ;
15865 unsigned char val6 ;
15866 int ecode6 = 0 ;
15867 unsigned char val7 ;
15868 int ecode7 = 0 ;
15869 PyObject * obj0 = 0 ;
15870 PyObject * obj1 = 0 ;
15871 PyObject * obj2 = 0 ;
15872 PyObject * obj3 = 0 ;
15873 PyObject * obj4 = 0 ;
15874 PyObject * obj5 = 0 ;
15875 PyObject * obj6 = 0 ;
15876 char * kwnames[] = {
15877 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15878 };
15879
15880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15882 if (!SWIG_IsOK(res1)) {
15883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15884 }
15885 arg1 = reinterpret_cast< wxImage * >(argp1);
15886 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15887 if (!SWIG_IsOK(ecode2)) {
15888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15889 }
15890 arg2 = static_cast< byte >(val2);
15891 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15892 if (!SWIG_IsOK(ecode3)) {
15893 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
15894 }
15895 arg3 = static_cast< byte >(val3);
15896 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15897 if (!SWIG_IsOK(ecode4)) {
15898 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
15899 }
15900 arg4 = static_cast< byte >(val4);
15901 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
15902 if (!SWIG_IsOK(ecode5)) {
15903 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
15904 }
15905 arg5 = static_cast< byte >(val5);
15906 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
15907 if (!SWIG_IsOK(ecode6)) {
15908 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
15909 }
15910 arg6 = static_cast< byte >(val6);
15911 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
15912 if (!SWIG_IsOK(ecode7)) {
15913 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
15914 }
15915 arg7 = static_cast< byte >(val7);
15916 {
15917 PyThreadState* __tstate = wxPyBeginAllowThreads();
15918 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
15919 wxPyEndAllowThreads(__tstate);
15920 if (PyErr_Occurred()) SWIG_fail;
15921 }
15922 resultobj = SWIG_Py_Void();
15923 return resultobj;
15924 fail:
15925 return NULL;
15926 }
15927
15928
15929 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15930 PyObject *resultobj = 0;
15931 wxImage *arg1 = (wxImage *) 0 ;
15932 double arg2 = (double) 0.299 ;
15933 double arg3 = (double) 0.587 ;
15934 double arg4 = (double) 0.114 ;
15935 SwigValueWrapper<wxImage > result;
15936 void *argp1 = 0 ;
15937 int res1 = 0 ;
15938 double val2 ;
15939 int ecode2 = 0 ;
15940 double val3 ;
15941 int ecode3 = 0 ;
15942 double val4 ;
15943 int ecode4 = 0 ;
15944 PyObject * obj0 = 0 ;
15945 PyObject * obj1 = 0 ;
15946 PyObject * obj2 = 0 ;
15947 PyObject * obj3 = 0 ;
15948 char * kwnames[] = {
15949 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
15950 };
15951
15952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15954 if (!SWIG_IsOK(res1)) {
15955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
15956 }
15957 arg1 = reinterpret_cast< wxImage * >(argp1);
15958 if (obj1) {
15959 ecode2 = SWIG_AsVal_double(obj1, &val2);
15960 if (!SWIG_IsOK(ecode2)) {
15961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
15962 }
15963 arg2 = static_cast< double >(val2);
15964 }
15965 if (obj2) {
15966 ecode3 = SWIG_AsVal_double(obj2, &val3);
15967 if (!SWIG_IsOK(ecode3)) {
15968 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
15969 }
15970 arg3 = static_cast< double >(val3);
15971 }
15972 if (obj3) {
15973 ecode4 = SWIG_AsVal_double(obj3, &val4);
15974 if (!SWIG_IsOK(ecode4)) {
15975 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
15976 }
15977 arg4 = static_cast< double >(val4);
15978 }
15979 {
15980 PyThreadState* __tstate = wxPyBeginAllowThreads();
15981 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
15982 wxPyEndAllowThreads(__tstate);
15983 if (PyErr_Occurred()) SWIG_fail;
15984 }
15985 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15986 return resultobj;
15987 fail:
15988 return NULL;
15989 }
15990
15991
15992 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15993 PyObject *resultobj = 0;
15994 wxImage *arg1 = (wxImage *) 0 ;
15995 byte arg2 ;
15996 byte arg3 ;
15997 byte arg4 ;
15998 SwigValueWrapper<wxImage > result;
15999 void *argp1 = 0 ;
16000 int res1 = 0 ;
16001 unsigned char val2 ;
16002 int ecode2 = 0 ;
16003 unsigned char val3 ;
16004 int ecode3 = 0 ;
16005 unsigned char val4 ;
16006 int ecode4 = 0 ;
16007 PyObject * obj0 = 0 ;
16008 PyObject * obj1 = 0 ;
16009 PyObject * obj2 = 0 ;
16010 PyObject * obj3 = 0 ;
16011 char * kwnames[] = {
16012 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16013 };
16014
16015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16017 if (!SWIG_IsOK(res1)) {
16018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16019 }
16020 arg1 = reinterpret_cast< wxImage * >(argp1);
16021 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16022 if (!SWIG_IsOK(ecode2)) {
16023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16024 }
16025 arg2 = static_cast< byte >(val2);
16026 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16027 if (!SWIG_IsOK(ecode3)) {
16028 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16029 }
16030 arg3 = static_cast< byte >(val3);
16031 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16032 if (!SWIG_IsOK(ecode4)) {
16033 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16034 }
16035 arg4 = static_cast< byte >(val4);
16036 {
16037 PyThreadState* __tstate = wxPyBeginAllowThreads();
16038 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16039 wxPyEndAllowThreads(__tstate);
16040 if (PyErr_Occurred()) SWIG_fail;
16041 }
16042 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16043 return resultobj;
16044 fail:
16045 return NULL;
16046 }
16047
16048
16049 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16050 PyObject *resultobj = 0;
16051 wxImage *arg1 = (wxImage *) 0 ;
16052 wxString *arg2 = 0 ;
16053 wxString *arg3 = 0 ;
16054 void *argp1 = 0 ;
16055 int res1 = 0 ;
16056 bool temp2 = false ;
16057 bool temp3 = false ;
16058 PyObject * obj0 = 0 ;
16059 PyObject * obj1 = 0 ;
16060 PyObject * obj2 = 0 ;
16061 char * kwnames[] = {
16062 (char *) "self",(char *) "name",(char *) "value", NULL
16063 };
16064
16065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16067 if (!SWIG_IsOK(res1)) {
16068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16069 }
16070 arg1 = reinterpret_cast< wxImage * >(argp1);
16071 {
16072 arg2 = wxString_in_helper(obj1);
16073 if (arg2 == NULL) SWIG_fail;
16074 temp2 = true;
16075 }
16076 {
16077 arg3 = wxString_in_helper(obj2);
16078 if (arg3 == NULL) SWIG_fail;
16079 temp3 = true;
16080 }
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 resultobj = SWIG_Py_Void();
16088 {
16089 if (temp2)
16090 delete arg2;
16091 }
16092 {
16093 if (temp3)
16094 delete arg3;
16095 }
16096 return resultobj;
16097 fail:
16098 {
16099 if (temp2)
16100 delete arg2;
16101 }
16102 {
16103 if (temp3)
16104 delete arg3;
16105 }
16106 return NULL;
16107 }
16108
16109
16110 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16111 PyObject *resultobj = 0;
16112 wxImage *arg1 = (wxImage *) 0 ;
16113 wxString *arg2 = 0 ;
16114 int arg3 ;
16115 void *argp1 = 0 ;
16116 int res1 = 0 ;
16117 bool temp2 = false ;
16118 int val3 ;
16119 int ecode3 = 0 ;
16120 PyObject * obj0 = 0 ;
16121 PyObject * obj1 = 0 ;
16122 PyObject * obj2 = 0 ;
16123 char * kwnames[] = {
16124 (char *) "self",(char *) "name",(char *) "value", NULL
16125 };
16126
16127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16129 if (!SWIG_IsOK(res1)) {
16130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16131 }
16132 arg1 = reinterpret_cast< wxImage * >(argp1);
16133 {
16134 arg2 = wxString_in_helper(obj1);
16135 if (arg2 == NULL) SWIG_fail;
16136 temp2 = true;
16137 }
16138 ecode3 = SWIG_AsVal_int(obj2, &val3);
16139 if (!SWIG_IsOK(ecode3)) {
16140 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16141 }
16142 arg3 = static_cast< int >(val3);
16143 {
16144 PyThreadState* __tstate = wxPyBeginAllowThreads();
16145 (arg1)->SetOption((wxString const &)*arg2,arg3);
16146 wxPyEndAllowThreads(__tstate);
16147 if (PyErr_Occurred()) SWIG_fail;
16148 }
16149 resultobj = SWIG_Py_Void();
16150 {
16151 if (temp2)
16152 delete arg2;
16153 }
16154 return resultobj;
16155 fail:
16156 {
16157 if (temp2)
16158 delete arg2;
16159 }
16160 return NULL;
16161 }
16162
16163
16164 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16165 PyObject *resultobj = 0;
16166 wxImage *arg1 = (wxImage *) 0 ;
16167 wxString *arg2 = 0 ;
16168 wxString result;
16169 void *argp1 = 0 ;
16170 int res1 = 0 ;
16171 bool temp2 = false ;
16172 PyObject * obj0 = 0 ;
16173 PyObject * obj1 = 0 ;
16174 char * kwnames[] = {
16175 (char *) "self",(char *) "name", NULL
16176 };
16177
16178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16180 if (!SWIG_IsOK(res1)) {
16181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16182 }
16183 arg1 = reinterpret_cast< wxImage * >(argp1);
16184 {
16185 arg2 = wxString_in_helper(obj1);
16186 if (arg2 == NULL) SWIG_fail;
16187 temp2 = true;
16188 }
16189 {
16190 PyThreadState* __tstate = wxPyBeginAllowThreads();
16191 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 {
16196 #if wxUSE_UNICODE
16197 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16198 #else
16199 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16200 #endif
16201 }
16202 {
16203 if (temp2)
16204 delete arg2;
16205 }
16206 return resultobj;
16207 fail:
16208 {
16209 if (temp2)
16210 delete arg2;
16211 }
16212 return NULL;
16213 }
16214
16215
16216 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16217 PyObject *resultobj = 0;
16218 wxImage *arg1 = (wxImage *) 0 ;
16219 wxString *arg2 = 0 ;
16220 int result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 bool temp2 = false ;
16224 PyObject * obj0 = 0 ;
16225 PyObject * obj1 = 0 ;
16226 char * kwnames[] = {
16227 (char *) "self",(char *) "name", NULL
16228 };
16229
16230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16232 if (!SWIG_IsOK(res1)) {
16233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16234 }
16235 arg1 = reinterpret_cast< wxImage * >(argp1);
16236 {
16237 arg2 = wxString_in_helper(obj1);
16238 if (arg2 == NULL) SWIG_fail;
16239 temp2 = true;
16240 }
16241 {
16242 PyThreadState* __tstate = wxPyBeginAllowThreads();
16243 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16244 wxPyEndAllowThreads(__tstate);
16245 if (PyErr_Occurred()) SWIG_fail;
16246 }
16247 resultobj = SWIG_From_int(static_cast< int >(result));
16248 {
16249 if (temp2)
16250 delete arg2;
16251 }
16252 return resultobj;
16253 fail:
16254 {
16255 if (temp2)
16256 delete arg2;
16257 }
16258 return NULL;
16259 }
16260
16261
16262 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16263 PyObject *resultobj = 0;
16264 wxImage *arg1 = (wxImage *) 0 ;
16265 wxString *arg2 = 0 ;
16266 bool result;
16267 void *argp1 = 0 ;
16268 int res1 = 0 ;
16269 bool temp2 = false ;
16270 PyObject * obj0 = 0 ;
16271 PyObject * obj1 = 0 ;
16272 char * kwnames[] = {
16273 (char *) "self",(char *) "name", NULL
16274 };
16275
16276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16278 if (!SWIG_IsOK(res1)) {
16279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16280 }
16281 arg1 = reinterpret_cast< wxImage * >(argp1);
16282 {
16283 arg2 = wxString_in_helper(obj1);
16284 if (arg2 == NULL) SWIG_fail;
16285 temp2 = true;
16286 }
16287 {
16288 PyThreadState* __tstate = wxPyBeginAllowThreads();
16289 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16290 wxPyEndAllowThreads(__tstate);
16291 if (PyErr_Occurred()) SWIG_fail;
16292 }
16293 {
16294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16295 }
16296 {
16297 if (temp2)
16298 delete arg2;
16299 }
16300 return resultobj;
16301 fail:
16302 {
16303 if (temp2)
16304 delete arg2;
16305 }
16306 return NULL;
16307 }
16308
16309
16310 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16311 PyObject *resultobj = 0;
16312 wxImage *arg1 = (wxImage *) 0 ;
16313 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16314 unsigned long result;
16315 void *argp1 = 0 ;
16316 int res1 = 0 ;
16317 unsigned long val2 ;
16318 int ecode2 = 0 ;
16319 PyObject * obj0 = 0 ;
16320 PyObject * obj1 = 0 ;
16321 char * kwnames[] = {
16322 (char *) "self",(char *) "stopafter", NULL
16323 };
16324
16325 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16326 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16327 if (!SWIG_IsOK(res1)) {
16328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16329 }
16330 arg1 = reinterpret_cast< wxImage * >(argp1);
16331 if (obj1) {
16332 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16333 if (!SWIG_IsOK(ecode2)) {
16334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16335 }
16336 arg2 = static_cast< unsigned long >(val2);
16337 }
16338 {
16339 PyThreadState* __tstate = wxPyBeginAllowThreads();
16340 result = (unsigned long)(arg1)->CountColours(arg2);
16341 wxPyEndAllowThreads(__tstate);
16342 if (PyErr_Occurred()) SWIG_fail;
16343 }
16344 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16345 return resultobj;
16346 fail:
16347 return NULL;
16348 }
16349
16350
16351 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16352 PyObject *resultobj = 0;
16353 wxImage *arg1 = (wxImage *) 0 ;
16354 wxImageHistogram *arg2 = 0 ;
16355 unsigned long result;
16356 void *argp1 = 0 ;
16357 int res1 = 0 ;
16358 void *argp2 = 0 ;
16359 int res2 = 0 ;
16360 PyObject * obj0 = 0 ;
16361 PyObject * obj1 = 0 ;
16362 char * kwnames[] = {
16363 (char *) "self",(char *) "h", NULL
16364 };
16365
16366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16368 if (!SWIG_IsOK(res1)) {
16369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16370 }
16371 arg1 = reinterpret_cast< wxImage * >(argp1);
16372 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16373 if (!SWIG_IsOK(res2)) {
16374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16375 }
16376 if (!argp2) {
16377 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16378 }
16379 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16380 {
16381 PyThreadState* __tstate = wxPyBeginAllowThreads();
16382 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16383 wxPyEndAllowThreads(__tstate);
16384 if (PyErr_Occurred()) SWIG_fail;
16385 }
16386 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16387 return resultobj;
16388 fail:
16389 return NULL;
16390 }
16391
16392
16393 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16394 PyObject *resultobj = 0;
16395 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16396 void *argp1 = 0 ;
16397 int res1 = 0 ;
16398 PyObject * obj0 = 0 ;
16399 char * kwnames[] = {
16400 (char *) "handler", NULL
16401 };
16402
16403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16405 if (!SWIG_IsOK(res1)) {
16406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16407 }
16408 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16409 {
16410 PyThreadState* __tstate = wxPyBeginAllowThreads();
16411 wxImage::AddHandler(arg1);
16412 wxPyEndAllowThreads(__tstate);
16413 if (PyErr_Occurred()) SWIG_fail;
16414 }
16415 resultobj = SWIG_Py_Void();
16416 return resultobj;
16417 fail:
16418 return NULL;
16419 }
16420
16421
16422 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16423 PyObject *resultobj = 0;
16424 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16425 void *argp1 = 0 ;
16426 int res1 = 0 ;
16427 PyObject * obj0 = 0 ;
16428 char * kwnames[] = {
16429 (char *) "handler", NULL
16430 };
16431
16432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16434 if (!SWIG_IsOK(res1)) {
16435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16436 }
16437 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16438 {
16439 PyThreadState* __tstate = wxPyBeginAllowThreads();
16440 wxImage::InsertHandler(arg1);
16441 wxPyEndAllowThreads(__tstate);
16442 if (PyErr_Occurred()) SWIG_fail;
16443 }
16444 resultobj = SWIG_Py_Void();
16445 return resultobj;
16446 fail:
16447 return NULL;
16448 }
16449
16450
16451 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16452 PyObject *resultobj = 0;
16453 wxString *arg1 = 0 ;
16454 bool result;
16455 bool temp1 = false ;
16456 PyObject * obj0 = 0 ;
16457 char * kwnames[] = {
16458 (char *) "name", NULL
16459 };
16460
16461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16462 {
16463 arg1 = wxString_in_helper(obj0);
16464 if (arg1 == NULL) SWIG_fail;
16465 temp1 = true;
16466 }
16467 {
16468 PyThreadState* __tstate = wxPyBeginAllowThreads();
16469 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16470 wxPyEndAllowThreads(__tstate);
16471 if (PyErr_Occurred()) SWIG_fail;
16472 }
16473 {
16474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16475 }
16476 {
16477 if (temp1)
16478 delete arg1;
16479 }
16480 return resultobj;
16481 fail:
16482 {
16483 if (temp1)
16484 delete arg1;
16485 }
16486 return NULL;
16487 }
16488
16489
16490 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16491 PyObject *resultobj = 0;
16492 PyObject *result = 0 ;
16493
16494 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16495 {
16496 PyThreadState* __tstate = wxPyBeginAllowThreads();
16497 result = (PyObject *)wxImage_GetHandlers();
16498 wxPyEndAllowThreads(__tstate);
16499 if (PyErr_Occurred()) SWIG_fail;
16500 }
16501 resultobj = result;
16502 return resultobj;
16503 fail:
16504 return NULL;
16505 }
16506
16507
16508 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16509 PyObject *resultobj = 0;
16510 wxString result;
16511
16512 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16513 {
16514 PyThreadState* __tstate = wxPyBeginAllowThreads();
16515 result = wxImage::GetImageExtWildcard();
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 {
16520 #if wxUSE_UNICODE
16521 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16522 #else
16523 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16524 #endif
16525 }
16526 return resultobj;
16527 fail:
16528 return NULL;
16529 }
16530
16531
16532 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxImage *arg1 = (wxImage *) 0 ;
16535 int arg2 = (int) -1 ;
16536 wxBitmap result;
16537 void *argp1 = 0 ;
16538 int res1 = 0 ;
16539 int val2 ;
16540 int ecode2 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "self",(char *) "depth", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16551 }
16552 arg1 = reinterpret_cast< wxImage * >(argp1);
16553 if (obj1) {
16554 ecode2 = SWIG_AsVal_int(obj1, &val2);
16555 if (!SWIG_IsOK(ecode2)) {
16556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16557 }
16558 arg2 = static_cast< int >(val2);
16559 }
16560 {
16561 if (!wxPyCheckForApp()) SWIG_fail;
16562 PyThreadState* __tstate = wxPyBeginAllowThreads();
16563 result = wxImage_ConvertToBitmap(arg1,arg2);
16564 wxPyEndAllowThreads(__tstate);
16565 if (PyErr_Occurred()) SWIG_fail;
16566 }
16567 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16568 return resultobj;
16569 fail:
16570 return NULL;
16571 }
16572
16573
16574 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16575 PyObject *resultobj = 0;
16576 wxImage *arg1 = (wxImage *) 0 ;
16577 byte arg2 ;
16578 byte arg3 ;
16579 byte arg4 ;
16580 wxBitmap result;
16581 void *argp1 = 0 ;
16582 int res1 = 0 ;
16583 unsigned char val2 ;
16584 int ecode2 = 0 ;
16585 unsigned char val3 ;
16586 int ecode3 = 0 ;
16587 unsigned char val4 ;
16588 int ecode4 = 0 ;
16589 PyObject * obj0 = 0 ;
16590 PyObject * obj1 = 0 ;
16591 PyObject * obj2 = 0 ;
16592 PyObject * obj3 = 0 ;
16593 char * kwnames[] = {
16594 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16595 };
16596
16597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16599 if (!SWIG_IsOK(res1)) {
16600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16601 }
16602 arg1 = reinterpret_cast< wxImage * >(argp1);
16603 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16604 if (!SWIG_IsOK(ecode2)) {
16605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16606 }
16607 arg2 = static_cast< byte >(val2);
16608 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16609 if (!SWIG_IsOK(ecode3)) {
16610 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', 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_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16616 }
16617 arg4 = static_cast< byte >(val4);
16618 {
16619 if (!wxPyCheckForApp()) SWIG_fail;
16620 PyThreadState* __tstate = wxPyBeginAllowThreads();
16621 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16622 wxPyEndAllowThreads(__tstate);
16623 if (PyErr_Occurred()) SWIG_fail;
16624 }
16625 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj = 0;
16634 wxImage *arg1 = (wxImage *) 0 ;
16635 double arg2 ;
16636 void *argp1 = 0 ;
16637 int res1 = 0 ;
16638 double val2 ;
16639 int ecode2 = 0 ;
16640 PyObject * obj0 = 0 ;
16641 PyObject * obj1 = 0 ;
16642 char * kwnames[] = {
16643 (char *) "self",(char *) "angle", NULL
16644 };
16645
16646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16648 if (!SWIG_IsOK(res1)) {
16649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16650 }
16651 arg1 = reinterpret_cast< wxImage * >(argp1);
16652 ecode2 = SWIG_AsVal_double(obj1, &val2);
16653 if (!SWIG_IsOK(ecode2)) {
16654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16655 }
16656 arg2 = static_cast< double >(val2);
16657 {
16658 PyThreadState* __tstate = wxPyBeginAllowThreads();
16659 (arg1)->RotateHue(arg2);
16660 wxPyEndAllowThreads(__tstate);
16661 if (PyErr_Occurred()) SWIG_fail;
16662 }
16663 resultobj = SWIG_Py_Void();
16664 return resultobj;
16665 fail:
16666 return NULL;
16667 }
16668
16669
16670 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16671 PyObject *resultobj = 0;
16672 wxImage_RGBValue arg1 ;
16673 wxImage_HSVValue result;
16674 void *argp1 ;
16675 int res1 = 0 ;
16676 PyObject * obj0 = 0 ;
16677 char * kwnames[] = {
16678 (char *) "rgb", NULL
16679 };
16680
16681 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16682 {
16683 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16684 if (!SWIG_IsOK(res1)) {
16685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16686 }
16687 if (!argp1) {
16688 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16689 } else {
16690 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16691 arg1 = *temp;
16692 if (SWIG_IsNewObj(res1)) delete temp;
16693 }
16694 }
16695 {
16696 PyThreadState* __tstate = wxPyBeginAllowThreads();
16697 result = wxImage::RGBtoHSV(arg1);
16698 wxPyEndAllowThreads(__tstate);
16699 if (PyErr_Occurred()) SWIG_fail;
16700 }
16701 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16702 return resultobj;
16703 fail:
16704 return NULL;
16705 }
16706
16707
16708 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16709 PyObject *resultobj = 0;
16710 wxImage_HSVValue arg1 ;
16711 wxImage_RGBValue result;
16712 void *argp1 ;
16713 int res1 = 0 ;
16714 PyObject * obj0 = 0 ;
16715 char * kwnames[] = {
16716 (char *) "hsv", NULL
16717 };
16718
16719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16720 {
16721 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16722 if (!SWIG_IsOK(res1)) {
16723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16724 }
16725 if (!argp1) {
16726 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16727 } else {
16728 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16729 arg1 = *temp;
16730 if (SWIG_IsNewObj(res1)) delete temp;
16731 }
16732 }
16733 {
16734 PyThreadState* __tstate = wxPyBeginAllowThreads();
16735 result = wxImage::HSVtoRGB(arg1);
16736 wxPyEndAllowThreads(__tstate);
16737 if (PyErr_Occurred()) SWIG_fail;
16738 }
16739 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16740 return resultobj;
16741 fail:
16742 return NULL;
16743 }
16744
16745
16746 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16747 PyObject *obj;
16748 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16749 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16750 return SWIG_Py_Void();
16751 }
16752
16753 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16754 return SWIG_Python_InitShadowInstance(args);
16755 }
16756
16757 SWIGINTERN int NullImage_set(PyObject *) {
16758 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16759 return 1;
16760 }
16761
16762
16763 SWIGINTERN PyObject *NullImage_get(void) {
16764 PyObject *pyobj = 0;
16765
16766 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16767 return pyobj;
16768 }
16769
16770
16771 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16772 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16773 return 1;
16774 }
16775
16776
16777 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16778 PyObject *pyobj = 0;
16779
16780 {
16781 #if wxUSE_UNICODE
16782 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16783 #else
16784 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16785 #endif
16786 }
16787 return pyobj;
16788 }
16789
16790
16791 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16792 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16793 return 1;
16794 }
16795
16796
16797 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16798 PyObject *pyobj = 0;
16799
16800 {
16801 #if wxUSE_UNICODE
16802 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16803 #else
16804 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16805 #endif
16806 }
16807 return pyobj;
16808 }
16809
16810
16811 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16812 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16813 return 1;
16814 }
16815
16816
16817 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16818 PyObject *pyobj = 0;
16819
16820 {
16821 #if wxUSE_UNICODE
16822 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16823 #else
16824 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16825 #endif
16826 }
16827 return pyobj;
16828 }
16829
16830
16831 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16832 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16833 return 1;
16834 }
16835
16836
16837 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16838 PyObject *pyobj = 0;
16839
16840 {
16841 #if wxUSE_UNICODE
16842 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16843 #else
16844 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16845 #endif
16846 }
16847 return pyobj;
16848 }
16849
16850
16851 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16852 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16853 return 1;
16854 }
16855
16856
16857 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16858 PyObject *pyobj = 0;
16859
16860 {
16861 #if wxUSE_UNICODE
16862 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16863 #else
16864 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16865 #endif
16866 }
16867 return pyobj;
16868 }
16869
16870
16871 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16872 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16873 return 1;
16874 }
16875
16876
16877 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16878 PyObject *pyobj = 0;
16879
16880 {
16881 #if wxUSE_UNICODE
16882 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16883 #else
16884 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16885 #endif
16886 }
16887 return pyobj;
16888 }
16889
16890
16891 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
16892 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
16893 return 1;
16894 }
16895
16896
16897 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
16898 PyObject *pyobj = 0;
16899
16900 {
16901 #if wxUSE_UNICODE
16902 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16903 #else
16904 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
16905 #endif
16906 }
16907 return pyobj;
16908 }
16909
16910
16911 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
16912 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
16913 return 1;
16914 }
16915
16916
16917 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
16918 PyObject *pyobj = 0;
16919
16920 {
16921 #if wxUSE_UNICODE
16922 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16923 #else
16924 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
16925 #endif
16926 }
16927 return pyobj;
16928 }
16929
16930
16931 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
16932 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
16933 return 1;
16934 }
16935
16936
16937 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
16938 PyObject *pyobj = 0;
16939
16940 {
16941 #if wxUSE_UNICODE
16942 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16943 #else
16944 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
16945 #endif
16946 }
16947 return pyobj;
16948 }
16949
16950
16951 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
16952 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
16953 return 1;
16954 }
16955
16956
16957 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
16958 PyObject *pyobj = 0;
16959
16960 {
16961 #if wxUSE_UNICODE
16962 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16963 #else
16964 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
16965 #endif
16966 }
16967 return pyobj;
16968 }
16969
16970
16971 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
16972 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
16973 return 1;
16974 }
16975
16976
16977 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
16978 PyObject *pyobj = 0;
16979
16980 {
16981 #if wxUSE_UNICODE
16982 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
16983 #else
16984 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
16985 #endif
16986 }
16987 return pyobj;
16988 }
16989
16990
16991 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
16992 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
16993 return 1;
16994 }
16995
16996
16997 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
16998 PyObject *pyobj = 0;
16999
17000 {
17001 #if wxUSE_UNICODE
17002 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17003 #else
17004 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17005 #endif
17006 }
17007 return pyobj;
17008 }
17009
17010
17011 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17012 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17013 return 1;
17014 }
17015
17016
17017 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17018 PyObject *pyobj = 0;
17019
17020 {
17021 #if wxUSE_UNICODE
17022 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17023 #else
17024 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17025 #endif
17026 }
17027 return pyobj;
17028 }
17029
17030
17031 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17032 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17033 return 1;
17034 }
17035
17036
17037 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17038 PyObject *pyobj = 0;
17039
17040 {
17041 #if wxUSE_UNICODE
17042 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17043 #else
17044 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17045 #endif
17046 }
17047 return pyobj;
17048 }
17049
17050
17051 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17052 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17053 return 1;
17054 }
17055
17056
17057 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17058 PyObject *pyobj = 0;
17059
17060 {
17061 #if wxUSE_UNICODE
17062 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17063 #else
17064 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17065 #endif
17066 }
17067 return pyobj;
17068 }
17069
17070
17071 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17072 PyObject *resultobj = 0;
17073 wxBMPHandler *result = 0 ;
17074
17075 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = (wxBMPHandler *)new wxBMPHandler();
17079 wxPyEndAllowThreads(__tstate);
17080 if (PyErr_Occurred()) SWIG_fail;
17081 }
17082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17083 return resultobj;
17084 fail:
17085 return NULL;
17086 }
17087
17088
17089 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17090 PyObject *obj;
17091 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17092 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17093 return SWIG_Py_Void();
17094 }
17095
17096 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17097 return SWIG_Python_InitShadowInstance(args);
17098 }
17099
17100 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17101 PyObject *resultobj = 0;
17102 wxICOHandler *result = 0 ;
17103
17104 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17105 {
17106 PyThreadState* __tstate = wxPyBeginAllowThreads();
17107 result = (wxICOHandler *)new wxICOHandler();
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17112 return resultobj;
17113 fail:
17114 return NULL;
17115 }
17116
17117
17118 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17119 PyObject *obj;
17120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17121 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17122 return SWIG_Py_Void();
17123 }
17124
17125 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17126 return SWIG_Python_InitShadowInstance(args);
17127 }
17128
17129 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17130 PyObject *resultobj = 0;
17131 wxCURHandler *result = 0 ;
17132
17133 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17134 {
17135 PyThreadState* __tstate = wxPyBeginAllowThreads();
17136 result = (wxCURHandler *)new wxCURHandler();
17137 wxPyEndAllowThreads(__tstate);
17138 if (PyErr_Occurred()) SWIG_fail;
17139 }
17140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17141 return resultobj;
17142 fail:
17143 return NULL;
17144 }
17145
17146
17147 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17148 PyObject *obj;
17149 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17150 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17151 return SWIG_Py_Void();
17152 }
17153
17154 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17155 return SWIG_Python_InitShadowInstance(args);
17156 }
17157
17158 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17159 PyObject *resultobj = 0;
17160 wxANIHandler *result = 0 ;
17161
17162 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17163 {
17164 PyThreadState* __tstate = wxPyBeginAllowThreads();
17165 result = (wxANIHandler *)new wxANIHandler();
17166 wxPyEndAllowThreads(__tstate);
17167 if (PyErr_Occurred()) SWIG_fail;
17168 }
17169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17177 PyObject *obj;
17178 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17179 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17180 return SWIG_Py_Void();
17181 }
17182
17183 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17184 return SWIG_Python_InitShadowInstance(args);
17185 }
17186
17187 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17188 PyObject *resultobj = 0;
17189 wxPNGHandler *result = 0 ;
17190
17191 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17192 {
17193 PyThreadState* __tstate = wxPyBeginAllowThreads();
17194 result = (wxPNGHandler *)new wxPNGHandler();
17195 wxPyEndAllowThreads(__tstate);
17196 if (PyErr_Occurred()) SWIG_fail;
17197 }
17198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17206 PyObject *obj;
17207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17208 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17209 return SWIG_Py_Void();
17210 }
17211
17212 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17213 return SWIG_Python_InitShadowInstance(args);
17214 }
17215
17216 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17217 PyObject *resultobj = 0;
17218 wxGIFHandler *result = 0 ;
17219
17220 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17221 {
17222 PyThreadState* __tstate = wxPyBeginAllowThreads();
17223 result = (wxGIFHandler *)new wxGIFHandler();
17224 wxPyEndAllowThreads(__tstate);
17225 if (PyErr_Occurred()) SWIG_fail;
17226 }
17227 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17228 return resultobj;
17229 fail:
17230 return NULL;
17231 }
17232
17233
17234 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17235 PyObject *obj;
17236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17237 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17238 return SWIG_Py_Void();
17239 }
17240
17241 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17242 return SWIG_Python_InitShadowInstance(args);
17243 }
17244
17245 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17246 PyObject *resultobj = 0;
17247 wxPCXHandler *result = 0 ;
17248
17249 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17250 {
17251 PyThreadState* __tstate = wxPyBeginAllowThreads();
17252 result = (wxPCXHandler *)new wxPCXHandler();
17253 wxPyEndAllowThreads(__tstate);
17254 if (PyErr_Occurred()) SWIG_fail;
17255 }
17256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17257 return resultobj;
17258 fail:
17259 return NULL;
17260 }
17261
17262
17263 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17264 PyObject *obj;
17265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17266 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17267 return SWIG_Py_Void();
17268 }
17269
17270 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17271 return SWIG_Python_InitShadowInstance(args);
17272 }
17273
17274 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17275 PyObject *resultobj = 0;
17276 wxJPEGHandler *result = 0 ;
17277
17278 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17279 {
17280 PyThreadState* __tstate = wxPyBeginAllowThreads();
17281 result = (wxJPEGHandler *)new wxJPEGHandler();
17282 wxPyEndAllowThreads(__tstate);
17283 if (PyErr_Occurred()) SWIG_fail;
17284 }
17285 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17286 return resultobj;
17287 fail:
17288 return NULL;
17289 }
17290
17291
17292 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17293 PyObject *obj;
17294 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17295 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17296 return SWIG_Py_Void();
17297 }
17298
17299 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17300 return SWIG_Python_InitShadowInstance(args);
17301 }
17302
17303 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17304 PyObject *resultobj = 0;
17305 wxPNMHandler *result = 0 ;
17306
17307 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17308 {
17309 PyThreadState* __tstate = wxPyBeginAllowThreads();
17310 result = (wxPNMHandler *)new wxPNMHandler();
17311 wxPyEndAllowThreads(__tstate);
17312 if (PyErr_Occurred()) SWIG_fail;
17313 }
17314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17315 return resultobj;
17316 fail:
17317 return NULL;
17318 }
17319
17320
17321 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 PyObject *obj;
17323 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17324 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17325 return SWIG_Py_Void();
17326 }
17327
17328 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17329 return SWIG_Python_InitShadowInstance(args);
17330 }
17331
17332 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17333 PyObject *resultobj = 0;
17334 wxXPMHandler *result = 0 ;
17335
17336 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17337 {
17338 PyThreadState* __tstate = wxPyBeginAllowThreads();
17339 result = (wxXPMHandler *)new wxXPMHandler();
17340 wxPyEndAllowThreads(__tstate);
17341 if (PyErr_Occurred()) SWIG_fail;
17342 }
17343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17344 return resultobj;
17345 fail:
17346 return NULL;
17347 }
17348
17349
17350 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17351 PyObject *obj;
17352 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17353 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17354 return SWIG_Py_Void();
17355 }
17356
17357 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17358 return SWIG_Python_InitShadowInstance(args);
17359 }
17360
17361 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17362 PyObject *resultobj = 0;
17363 wxTIFFHandler *result = 0 ;
17364
17365 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17366 {
17367 PyThreadState* __tstate = wxPyBeginAllowThreads();
17368 result = (wxTIFFHandler *)new wxTIFFHandler();
17369 wxPyEndAllowThreads(__tstate);
17370 if (PyErr_Occurred()) SWIG_fail;
17371 }
17372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17373 return resultobj;
17374 fail:
17375 return NULL;
17376 }
17377
17378
17379 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17380 PyObject *obj;
17381 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17382 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17383 return SWIG_Py_Void();
17384 }
17385
17386 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17387 return SWIG_Python_InitShadowInstance(args);
17388 }
17389
17390 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17391 PyObject *resultobj = 0;
17392 wxImage *arg1 = 0 ;
17393 wxImage *arg2 = 0 ;
17394 int arg3 = (int) 236 ;
17395 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17396 bool result;
17397 void *argp1 = 0 ;
17398 int res1 = 0 ;
17399 void *argp2 = 0 ;
17400 int res2 = 0 ;
17401 int val3 ;
17402 int ecode3 = 0 ;
17403 int val4 ;
17404 int ecode4 = 0 ;
17405 PyObject * obj0 = 0 ;
17406 PyObject * obj1 = 0 ;
17407 PyObject * obj2 = 0 ;
17408 PyObject * obj3 = 0 ;
17409 char * kwnames[] = {
17410 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17411 };
17412
17413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17414 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17415 if (!SWIG_IsOK(res1)) {
17416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17417 }
17418 if (!argp1) {
17419 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17420 }
17421 arg1 = reinterpret_cast< wxImage * >(argp1);
17422 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17423 if (!SWIG_IsOK(res2)) {
17424 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17425 }
17426 if (!argp2) {
17427 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17428 }
17429 arg2 = reinterpret_cast< wxImage * >(argp2);
17430 if (obj2) {
17431 ecode3 = SWIG_AsVal_int(obj2, &val3);
17432 if (!SWIG_IsOK(ecode3)) {
17433 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17434 }
17435 arg3 = static_cast< int >(val3);
17436 }
17437 if (obj3) {
17438 ecode4 = SWIG_AsVal_int(obj3, &val4);
17439 if (!SWIG_IsOK(ecode4)) {
17440 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17441 }
17442 arg4 = static_cast< int >(val4);
17443 }
17444 {
17445 PyThreadState* __tstate = wxPyBeginAllowThreads();
17446 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17447 wxPyEndAllowThreads(__tstate);
17448 if (PyErr_Occurred()) SWIG_fail;
17449 }
17450 {
17451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17452 }
17453 return resultobj;
17454 fail:
17455 return NULL;
17456 }
17457
17458
17459 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17460 PyObject *obj;
17461 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17462 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17463 return SWIG_Py_Void();
17464 }
17465
17466 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17467 PyObject *resultobj = 0;
17468 wxEvtHandler *result = 0 ;
17469
17470 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17471 {
17472 PyThreadState* __tstate = wxPyBeginAllowThreads();
17473 result = (wxEvtHandler *)new wxEvtHandler();
17474 wxPyEndAllowThreads(__tstate);
17475 if (PyErr_Occurred()) SWIG_fail;
17476 }
17477 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17478 return resultobj;
17479 fail:
17480 return NULL;
17481 }
17482
17483
17484 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17485 PyObject *resultobj = 0;
17486 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17487 wxEvtHandler *result = 0 ;
17488 void *argp1 = 0 ;
17489 int res1 = 0 ;
17490 PyObject *swig_obj[1] ;
17491
17492 if (!args) SWIG_fail;
17493 swig_obj[0] = args;
17494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17495 if (!SWIG_IsOK(res1)) {
17496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17497 }
17498 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17499 {
17500 PyThreadState* __tstate = wxPyBeginAllowThreads();
17501 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17502 wxPyEndAllowThreads(__tstate);
17503 if (PyErr_Occurred()) SWIG_fail;
17504 }
17505 {
17506 resultobj = wxPyMake_wxObject(result, 0);
17507 }
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17515 PyObject *resultobj = 0;
17516 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17517 wxEvtHandler *result = 0 ;
17518 void *argp1 = 0 ;
17519 int res1 = 0 ;
17520 PyObject *swig_obj[1] ;
17521
17522 if (!args) SWIG_fail;
17523 swig_obj[0] = args;
17524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17525 if (!SWIG_IsOK(res1)) {
17526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17527 }
17528 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17529 {
17530 PyThreadState* __tstate = wxPyBeginAllowThreads();
17531 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17532 wxPyEndAllowThreads(__tstate);
17533 if (PyErr_Occurred()) SWIG_fail;
17534 }
17535 {
17536 resultobj = wxPyMake_wxObject(result, 0);
17537 }
17538 return resultobj;
17539 fail:
17540 return NULL;
17541 }
17542
17543
17544 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17545 PyObject *resultobj = 0;
17546 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17547 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17548 void *argp1 = 0 ;
17549 int res1 = 0 ;
17550 void *argp2 = 0 ;
17551 int res2 = 0 ;
17552 PyObject * obj0 = 0 ;
17553 PyObject * obj1 = 0 ;
17554 char * kwnames[] = {
17555 (char *) "self",(char *) "handler", NULL
17556 };
17557
17558 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17559 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17560 if (!SWIG_IsOK(res1)) {
17561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17562 }
17563 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17564 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17565 if (!SWIG_IsOK(res2)) {
17566 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17567 }
17568 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17569 {
17570 PyThreadState* __tstate = wxPyBeginAllowThreads();
17571 (arg1)->SetNextHandler(arg2);
17572 wxPyEndAllowThreads(__tstate);
17573 if (PyErr_Occurred()) SWIG_fail;
17574 }
17575 resultobj = SWIG_Py_Void();
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj = 0;
17584 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17585 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17586 void *argp1 = 0 ;
17587 int res1 = 0 ;
17588 void *argp2 = 0 ;
17589 int res2 = 0 ;
17590 PyObject * obj0 = 0 ;
17591 PyObject * obj1 = 0 ;
17592 char * kwnames[] = {
17593 (char *) "self",(char *) "handler", NULL
17594 };
17595
17596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17598 if (!SWIG_IsOK(res1)) {
17599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17600 }
17601 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17603 if (!SWIG_IsOK(res2)) {
17604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17605 }
17606 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 (arg1)->SetPreviousHandler(arg2);
17610 wxPyEndAllowThreads(__tstate);
17611 if (PyErr_Occurred()) SWIG_fail;
17612 }
17613 resultobj = SWIG_Py_Void();
17614 return resultobj;
17615 fail:
17616 return NULL;
17617 }
17618
17619
17620 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17621 PyObject *resultobj = 0;
17622 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17623 bool result;
17624 void *argp1 = 0 ;
17625 int res1 = 0 ;
17626 PyObject *swig_obj[1] ;
17627
17628 if (!args) SWIG_fail;
17629 swig_obj[0] = args;
17630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17631 if (!SWIG_IsOK(res1)) {
17632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17633 }
17634 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17635 {
17636 PyThreadState* __tstate = wxPyBeginAllowThreads();
17637 result = (bool)(arg1)->GetEvtHandlerEnabled();
17638 wxPyEndAllowThreads(__tstate);
17639 if (PyErr_Occurred()) SWIG_fail;
17640 }
17641 {
17642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17643 }
17644 return resultobj;
17645 fail:
17646 return NULL;
17647 }
17648
17649
17650 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17651 PyObject *resultobj = 0;
17652 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17653 bool arg2 ;
17654 void *argp1 = 0 ;
17655 int res1 = 0 ;
17656 bool val2 ;
17657 int ecode2 = 0 ;
17658 PyObject * obj0 = 0 ;
17659 PyObject * obj1 = 0 ;
17660 char * kwnames[] = {
17661 (char *) "self",(char *) "enabled", NULL
17662 };
17663
17664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17666 if (!SWIG_IsOK(res1)) {
17667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17668 }
17669 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17671 if (!SWIG_IsOK(ecode2)) {
17672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17673 }
17674 arg2 = static_cast< bool >(val2);
17675 {
17676 PyThreadState* __tstate = wxPyBeginAllowThreads();
17677 (arg1)->SetEvtHandlerEnabled(arg2);
17678 wxPyEndAllowThreads(__tstate);
17679 if (PyErr_Occurred()) SWIG_fail;
17680 }
17681 resultobj = SWIG_Py_Void();
17682 return resultobj;
17683 fail:
17684 return NULL;
17685 }
17686
17687
17688 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17689 PyObject *resultobj = 0;
17690 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17691 wxEvent *arg2 = 0 ;
17692 bool result;
17693 void *argp1 = 0 ;
17694 int res1 = 0 ;
17695 void *argp2 = 0 ;
17696 int res2 = 0 ;
17697 PyObject * obj0 = 0 ;
17698 PyObject * obj1 = 0 ;
17699 char * kwnames[] = {
17700 (char *) "self",(char *) "event", NULL
17701 };
17702
17703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17705 if (!SWIG_IsOK(res1)) {
17706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17707 }
17708 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17709 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17710 if (!SWIG_IsOK(res2)) {
17711 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17712 }
17713 if (!argp2) {
17714 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17715 }
17716 arg2 = reinterpret_cast< wxEvent * >(argp2);
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 result = (bool)(arg1)->ProcessEvent(*arg2);
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 {
17724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17725 }
17726 return resultobj;
17727 fail:
17728 return NULL;
17729 }
17730
17731
17732 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17733 PyObject *resultobj = 0;
17734 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17735 wxEvent *arg2 = 0 ;
17736 void *argp1 = 0 ;
17737 int res1 = 0 ;
17738 void *argp2 = 0 ;
17739 int res2 = 0 ;
17740 PyObject * obj0 = 0 ;
17741 PyObject * obj1 = 0 ;
17742 char * kwnames[] = {
17743 (char *) "self",(char *) "event", NULL
17744 };
17745
17746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17748 if (!SWIG_IsOK(res1)) {
17749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17750 }
17751 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17752 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17753 if (!SWIG_IsOK(res2)) {
17754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17755 }
17756 if (!argp2) {
17757 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17758 }
17759 arg2 = reinterpret_cast< wxEvent * >(argp2);
17760 {
17761 PyThreadState* __tstate = wxPyBeginAllowThreads();
17762 (arg1)->AddPendingEvent(*arg2);
17763 wxPyEndAllowThreads(__tstate);
17764 if (PyErr_Occurred()) SWIG_fail;
17765 }
17766 resultobj = SWIG_Py_Void();
17767 return resultobj;
17768 fail:
17769 return NULL;
17770 }
17771
17772
17773 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17774 PyObject *resultobj = 0;
17775 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17776 void *argp1 = 0 ;
17777 int res1 = 0 ;
17778 PyObject *swig_obj[1] ;
17779
17780 if (!args) SWIG_fail;
17781 swig_obj[0] = args;
17782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17783 if (!SWIG_IsOK(res1)) {
17784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17785 }
17786 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17787 {
17788 PyThreadState* __tstate = wxPyBeginAllowThreads();
17789 (arg1)->ProcessPendingEvents();
17790 wxPyEndAllowThreads(__tstate);
17791 if (PyErr_Occurred()) SWIG_fail;
17792 }
17793 resultobj = SWIG_Py_Void();
17794 return resultobj;
17795 fail:
17796 return NULL;
17797 }
17798
17799
17800 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17801 PyObject *resultobj = 0;
17802 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17803 int arg2 ;
17804 int arg3 ;
17805 int arg4 ;
17806 PyObject *arg5 = (PyObject *) 0 ;
17807 void *argp1 = 0 ;
17808 int res1 = 0 ;
17809 int val2 ;
17810 int ecode2 = 0 ;
17811 int val3 ;
17812 int ecode3 = 0 ;
17813 int val4 ;
17814 int ecode4 = 0 ;
17815 PyObject * obj0 = 0 ;
17816 PyObject * obj1 = 0 ;
17817 PyObject * obj2 = 0 ;
17818 PyObject * obj3 = 0 ;
17819 PyObject * obj4 = 0 ;
17820 char * kwnames[] = {
17821 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17822 };
17823
17824 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17825 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17826 if (!SWIG_IsOK(res1)) {
17827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17828 }
17829 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17830 ecode2 = SWIG_AsVal_int(obj1, &val2);
17831 if (!SWIG_IsOK(ecode2)) {
17832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17833 }
17834 arg2 = static_cast< int >(val2);
17835 ecode3 = SWIG_AsVal_int(obj2, &val3);
17836 if (!SWIG_IsOK(ecode3)) {
17837 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17838 }
17839 arg3 = static_cast< int >(val3);
17840 ecode4 = SWIG_AsVal_int(obj3, &val4);
17841 if (!SWIG_IsOK(ecode4)) {
17842 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17843 }
17844 arg4 = static_cast< int >(val4);
17845 arg5 = obj4;
17846 {
17847 PyThreadState* __tstate = wxPyBeginAllowThreads();
17848 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17849 wxPyEndAllowThreads(__tstate);
17850 if (PyErr_Occurred()) SWIG_fail;
17851 }
17852 resultobj = SWIG_Py_Void();
17853 return resultobj;
17854 fail:
17855 return NULL;
17856 }
17857
17858
17859 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17860 PyObject *resultobj = 0;
17861 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17862 int arg2 ;
17863 int arg3 = (int) -1 ;
17864 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17865 bool result;
17866 void *argp1 = 0 ;
17867 int res1 = 0 ;
17868 int val2 ;
17869 int ecode2 = 0 ;
17870 int val3 ;
17871 int ecode3 = 0 ;
17872 int val4 ;
17873 int ecode4 = 0 ;
17874 PyObject * obj0 = 0 ;
17875 PyObject * obj1 = 0 ;
17876 PyObject * obj2 = 0 ;
17877 PyObject * obj3 = 0 ;
17878 char * kwnames[] = {
17879 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17880 };
17881
17882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17884 if (!SWIG_IsOK(res1)) {
17885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17886 }
17887 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17888 ecode2 = SWIG_AsVal_int(obj1, &val2);
17889 if (!SWIG_IsOK(ecode2)) {
17890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
17891 }
17892 arg2 = static_cast< int >(val2);
17893 if (obj2) {
17894 ecode3 = SWIG_AsVal_int(obj2, &val3);
17895 if (!SWIG_IsOK(ecode3)) {
17896 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
17897 }
17898 arg3 = static_cast< int >(val3);
17899 }
17900 if (obj3) {
17901 ecode4 = SWIG_AsVal_int(obj3, &val4);
17902 if (!SWIG_IsOK(ecode4)) {
17903 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
17904 }
17905 arg4 = static_cast< wxEventType >(val4);
17906 }
17907 {
17908 PyThreadState* __tstate = wxPyBeginAllowThreads();
17909 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
17910 wxPyEndAllowThreads(__tstate);
17911 if (PyErr_Occurred()) SWIG_fail;
17912 }
17913 {
17914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17915 }
17916 return resultobj;
17917 fail:
17918 return NULL;
17919 }
17920
17921
17922 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17923 PyObject *resultobj = 0;
17924 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17925 PyObject *arg2 = (PyObject *) 0 ;
17926 bool arg3 = (bool) true ;
17927 void *argp1 = 0 ;
17928 int res1 = 0 ;
17929 bool val3 ;
17930 int ecode3 = 0 ;
17931 PyObject * obj0 = 0 ;
17932 PyObject * obj1 = 0 ;
17933 PyObject * obj2 = 0 ;
17934 char * kwnames[] = {
17935 (char *) "self",(char *) "_self",(char *) "incref", NULL
17936 };
17937
17938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17940 if (!SWIG_IsOK(res1)) {
17941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17942 }
17943 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17944 arg2 = obj1;
17945 if (obj2) {
17946 ecode3 = SWIG_AsVal_bool(obj2, &val3);
17947 if (!SWIG_IsOK(ecode3)) {
17948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
17949 }
17950 arg3 = static_cast< bool >(val3);
17951 }
17952 {
17953 PyThreadState* __tstate = wxPyBeginAllowThreads();
17954 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
17955 wxPyEndAllowThreads(__tstate);
17956 if (PyErr_Occurred()) SWIG_fail;
17957 }
17958 resultobj = SWIG_Py_Void();
17959 return resultobj;
17960 fail:
17961 return NULL;
17962 }
17963
17964
17965 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17966 PyObject *obj;
17967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17968 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
17969 return SWIG_Py_Void();
17970 }
17971
17972 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17973 return SWIG_Python_InitShadowInstance(args);
17974 }
17975
17976 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17977 PyObject *resultobj = 0;
17978 wxEventType result;
17979
17980 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
17981 {
17982 PyThreadState* __tstate = wxPyBeginAllowThreads();
17983 result = (wxEventType)wxNewEventType();
17984 wxPyEndAllowThreads(__tstate);
17985 if (PyErr_Occurred()) SWIG_fail;
17986 }
17987 resultobj = SWIG_From_int(static_cast< int >(result));
17988 return resultobj;
17989 fail:
17990 return NULL;
17991 }
17992
17993
17994 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17995 PyObject *resultobj = 0;
17996 wxEvent *arg1 = (wxEvent *) 0 ;
17997 void *argp1 = 0 ;
17998 int res1 = 0 ;
17999 PyObject *swig_obj[1] ;
18000
18001 if (!args) SWIG_fail;
18002 swig_obj[0] = args;
18003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18004 if (!SWIG_IsOK(res1)) {
18005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18006 }
18007 arg1 = reinterpret_cast< wxEvent * >(argp1);
18008 {
18009 PyThreadState* __tstate = wxPyBeginAllowThreads();
18010 delete arg1;
18011
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_Py_Void();
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj = 0;
18024 wxEvent *arg1 = (wxEvent *) 0 ;
18025 wxEventType arg2 ;
18026 void *argp1 = 0 ;
18027 int res1 = 0 ;
18028 int val2 ;
18029 int ecode2 = 0 ;
18030 PyObject * obj0 = 0 ;
18031 PyObject * obj1 = 0 ;
18032 char * kwnames[] = {
18033 (char *) "self",(char *) "typ", NULL
18034 };
18035
18036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18038 if (!SWIG_IsOK(res1)) {
18039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18040 }
18041 arg1 = reinterpret_cast< wxEvent * >(argp1);
18042 ecode2 = SWIG_AsVal_int(obj1, &val2);
18043 if (!SWIG_IsOK(ecode2)) {
18044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18045 }
18046 arg2 = static_cast< wxEventType >(val2);
18047 {
18048 PyThreadState* __tstate = wxPyBeginAllowThreads();
18049 (arg1)->SetEventType(arg2);
18050 wxPyEndAllowThreads(__tstate);
18051 if (PyErr_Occurred()) SWIG_fail;
18052 }
18053 resultobj = SWIG_Py_Void();
18054 return resultobj;
18055 fail:
18056 return NULL;
18057 }
18058
18059
18060 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18061 PyObject *resultobj = 0;
18062 wxEvent *arg1 = (wxEvent *) 0 ;
18063 wxEventType result;
18064 void *argp1 = 0 ;
18065 int res1 = 0 ;
18066 PyObject *swig_obj[1] ;
18067
18068 if (!args) SWIG_fail;
18069 swig_obj[0] = args;
18070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18071 if (!SWIG_IsOK(res1)) {
18072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18073 }
18074 arg1 = reinterpret_cast< wxEvent * >(argp1);
18075 {
18076 PyThreadState* __tstate = wxPyBeginAllowThreads();
18077 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18078 wxPyEndAllowThreads(__tstate);
18079 if (PyErr_Occurred()) SWIG_fail;
18080 }
18081 resultobj = SWIG_From_int(static_cast< int >(result));
18082 return resultobj;
18083 fail:
18084 return NULL;
18085 }
18086
18087
18088 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18089 PyObject *resultobj = 0;
18090 wxEvent *arg1 = (wxEvent *) 0 ;
18091 wxObject *result = 0 ;
18092 void *argp1 = 0 ;
18093 int res1 = 0 ;
18094 PyObject *swig_obj[1] ;
18095
18096 if (!args) SWIG_fail;
18097 swig_obj[0] = args;
18098 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18099 if (!SWIG_IsOK(res1)) {
18100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18101 }
18102 arg1 = reinterpret_cast< wxEvent * >(argp1);
18103 {
18104 PyThreadState* __tstate = wxPyBeginAllowThreads();
18105 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18106 wxPyEndAllowThreads(__tstate);
18107 if (PyErr_Occurred()) SWIG_fail;
18108 }
18109 {
18110 resultobj = wxPyMake_wxObject(result, (bool)0);
18111 }
18112 return resultobj;
18113 fail:
18114 return NULL;
18115 }
18116
18117
18118 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj = 0;
18120 wxEvent *arg1 = (wxEvent *) 0 ;
18121 wxObject *arg2 = (wxObject *) 0 ;
18122 void *argp1 = 0 ;
18123 int res1 = 0 ;
18124 void *argp2 = 0 ;
18125 int res2 = 0 ;
18126 PyObject * obj0 = 0 ;
18127 PyObject * obj1 = 0 ;
18128 char * kwnames[] = {
18129 (char *) "self",(char *) "obj", NULL
18130 };
18131
18132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18134 if (!SWIG_IsOK(res1)) {
18135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18136 }
18137 arg1 = reinterpret_cast< wxEvent * >(argp1);
18138 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18139 if (!SWIG_IsOK(res2)) {
18140 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18141 }
18142 arg2 = reinterpret_cast< wxObject * >(argp2);
18143 {
18144 PyThreadState* __tstate = wxPyBeginAllowThreads();
18145 (arg1)->SetEventObject(arg2);
18146 wxPyEndAllowThreads(__tstate);
18147 if (PyErr_Occurred()) SWIG_fail;
18148 }
18149 resultobj = SWIG_Py_Void();
18150 return resultobj;
18151 fail:
18152 return NULL;
18153 }
18154
18155
18156 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18157 PyObject *resultobj = 0;
18158 wxEvent *arg1 = (wxEvent *) 0 ;
18159 long result;
18160 void *argp1 = 0 ;
18161 int res1 = 0 ;
18162 PyObject *swig_obj[1] ;
18163
18164 if (!args) SWIG_fail;
18165 swig_obj[0] = args;
18166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18167 if (!SWIG_IsOK(res1)) {
18168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18169 }
18170 arg1 = reinterpret_cast< wxEvent * >(argp1);
18171 {
18172 PyThreadState* __tstate = wxPyBeginAllowThreads();
18173 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18174 wxPyEndAllowThreads(__tstate);
18175 if (PyErr_Occurred()) SWIG_fail;
18176 }
18177 resultobj = SWIG_From_long(static_cast< long >(result));
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj = 0;
18186 wxEvent *arg1 = (wxEvent *) 0 ;
18187 long arg2 = (long) 0 ;
18188 void *argp1 = 0 ;
18189 int res1 = 0 ;
18190 long val2 ;
18191 int ecode2 = 0 ;
18192 PyObject * obj0 = 0 ;
18193 PyObject * obj1 = 0 ;
18194 char * kwnames[] = {
18195 (char *) "self",(char *) "ts", NULL
18196 };
18197
18198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18200 if (!SWIG_IsOK(res1)) {
18201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18202 }
18203 arg1 = reinterpret_cast< wxEvent * >(argp1);
18204 if (obj1) {
18205 ecode2 = SWIG_AsVal_long(obj1, &val2);
18206 if (!SWIG_IsOK(ecode2)) {
18207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18208 }
18209 arg2 = static_cast< long >(val2);
18210 }
18211 {
18212 PyThreadState* __tstate = wxPyBeginAllowThreads();
18213 (arg1)->SetTimestamp(arg2);
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 resultobj = SWIG_Py_Void();
18218 return resultobj;
18219 fail:
18220 return NULL;
18221 }
18222
18223
18224 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18225 PyObject *resultobj = 0;
18226 wxEvent *arg1 = (wxEvent *) 0 ;
18227 int result;
18228 void *argp1 = 0 ;
18229 int res1 = 0 ;
18230 PyObject *swig_obj[1] ;
18231
18232 if (!args) SWIG_fail;
18233 swig_obj[0] = args;
18234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18235 if (!SWIG_IsOK(res1)) {
18236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18237 }
18238 arg1 = reinterpret_cast< wxEvent * >(argp1);
18239 {
18240 PyThreadState* __tstate = wxPyBeginAllowThreads();
18241 result = (int)((wxEvent const *)arg1)->GetId();
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 resultobj = SWIG_From_int(static_cast< int >(result));
18246 return resultobj;
18247 fail:
18248 return NULL;
18249 }
18250
18251
18252 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18253 PyObject *resultobj = 0;
18254 wxEvent *arg1 = (wxEvent *) 0 ;
18255 int arg2 ;
18256 void *argp1 = 0 ;
18257 int res1 = 0 ;
18258 int val2 ;
18259 int ecode2 = 0 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char * kwnames[] = {
18263 (char *) "self",(char *) "Id", NULL
18264 };
18265
18266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18268 if (!SWIG_IsOK(res1)) {
18269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18270 }
18271 arg1 = reinterpret_cast< wxEvent * >(argp1);
18272 ecode2 = SWIG_AsVal_int(obj1, &val2);
18273 if (!SWIG_IsOK(ecode2)) {
18274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18275 }
18276 arg2 = static_cast< int >(val2);
18277 {
18278 PyThreadState* __tstate = wxPyBeginAllowThreads();
18279 (arg1)->SetId(arg2);
18280 wxPyEndAllowThreads(__tstate);
18281 if (PyErr_Occurred()) SWIG_fail;
18282 }
18283 resultobj = SWIG_Py_Void();
18284 return resultobj;
18285 fail:
18286 return NULL;
18287 }
18288
18289
18290 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18291 PyObject *resultobj = 0;
18292 wxEvent *arg1 = (wxEvent *) 0 ;
18293 bool result;
18294 void *argp1 = 0 ;
18295 int res1 = 0 ;
18296 PyObject *swig_obj[1] ;
18297
18298 if (!args) SWIG_fail;
18299 swig_obj[0] = args;
18300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18301 if (!SWIG_IsOK(res1)) {
18302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18303 }
18304 arg1 = reinterpret_cast< wxEvent * >(argp1);
18305 {
18306 PyThreadState* __tstate = wxPyBeginAllowThreads();
18307 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18308 wxPyEndAllowThreads(__tstate);
18309 if (PyErr_Occurred()) SWIG_fail;
18310 }
18311 {
18312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18313 }
18314 return resultobj;
18315 fail:
18316 return NULL;
18317 }
18318
18319
18320 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18321 PyObject *resultobj = 0;
18322 wxEvent *arg1 = (wxEvent *) 0 ;
18323 bool arg2 = (bool) true ;
18324 void *argp1 = 0 ;
18325 int res1 = 0 ;
18326 bool val2 ;
18327 int ecode2 = 0 ;
18328 PyObject * obj0 = 0 ;
18329 PyObject * obj1 = 0 ;
18330 char * kwnames[] = {
18331 (char *) "self",(char *) "skip", NULL
18332 };
18333
18334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18336 if (!SWIG_IsOK(res1)) {
18337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18338 }
18339 arg1 = reinterpret_cast< wxEvent * >(argp1);
18340 if (obj1) {
18341 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18342 if (!SWIG_IsOK(ecode2)) {
18343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18344 }
18345 arg2 = static_cast< bool >(val2);
18346 }
18347 {
18348 PyThreadState* __tstate = wxPyBeginAllowThreads();
18349 (arg1)->Skip(arg2);
18350 wxPyEndAllowThreads(__tstate);
18351 if (PyErr_Occurred()) SWIG_fail;
18352 }
18353 resultobj = SWIG_Py_Void();
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18361 PyObject *resultobj = 0;
18362 wxEvent *arg1 = (wxEvent *) 0 ;
18363 bool result;
18364 void *argp1 = 0 ;
18365 int res1 = 0 ;
18366 PyObject *swig_obj[1] ;
18367
18368 if (!args) SWIG_fail;
18369 swig_obj[0] = args;
18370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18371 if (!SWIG_IsOK(res1)) {
18372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18373 }
18374 arg1 = reinterpret_cast< wxEvent * >(argp1);
18375 {
18376 PyThreadState* __tstate = wxPyBeginAllowThreads();
18377 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18378 wxPyEndAllowThreads(__tstate);
18379 if (PyErr_Occurred()) SWIG_fail;
18380 }
18381 {
18382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18383 }
18384 return resultobj;
18385 fail:
18386 return NULL;
18387 }
18388
18389
18390 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18391 PyObject *resultobj = 0;
18392 wxEvent *arg1 = (wxEvent *) 0 ;
18393 bool result;
18394 void *argp1 = 0 ;
18395 int res1 = 0 ;
18396 PyObject *swig_obj[1] ;
18397
18398 if (!args) SWIG_fail;
18399 swig_obj[0] = args;
18400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18401 if (!SWIG_IsOK(res1)) {
18402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18403 }
18404 arg1 = reinterpret_cast< wxEvent * >(argp1);
18405 {
18406 PyThreadState* __tstate = wxPyBeginAllowThreads();
18407 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18408 wxPyEndAllowThreads(__tstate);
18409 if (PyErr_Occurred()) SWIG_fail;
18410 }
18411 {
18412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18413 }
18414 return resultobj;
18415 fail:
18416 return NULL;
18417 }
18418
18419
18420 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18421 PyObject *resultobj = 0;
18422 wxEvent *arg1 = (wxEvent *) 0 ;
18423 int result;
18424 void *argp1 = 0 ;
18425 int res1 = 0 ;
18426 PyObject *swig_obj[1] ;
18427
18428 if (!args) SWIG_fail;
18429 swig_obj[0] = args;
18430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18431 if (!SWIG_IsOK(res1)) {
18432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18433 }
18434 arg1 = reinterpret_cast< wxEvent * >(argp1);
18435 {
18436 PyThreadState* __tstate = wxPyBeginAllowThreads();
18437 result = (int)(arg1)->StopPropagation();
18438 wxPyEndAllowThreads(__tstate);
18439 if (PyErr_Occurred()) SWIG_fail;
18440 }
18441 resultobj = SWIG_From_int(static_cast< int >(result));
18442 return resultobj;
18443 fail:
18444 return NULL;
18445 }
18446
18447
18448 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18449 PyObject *resultobj = 0;
18450 wxEvent *arg1 = (wxEvent *) 0 ;
18451 int arg2 ;
18452 void *argp1 = 0 ;
18453 int res1 = 0 ;
18454 int val2 ;
18455 int ecode2 = 0 ;
18456 PyObject * obj0 = 0 ;
18457 PyObject * obj1 = 0 ;
18458 char * kwnames[] = {
18459 (char *) "self",(char *) "propagationLevel", NULL
18460 };
18461
18462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18464 if (!SWIG_IsOK(res1)) {
18465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18466 }
18467 arg1 = reinterpret_cast< wxEvent * >(argp1);
18468 ecode2 = SWIG_AsVal_int(obj1, &val2);
18469 if (!SWIG_IsOK(ecode2)) {
18470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18471 }
18472 arg2 = static_cast< int >(val2);
18473 {
18474 PyThreadState* __tstate = wxPyBeginAllowThreads();
18475 (arg1)->ResumePropagation(arg2);
18476 wxPyEndAllowThreads(__tstate);
18477 if (PyErr_Occurred()) SWIG_fail;
18478 }
18479 resultobj = SWIG_Py_Void();
18480 return resultobj;
18481 fail:
18482 return NULL;
18483 }
18484
18485
18486 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18487 PyObject *resultobj = 0;
18488 wxEvent *arg1 = (wxEvent *) 0 ;
18489 wxEvent *result = 0 ;
18490 void *argp1 = 0 ;
18491 int res1 = 0 ;
18492 PyObject *swig_obj[1] ;
18493
18494 if (!args) SWIG_fail;
18495 swig_obj[0] = args;
18496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18497 if (!SWIG_IsOK(res1)) {
18498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18499 }
18500 arg1 = reinterpret_cast< wxEvent * >(argp1);
18501 {
18502 PyThreadState* __tstate = wxPyBeginAllowThreads();
18503 result = (wxEvent *)(arg1)->Clone();
18504 wxPyEndAllowThreads(__tstate);
18505 if (PyErr_Occurred()) SWIG_fail;
18506 }
18507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18508 return resultobj;
18509 fail:
18510 return NULL;
18511 }
18512
18513
18514 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18515 PyObject *obj;
18516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18517 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18518 return SWIG_Py_Void();
18519 }
18520
18521 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18522 PyObject *resultobj = 0;
18523 wxEvent *arg1 = 0 ;
18524 wxPropagationDisabler *result = 0 ;
18525 void *argp1 = 0 ;
18526 int res1 = 0 ;
18527 PyObject * obj0 = 0 ;
18528 char * kwnames[] = {
18529 (char *) "event", NULL
18530 };
18531
18532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18533 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18534 if (!SWIG_IsOK(res1)) {
18535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18536 }
18537 if (!argp1) {
18538 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18539 }
18540 arg1 = reinterpret_cast< wxEvent * >(argp1);
18541 {
18542 PyThreadState* __tstate = wxPyBeginAllowThreads();
18543 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18544 wxPyEndAllowThreads(__tstate);
18545 if (PyErr_Occurred()) SWIG_fail;
18546 }
18547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18548 return resultobj;
18549 fail:
18550 return NULL;
18551 }
18552
18553
18554 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18555 PyObject *resultobj = 0;
18556 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18557 void *argp1 = 0 ;
18558 int res1 = 0 ;
18559 PyObject *swig_obj[1] ;
18560
18561 if (!args) SWIG_fail;
18562 swig_obj[0] = args;
18563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18564 if (!SWIG_IsOK(res1)) {
18565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18566 }
18567 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18568 {
18569 PyThreadState* __tstate = wxPyBeginAllowThreads();
18570 delete arg1;
18571
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 resultobj = SWIG_Py_Void();
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18583 PyObject *obj;
18584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18585 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18586 return SWIG_Py_Void();
18587 }
18588
18589 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18590 return SWIG_Python_InitShadowInstance(args);
18591 }
18592
18593 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18594 PyObject *resultobj = 0;
18595 wxEvent *arg1 = 0 ;
18596 wxPropagateOnce *result = 0 ;
18597 void *argp1 = 0 ;
18598 int res1 = 0 ;
18599 PyObject * obj0 = 0 ;
18600 char * kwnames[] = {
18601 (char *) "event", NULL
18602 };
18603
18604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18605 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18606 if (!SWIG_IsOK(res1)) {
18607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18608 }
18609 if (!argp1) {
18610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18611 }
18612 arg1 = reinterpret_cast< wxEvent * >(argp1);
18613 {
18614 PyThreadState* __tstate = wxPyBeginAllowThreads();
18615 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18616 wxPyEndAllowThreads(__tstate);
18617 if (PyErr_Occurred()) SWIG_fail;
18618 }
18619 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18620 return resultobj;
18621 fail:
18622 return NULL;
18623 }
18624
18625
18626 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18627 PyObject *resultobj = 0;
18628 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18629 void *argp1 = 0 ;
18630 int res1 = 0 ;
18631 PyObject *swig_obj[1] ;
18632
18633 if (!args) SWIG_fail;
18634 swig_obj[0] = args;
18635 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18638 }
18639 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18640 {
18641 PyThreadState* __tstate = wxPyBeginAllowThreads();
18642 delete arg1;
18643
18644 wxPyEndAllowThreads(__tstate);
18645 if (PyErr_Occurred()) SWIG_fail;
18646 }
18647 resultobj = SWIG_Py_Void();
18648 return resultobj;
18649 fail:
18650 return NULL;
18651 }
18652
18653
18654 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18655 PyObject *obj;
18656 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18657 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18658 return SWIG_Py_Void();
18659 }
18660
18661 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18662 return SWIG_Python_InitShadowInstance(args);
18663 }
18664
18665 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18666 PyObject *resultobj = 0;
18667 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18668 int arg2 = (int) 0 ;
18669 wxCommandEvent *result = 0 ;
18670 int val1 ;
18671 int ecode1 = 0 ;
18672 int val2 ;
18673 int ecode2 = 0 ;
18674 PyObject * obj0 = 0 ;
18675 PyObject * obj1 = 0 ;
18676 char * kwnames[] = {
18677 (char *) "commandType",(char *) "winid", NULL
18678 };
18679
18680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18681 if (obj0) {
18682 ecode1 = SWIG_AsVal_int(obj0, &val1);
18683 if (!SWIG_IsOK(ecode1)) {
18684 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18685 }
18686 arg1 = static_cast< wxEventType >(val1);
18687 }
18688 if (obj1) {
18689 ecode2 = SWIG_AsVal_int(obj1, &val2);
18690 if (!SWIG_IsOK(ecode2)) {
18691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18692 }
18693 arg2 = static_cast< int >(val2);
18694 }
18695 {
18696 PyThreadState* __tstate = wxPyBeginAllowThreads();
18697 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18709 PyObject *resultobj = 0;
18710 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18711 int result;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18721 }
18722 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 resultobj = SWIG_From_int(static_cast< int >(result));
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18737 PyObject *resultobj = 0;
18738 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18739 wxString *arg2 = 0 ;
18740 void *argp1 = 0 ;
18741 int res1 = 0 ;
18742 bool temp2 = false ;
18743 PyObject * obj0 = 0 ;
18744 PyObject * obj1 = 0 ;
18745 char * kwnames[] = {
18746 (char *) "self",(char *) "s", NULL
18747 };
18748
18749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18751 if (!SWIG_IsOK(res1)) {
18752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18753 }
18754 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18755 {
18756 arg2 = wxString_in_helper(obj1);
18757 if (arg2 == NULL) SWIG_fail;
18758 temp2 = true;
18759 }
18760 {
18761 PyThreadState* __tstate = wxPyBeginAllowThreads();
18762 (arg1)->SetString((wxString const &)*arg2);
18763 wxPyEndAllowThreads(__tstate);
18764 if (PyErr_Occurred()) SWIG_fail;
18765 }
18766 resultobj = SWIG_Py_Void();
18767 {
18768 if (temp2)
18769 delete arg2;
18770 }
18771 return resultobj;
18772 fail:
18773 {
18774 if (temp2)
18775 delete arg2;
18776 }
18777 return NULL;
18778 }
18779
18780
18781 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18782 PyObject *resultobj = 0;
18783 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18784 wxString result;
18785 void *argp1 = 0 ;
18786 int res1 = 0 ;
18787 PyObject *swig_obj[1] ;
18788
18789 if (!args) SWIG_fail;
18790 swig_obj[0] = args;
18791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18792 if (!SWIG_IsOK(res1)) {
18793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18794 }
18795 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18796 {
18797 PyThreadState* __tstate = wxPyBeginAllowThreads();
18798 result = ((wxCommandEvent const *)arg1)->GetString();
18799 wxPyEndAllowThreads(__tstate);
18800 if (PyErr_Occurred()) SWIG_fail;
18801 }
18802 {
18803 #if wxUSE_UNICODE
18804 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18805 #else
18806 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18807 #endif
18808 }
18809 return resultobj;
18810 fail:
18811 return NULL;
18812 }
18813
18814
18815 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18816 PyObject *resultobj = 0;
18817 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18818 bool result;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject *swig_obj[1] ;
18822
18823 if (!args) SWIG_fail;
18824 swig_obj[0] = args;
18825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18826 if (!SWIG_IsOK(res1)) {
18827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18828 }
18829 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18830 {
18831 PyThreadState* __tstate = wxPyBeginAllowThreads();
18832 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18833 wxPyEndAllowThreads(__tstate);
18834 if (PyErr_Occurred()) SWIG_fail;
18835 }
18836 {
18837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18838 }
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18846 PyObject *resultobj = 0;
18847 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18848 bool result;
18849 void *argp1 = 0 ;
18850 int res1 = 0 ;
18851 PyObject *swig_obj[1] ;
18852
18853 if (!args) SWIG_fail;
18854 swig_obj[0] = args;
18855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18856 if (!SWIG_IsOK(res1)) {
18857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18858 }
18859 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18860 {
18861 PyThreadState* __tstate = wxPyBeginAllowThreads();
18862 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18863 wxPyEndAllowThreads(__tstate);
18864 if (PyErr_Occurred()) SWIG_fail;
18865 }
18866 {
18867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18868 }
18869 return resultobj;
18870 fail:
18871 return NULL;
18872 }
18873
18874
18875 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18876 PyObject *resultobj = 0;
18877 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18878 long arg2 ;
18879 void *argp1 = 0 ;
18880 int res1 = 0 ;
18881 long val2 ;
18882 int ecode2 = 0 ;
18883 PyObject * obj0 = 0 ;
18884 PyObject * obj1 = 0 ;
18885 char * kwnames[] = {
18886 (char *) "self",(char *) "extraLong", NULL
18887 };
18888
18889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
18890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18891 if (!SWIG_IsOK(res1)) {
18892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18893 }
18894 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18895 ecode2 = SWIG_AsVal_long(obj1, &val2);
18896 if (!SWIG_IsOK(ecode2)) {
18897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
18898 }
18899 arg2 = static_cast< long >(val2);
18900 {
18901 PyThreadState* __tstate = wxPyBeginAllowThreads();
18902 (arg1)->SetExtraLong(arg2);
18903 wxPyEndAllowThreads(__tstate);
18904 if (PyErr_Occurred()) SWIG_fail;
18905 }
18906 resultobj = SWIG_Py_Void();
18907 return resultobj;
18908 fail:
18909 return NULL;
18910 }
18911
18912
18913 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18914 PyObject *resultobj = 0;
18915 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18916 long result;
18917 void *argp1 = 0 ;
18918 int res1 = 0 ;
18919 PyObject *swig_obj[1] ;
18920
18921 if (!args) SWIG_fail;
18922 swig_obj[0] = args;
18923 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18924 if (!SWIG_IsOK(res1)) {
18925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18926 }
18927 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18928 {
18929 PyThreadState* __tstate = wxPyBeginAllowThreads();
18930 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
18931 wxPyEndAllowThreads(__tstate);
18932 if (PyErr_Occurred()) SWIG_fail;
18933 }
18934 resultobj = SWIG_From_long(static_cast< long >(result));
18935 return resultobj;
18936 fail:
18937 return NULL;
18938 }
18939
18940
18941 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18942 PyObject *resultobj = 0;
18943 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18944 int arg2 ;
18945 void *argp1 = 0 ;
18946 int res1 = 0 ;
18947 int val2 ;
18948 int ecode2 = 0 ;
18949 PyObject * obj0 = 0 ;
18950 PyObject * obj1 = 0 ;
18951 char * kwnames[] = {
18952 (char *) "self",(char *) "i", NULL
18953 };
18954
18955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
18956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18957 if (!SWIG_IsOK(res1)) {
18958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18959 }
18960 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18961 ecode2 = SWIG_AsVal_int(obj1, &val2);
18962 if (!SWIG_IsOK(ecode2)) {
18963 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
18964 }
18965 arg2 = static_cast< int >(val2);
18966 {
18967 PyThreadState* __tstate = wxPyBeginAllowThreads();
18968 (arg1)->SetInt(arg2);
18969 wxPyEndAllowThreads(__tstate);
18970 if (PyErr_Occurred()) SWIG_fail;
18971 }
18972 resultobj = SWIG_Py_Void();
18973 return resultobj;
18974 fail:
18975 return NULL;
18976 }
18977
18978
18979 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18980 PyObject *resultobj = 0;
18981 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18982 long result;
18983 void *argp1 = 0 ;
18984 int res1 = 0 ;
18985 PyObject *swig_obj[1] ;
18986
18987 if (!args) SWIG_fail;
18988 swig_obj[0] = args;
18989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18990 if (!SWIG_IsOK(res1)) {
18991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18992 }
18993 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18994 {
18995 PyThreadState* __tstate = wxPyBeginAllowThreads();
18996 result = (long)((wxCommandEvent const *)arg1)->GetInt();
18997 wxPyEndAllowThreads(__tstate);
18998 if (PyErr_Occurred()) SWIG_fail;
18999 }
19000 resultobj = SWIG_From_long(static_cast< long >(result));
19001 return resultobj;
19002 fail:
19003 return NULL;
19004 }
19005
19006
19007 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19008 PyObject *resultobj = 0;
19009 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19010 PyObject *result = 0 ;
19011 void *argp1 = 0 ;
19012 int res1 = 0 ;
19013 PyObject *swig_obj[1] ;
19014
19015 if (!args) SWIG_fail;
19016 swig_obj[0] = args;
19017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19018 if (!SWIG_IsOK(res1)) {
19019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19020 }
19021 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19022 {
19023 PyThreadState* __tstate = wxPyBeginAllowThreads();
19024 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19025 wxPyEndAllowThreads(__tstate);
19026 if (PyErr_Occurred()) SWIG_fail;
19027 }
19028 resultobj = result;
19029 return resultobj;
19030 fail:
19031 return NULL;
19032 }
19033
19034
19035 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19036 PyObject *resultobj = 0;
19037 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19038 PyObject *arg2 = (PyObject *) 0 ;
19039 void *argp1 = 0 ;
19040 int res1 = 0 ;
19041 PyObject * obj0 = 0 ;
19042 PyObject * obj1 = 0 ;
19043 char * kwnames[] = {
19044 (char *) "self",(char *) "clientData", NULL
19045 };
19046
19047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19049 if (!SWIG_IsOK(res1)) {
19050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19051 }
19052 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19053 arg2 = obj1;
19054 {
19055 PyThreadState* __tstate = wxPyBeginAllowThreads();
19056 wxCommandEvent_SetClientData(arg1,arg2);
19057 wxPyEndAllowThreads(__tstate);
19058 if (PyErr_Occurred()) SWIG_fail;
19059 }
19060 resultobj = SWIG_Py_Void();
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19068 PyObject *resultobj = 0;
19069 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19070 wxEvent *result = 0 ;
19071 void *argp1 = 0 ;
19072 int res1 = 0 ;
19073 PyObject *swig_obj[1] ;
19074
19075 if (!args) SWIG_fail;
19076 swig_obj[0] = args;
19077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19078 if (!SWIG_IsOK(res1)) {
19079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19080 }
19081 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19089 return resultobj;
19090 fail:
19091 return NULL;
19092 }
19093
19094
19095 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19096 PyObject *obj;
19097 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19098 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19099 return SWIG_Py_Void();
19100 }
19101
19102 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19103 return SWIG_Python_InitShadowInstance(args);
19104 }
19105
19106 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19107 PyObject *resultobj = 0;
19108 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19109 int arg2 = (int) 0 ;
19110 wxNotifyEvent *result = 0 ;
19111 int val1 ;
19112 int ecode1 = 0 ;
19113 int val2 ;
19114 int ecode2 = 0 ;
19115 PyObject * obj0 = 0 ;
19116 PyObject * obj1 = 0 ;
19117 char * kwnames[] = {
19118 (char *) "commandType",(char *) "winid", NULL
19119 };
19120
19121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19122 if (obj0) {
19123 ecode1 = SWIG_AsVal_int(obj0, &val1);
19124 if (!SWIG_IsOK(ecode1)) {
19125 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19126 }
19127 arg1 = static_cast< wxEventType >(val1);
19128 }
19129 if (obj1) {
19130 ecode2 = SWIG_AsVal_int(obj1, &val2);
19131 if (!SWIG_IsOK(ecode2)) {
19132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19133 }
19134 arg2 = static_cast< int >(val2);
19135 }
19136 {
19137 PyThreadState* __tstate = wxPyBeginAllowThreads();
19138 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19139 wxPyEndAllowThreads(__tstate);
19140 if (PyErr_Occurred()) SWIG_fail;
19141 }
19142 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19150 PyObject *resultobj = 0;
19151 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19152 void *argp1 = 0 ;
19153 int res1 = 0 ;
19154 PyObject *swig_obj[1] ;
19155
19156 if (!args) SWIG_fail;
19157 swig_obj[0] = args;
19158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19159 if (!SWIG_IsOK(res1)) {
19160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19161 }
19162 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19163 {
19164 PyThreadState* __tstate = wxPyBeginAllowThreads();
19165 (arg1)->Veto();
19166 wxPyEndAllowThreads(__tstate);
19167 if (PyErr_Occurred()) SWIG_fail;
19168 }
19169 resultobj = SWIG_Py_Void();
19170 return resultobj;
19171 fail:
19172 return NULL;
19173 }
19174
19175
19176 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19177 PyObject *resultobj = 0;
19178 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19179 void *argp1 = 0 ;
19180 int res1 = 0 ;
19181 PyObject *swig_obj[1] ;
19182
19183 if (!args) SWIG_fail;
19184 swig_obj[0] = args;
19185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19186 if (!SWIG_IsOK(res1)) {
19187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19188 }
19189 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 (arg1)->Allow();
19193 wxPyEndAllowThreads(__tstate);
19194 if (PyErr_Occurred()) SWIG_fail;
19195 }
19196 resultobj = SWIG_Py_Void();
19197 return resultobj;
19198 fail:
19199 return NULL;
19200 }
19201
19202
19203 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19204 PyObject *resultobj = 0;
19205 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19206 bool result;
19207 void *argp1 = 0 ;
19208 int res1 = 0 ;
19209 PyObject *swig_obj[1] ;
19210
19211 if (!args) SWIG_fail;
19212 swig_obj[0] = args;
19213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19214 if (!SWIG_IsOK(res1)) {
19215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19216 }
19217 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19218 {
19219 PyThreadState* __tstate = wxPyBeginAllowThreads();
19220 result = (bool)(arg1)->IsAllowed();
19221 wxPyEndAllowThreads(__tstate);
19222 if (PyErr_Occurred()) SWIG_fail;
19223 }
19224 {
19225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19226 }
19227 return resultobj;
19228 fail:
19229 return NULL;
19230 }
19231
19232
19233 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19234 PyObject *obj;
19235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19236 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19237 return SWIG_Py_Void();
19238 }
19239
19240 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19241 return SWIG_Python_InitShadowInstance(args);
19242 }
19243
19244 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj = 0;
19246 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19247 int arg2 = (int) 0 ;
19248 int arg3 = (int) 0 ;
19249 int arg4 = (int) 0 ;
19250 wxScrollEvent *result = 0 ;
19251 int val1 ;
19252 int ecode1 = 0 ;
19253 int val2 ;
19254 int ecode2 = 0 ;
19255 int val3 ;
19256 int ecode3 = 0 ;
19257 int val4 ;
19258 int ecode4 = 0 ;
19259 PyObject * obj0 = 0 ;
19260 PyObject * obj1 = 0 ;
19261 PyObject * obj2 = 0 ;
19262 PyObject * obj3 = 0 ;
19263 char * kwnames[] = {
19264 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19265 };
19266
19267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19268 if (obj0) {
19269 ecode1 = SWIG_AsVal_int(obj0, &val1);
19270 if (!SWIG_IsOK(ecode1)) {
19271 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19272 }
19273 arg1 = static_cast< wxEventType >(val1);
19274 }
19275 if (obj1) {
19276 ecode2 = SWIG_AsVal_int(obj1, &val2);
19277 if (!SWIG_IsOK(ecode2)) {
19278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19279 }
19280 arg2 = static_cast< int >(val2);
19281 }
19282 if (obj2) {
19283 ecode3 = SWIG_AsVal_int(obj2, &val3);
19284 if (!SWIG_IsOK(ecode3)) {
19285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19286 }
19287 arg3 = static_cast< int >(val3);
19288 }
19289 if (obj3) {
19290 ecode4 = SWIG_AsVal_int(obj3, &val4);
19291 if (!SWIG_IsOK(ecode4)) {
19292 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19293 }
19294 arg4 = static_cast< int >(val4);
19295 }
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19299 wxPyEndAllowThreads(__tstate);
19300 if (PyErr_Occurred()) SWIG_fail;
19301 }
19302 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19303 return resultobj;
19304 fail:
19305 return NULL;
19306 }
19307
19308
19309 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19310 PyObject *resultobj = 0;
19311 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19312 int result;
19313 void *argp1 = 0 ;
19314 int res1 = 0 ;
19315 PyObject *swig_obj[1] ;
19316
19317 if (!args) SWIG_fail;
19318 swig_obj[0] = args;
19319 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19320 if (!SWIG_IsOK(res1)) {
19321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19322 }
19323 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19324 {
19325 PyThreadState* __tstate = wxPyBeginAllowThreads();
19326 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19327 wxPyEndAllowThreads(__tstate);
19328 if (PyErr_Occurred()) SWIG_fail;
19329 }
19330 resultobj = SWIG_From_int(static_cast< int >(result));
19331 return resultobj;
19332 fail:
19333 return NULL;
19334 }
19335
19336
19337 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19338 PyObject *resultobj = 0;
19339 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19340 int result;
19341 void *argp1 = 0 ;
19342 int res1 = 0 ;
19343 PyObject *swig_obj[1] ;
19344
19345 if (!args) SWIG_fail;
19346 swig_obj[0] = args;
19347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19348 if (!SWIG_IsOK(res1)) {
19349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19350 }
19351 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19352 {
19353 PyThreadState* __tstate = wxPyBeginAllowThreads();
19354 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19355 wxPyEndAllowThreads(__tstate);
19356 if (PyErr_Occurred()) SWIG_fail;
19357 }
19358 resultobj = SWIG_From_int(static_cast< int >(result));
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj = 0;
19367 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19368 int arg2 ;
19369 void *argp1 = 0 ;
19370 int res1 = 0 ;
19371 int val2 ;
19372 int ecode2 = 0 ;
19373 PyObject * obj0 = 0 ;
19374 PyObject * obj1 = 0 ;
19375 char * kwnames[] = {
19376 (char *) "self",(char *) "orient", NULL
19377 };
19378
19379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19381 if (!SWIG_IsOK(res1)) {
19382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19383 }
19384 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19385 ecode2 = SWIG_AsVal_int(obj1, &val2);
19386 if (!SWIG_IsOK(ecode2)) {
19387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19388 }
19389 arg2 = static_cast< int >(val2);
19390 {
19391 PyThreadState* __tstate = wxPyBeginAllowThreads();
19392 (arg1)->SetOrientation(arg2);
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_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19404 PyObject *resultobj = 0;
19405 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19406 int arg2 ;
19407 void *argp1 = 0 ;
19408 int res1 = 0 ;
19409 int val2 ;
19410 int ecode2 = 0 ;
19411 PyObject * obj0 = 0 ;
19412 PyObject * obj1 = 0 ;
19413 char * kwnames[] = {
19414 (char *) "self",(char *) "pos", NULL
19415 };
19416
19417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19419 if (!SWIG_IsOK(res1)) {
19420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19421 }
19422 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19423 ecode2 = SWIG_AsVal_int(obj1, &val2);
19424 if (!SWIG_IsOK(ecode2)) {
19425 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19426 }
19427 arg2 = static_cast< int >(val2);
19428 {
19429 PyThreadState* __tstate = wxPyBeginAllowThreads();
19430 (arg1)->SetPosition(arg2);
19431 wxPyEndAllowThreads(__tstate);
19432 if (PyErr_Occurred()) SWIG_fail;
19433 }
19434 resultobj = SWIG_Py_Void();
19435 return resultobj;
19436 fail:
19437 return NULL;
19438 }
19439
19440
19441 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19442 PyObject *obj;
19443 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19444 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19445 return SWIG_Py_Void();
19446 }
19447
19448 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19449 return SWIG_Python_InitShadowInstance(args);
19450 }
19451
19452 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19453 PyObject *resultobj = 0;
19454 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19455 int arg2 = (int) 0 ;
19456 int arg3 = (int) 0 ;
19457 wxScrollWinEvent *result = 0 ;
19458 int val1 ;
19459 int ecode1 = 0 ;
19460 int val2 ;
19461 int ecode2 = 0 ;
19462 int val3 ;
19463 int ecode3 = 0 ;
19464 PyObject * obj0 = 0 ;
19465 PyObject * obj1 = 0 ;
19466 PyObject * obj2 = 0 ;
19467 char * kwnames[] = {
19468 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19469 };
19470
19471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19472 if (obj0) {
19473 ecode1 = SWIG_AsVal_int(obj0, &val1);
19474 if (!SWIG_IsOK(ecode1)) {
19475 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19476 }
19477 arg1 = static_cast< wxEventType >(val1);
19478 }
19479 if (obj1) {
19480 ecode2 = SWIG_AsVal_int(obj1, &val2);
19481 if (!SWIG_IsOK(ecode2)) {
19482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19483 }
19484 arg2 = static_cast< int >(val2);
19485 }
19486 if (obj2) {
19487 ecode3 = SWIG_AsVal_int(obj2, &val3);
19488 if (!SWIG_IsOK(ecode3)) {
19489 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19490 }
19491 arg3 = static_cast< int >(val3);
19492 }
19493 {
19494 PyThreadState* __tstate = wxPyBeginAllowThreads();
19495 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19496 wxPyEndAllowThreads(__tstate);
19497 if (PyErr_Occurred()) SWIG_fail;
19498 }
19499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19500 return resultobj;
19501 fail:
19502 return NULL;
19503 }
19504
19505
19506 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19507 PyObject *resultobj = 0;
19508 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19509 int result;
19510 void *argp1 = 0 ;
19511 int res1 = 0 ;
19512 PyObject *swig_obj[1] ;
19513
19514 if (!args) SWIG_fail;
19515 swig_obj[0] = args;
19516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19517 if (!SWIG_IsOK(res1)) {
19518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19519 }
19520 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19521 {
19522 PyThreadState* __tstate = wxPyBeginAllowThreads();
19523 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19524 wxPyEndAllowThreads(__tstate);
19525 if (PyErr_Occurred()) SWIG_fail;
19526 }
19527 resultobj = SWIG_From_int(static_cast< int >(result));
19528 return resultobj;
19529 fail:
19530 return NULL;
19531 }
19532
19533
19534 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19535 PyObject *resultobj = 0;
19536 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19537 int result;
19538 void *argp1 = 0 ;
19539 int res1 = 0 ;
19540 PyObject *swig_obj[1] ;
19541
19542 if (!args) SWIG_fail;
19543 swig_obj[0] = args;
19544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19545 if (!SWIG_IsOK(res1)) {
19546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19547 }
19548 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19549 {
19550 PyThreadState* __tstate = wxPyBeginAllowThreads();
19551 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19552 wxPyEndAllowThreads(__tstate);
19553 if (PyErr_Occurred()) SWIG_fail;
19554 }
19555 resultobj = SWIG_From_int(static_cast< int >(result));
19556 return resultobj;
19557 fail:
19558 return NULL;
19559 }
19560
19561
19562 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19565 int arg2 ;
19566 void *argp1 = 0 ;
19567 int res1 = 0 ;
19568 int val2 ;
19569 int ecode2 = 0 ;
19570 PyObject * obj0 = 0 ;
19571 PyObject * obj1 = 0 ;
19572 char * kwnames[] = {
19573 (char *) "self",(char *) "orient", NULL
19574 };
19575
19576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19580 }
19581 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19582 ecode2 = SWIG_AsVal_int(obj1, &val2);
19583 if (!SWIG_IsOK(ecode2)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19585 }
19586 arg2 = static_cast< int >(val2);
19587 {
19588 PyThreadState* __tstate = wxPyBeginAllowThreads();
19589 (arg1)->SetOrientation(arg2);
19590 wxPyEndAllowThreads(__tstate);
19591 if (PyErr_Occurred()) SWIG_fail;
19592 }
19593 resultobj = SWIG_Py_Void();
19594 return resultobj;
19595 fail:
19596 return NULL;
19597 }
19598
19599
19600 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19601 PyObject *resultobj = 0;
19602 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19603 int arg2 ;
19604 void *argp1 = 0 ;
19605 int res1 = 0 ;
19606 int val2 ;
19607 int ecode2 = 0 ;
19608 PyObject * obj0 = 0 ;
19609 PyObject * obj1 = 0 ;
19610 char * kwnames[] = {
19611 (char *) "self",(char *) "pos", NULL
19612 };
19613
19614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19616 if (!SWIG_IsOK(res1)) {
19617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19618 }
19619 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19620 ecode2 = SWIG_AsVal_int(obj1, &val2);
19621 if (!SWIG_IsOK(ecode2)) {
19622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19623 }
19624 arg2 = static_cast< int >(val2);
19625 {
19626 PyThreadState* __tstate = wxPyBeginAllowThreads();
19627 (arg1)->SetPosition(arg2);
19628 wxPyEndAllowThreads(__tstate);
19629 if (PyErr_Occurred()) SWIG_fail;
19630 }
19631 resultobj = SWIG_Py_Void();
19632 return resultobj;
19633 fail:
19634 return NULL;
19635 }
19636
19637
19638 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19639 PyObject *obj;
19640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19641 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19642 return SWIG_Py_Void();
19643 }
19644
19645 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646 return SWIG_Python_InitShadowInstance(args);
19647 }
19648
19649 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19650 PyObject *resultobj = 0;
19651 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19652 wxMouseEvent *result = 0 ;
19653 int val1 ;
19654 int ecode1 = 0 ;
19655 PyObject * obj0 = 0 ;
19656 char * kwnames[] = {
19657 (char *) "mouseType", NULL
19658 };
19659
19660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19661 if (obj0) {
19662 ecode1 = SWIG_AsVal_int(obj0, &val1);
19663 if (!SWIG_IsOK(ecode1)) {
19664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19665 }
19666 arg1 = static_cast< wxEventType >(val1);
19667 }
19668 {
19669 PyThreadState* __tstate = wxPyBeginAllowThreads();
19670 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19671 wxPyEndAllowThreads(__tstate);
19672 if (PyErr_Occurred()) SWIG_fail;
19673 }
19674 {
19675 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19676 }
19677 return resultobj;
19678 fail:
19679 return NULL;
19680 }
19681
19682
19683 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19684 PyObject *resultobj = 0;
19685 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19686 bool result;
19687 void *argp1 = 0 ;
19688 int res1 = 0 ;
19689 PyObject *swig_obj[1] ;
19690
19691 if (!args) SWIG_fail;
19692 swig_obj[0] = args;
19693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19694 if (!SWIG_IsOK(res1)) {
19695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19696 }
19697 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19698 {
19699 PyThreadState* __tstate = wxPyBeginAllowThreads();
19700 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19701 wxPyEndAllowThreads(__tstate);
19702 if (PyErr_Occurred()) SWIG_fail;
19703 }
19704 {
19705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19706 }
19707 return resultobj;
19708 fail:
19709 return NULL;
19710 }
19711
19712
19713 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19714 PyObject *resultobj = 0;
19715 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19716 int arg2 = (int) wxMOUSE_BTN_ANY ;
19717 bool result;
19718 void *argp1 = 0 ;
19719 int res1 = 0 ;
19720 int val2 ;
19721 int ecode2 = 0 ;
19722 PyObject * obj0 = 0 ;
19723 PyObject * obj1 = 0 ;
19724 char * kwnames[] = {
19725 (char *) "self",(char *) "but", NULL
19726 };
19727
19728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19730 if (!SWIG_IsOK(res1)) {
19731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19732 }
19733 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19734 if (obj1) {
19735 ecode2 = SWIG_AsVal_int(obj1, &val2);
19736 if (!SWIG_IsOK(ecode2)) {
19737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19738 }
19739 arg2 = static_cast< int >(val2);
19740 }
19741 {
19742 PyThreadState* __tstate = wxPyBeginAllowThreads();
19743 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19744 wxPyEndAllowThreads(__tstate);
19745 if (PyErr_Occurred()) SWIG_fail;
19746 }
19747 {
19748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19749 }
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19757 PyObject *resultobj = 0;
19758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19759 int arg2 = (int) wxMOUSE_BTN_ANY ;
19760 bool result;
19761 void *argp1 = 0 ;
19762 int res1 = 0 ;
19763 int val2 ;
19764 int ecode2 = 0 ;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char * kwnames[] = {
19768 (char *) "self",(char *) "but", NULL
19769 };
19770
19771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19773 if (!SWIG_IsOK(res1)) {
19774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19775 }
19776 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19777 if (obj1) {
19778 ecode2 = SWIG_AsVal_int(obj1, &val2);
19779 if (!SWIG_IsOK(ecode2)) {
19780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19781 }
19782 arg2 = static_cast< int >(val2);
19783 }
19784 {
19785 PyThreadState* __tstate = wxPyBeginAllowThreads();
19786 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19787 wxPyEndAllowThreads(__tstate);
19788 if (PyErr_Occurred()) SWIG_fail;
19789 }
19790 {
19791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19792 }
19793 return resultobj;
19794 fail:
19795 return NULL;
19796 }
19797
19798
19799 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19800 PyObject *resultobj = 0;
19801 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19802 int arg2 = (int) wxMOUSE_BTN_ANY ;
19803 bool result;
19804 void *argp1 = 0 ;
19805 int res1 = 0 ;
19806 int val2 ;
19807 int ecode2 = 0 ;
19808 PyObject * obj0 = 0 ;
19809 PyObject * obj1 = 0 ;
19810 char * kwnames[] = {
19811 (char *) "self",(char *) "but", NULL
19812 };
19813
19814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19816 if (!SWIG_IsOK(res1)) {
19817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19818 }
19819 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19820 if (obj1) {
19821 ecode2 = SWIG_AsVal_int(obj1, &val2);
19822 if (!SWIG_IsOK(ecode2)) {
19823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19824 }
19825 arg2 = static_cast< int >(val2);
19826 }
19827 {
19828 PyThreadState* __tstate = wxPyBeginAllowThreads();
19829 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19830 wxPyEndAllowThreads(__tstate);
19831 if (PyErr_Occurred()) SWIG_fail;
19832 }
19833 {
19834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19835 }
19836 return resultobj;
19837 fail:
19838 return NULL;
19839 }
19840
19841
19842 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19843 PyObject *resultobj = 0;
19844 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19845 int arg2 ;
19846 bool result;
19847 void *argp1 = 0 ;
19848 int res1 = 0 ;
19849 int val2 ;
19850 int ecode2 = 0 ;
19851 PyObject * obj0 = 0 ;
19852 PyObject * obj1 = 0 ;
19853 char * kwnames[] = {
19854 (char *) "self",(char *) "button", NULL
19855 };
19856
19857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19859 if (!SWIG_IsOK(res1)) {
19860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19861 }
19862 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19863 ecode2 = SWIG_AsVal_int(obj1, &val2);
19864 if (!SWIG_IsOK(ecode2)) {
19865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19866 }
19867 arg2 = static_cast< int >(val2);
19868 {
19869 PyThreadState* __tstate = wxPyBeginAllowThreads();
19870 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19871 wxPyEndAllowThreads(__tstate);
19872 if (PyErr_Occurred()) SWIG_fail;
19873 }
19874 {
19875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19876 }
19877 return resultobj;
19878 fail:
19879 return NULL;
19880 }
19881
19882
19883 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19884 PyObject *resultobj = 0;
19885 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19886 int arg2 ;
19887 bool result;
19888 void *argp1 = 0 ;
19889 int res1 = 0 ;
19890 int val2 ;
19891 int ecode2 = 0 ;
19892 PyObject * obj0 = 0 ;
19893 PyObject * obj1 = 0 ;
19894 char * kwnames[] = {
19895 (char *) "self",(char *) "but", NULL
19896 };
19897
19898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
19899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19900 if (!SWIG_IsOK(res1)) {
19901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19902 }
19903 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19904 ecode2 = SWIG_AsVal_int(obj1, &val2);
19905 if (!SWIG_IsOK(ecode2)) {
19906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
19907 }
19908 arg2 = static_cast< int >(val2);
19909 {
19910 PyThreadState* __tstate = wxPyBeginAllowThreads();
19911 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
19912 wxPyEndAllowThreads(__tstate);
19913 if (PyErr_Occurred()) SWIG_fail;
19914 }
19915 {
19916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19917 }
19918 return resultobj;
19919 fail:
19920 return NULL;
19921 }
19922
19923
19924 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19925 PyObject *resultobj = 0;
19926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19927 int result;
19928 void *argp1 = 0 ;
19929 int res1 = 0 ;
19930 PyObject *swig_obj[1] ;
19931
19932 if (!args) SWIG_fail;
19933 swig_obj[0] = args;
19934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19935 if (!SWIG_IsOK(res1)) {
19936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19937 }
19938 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19939 {
19940 PyThreadState* __tstate = wxPyBeginAllowThreads();
19941 result = (int)((wxMouseEvent const *)arg1)->GetButton();
19942 wxPyEndAllowThreads(__tstate);
19943 if (PyErr_Occurred()) SWIG_fail;
19944 }
19945 resultobj = SWIG_From_int(static_cast< int >(result));
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19953 PyObject *resultobj = 0;
19954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19955 bool result;
19956 void *argp1 = 0 ;
19957 int res1 = 0 ;
19958 PyObject *swig_obj[1] ;
19959
19960 if (!args) SWIG_fail;
19961 swig_obj[0] = args;
19962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19963 if (!SWIG_IsOK(res1)) {
19964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19965 }
19966 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19967 {
19968 PyThreadState* __tstate = wxPyBeginAllowThreads();
19969 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
19970 wxPyEndAllowThreads(__tstate);
19971 if (PyErr_Occurred()) SWIG_fail;
19972 }
19973 {
19974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19975 }
19976 return resultobj;
19977 fail:
19978 return NULL;
19979 }
19980
19981
19982 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19983 PyObject *resultobj = 0;
19984 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19985 bool result;
19986 void *argp1 = 0 ;
19987 int res1 = 0 ;
19988 PyObject *swig_obj[1] ;
19989
19990 if (!args) SWIG_fail;
19991 swig_obj[0] = args;
19992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19993 if (!SWIG_IsOK(res1)) {
19994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19995 }
19996 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19997 {
19998 PyThreadState* __tstate = wxPyBeginAllowThreads();
19999 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20000 wxPyEndAllowThreads(__tstate);
20001 if (PyErr_Occurred()) SWIG_fail;
20002 }
20003 {
20004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20005 }
20006 return resultobj;
20007 fail:
20008 return NULL;
20009 }
20010
20011
20012 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20013 PyObject *resultobj = 0;
20014 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20015 bool result;
20016 void *argp1 = 0 ;
20017 int res1 = 0 ;
20018 PyObject *swig_obj[1] ;
20019
20020 if (!args) SWIG_fail;
20021 swig_obj[0] = args;
20022 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20023 if (!SWIG_IsOK(res1)) {
20024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20025 }
20026 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20027 {
20028 PyThreadState* __tstate = wxPyBeginAllowThreads();
20029 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20030 wxPyEndAllowThreads(__tstate);
20031 if (PyErr_Occurred()) SWIG_fail;
20032 }
20033 {
20034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20035 }
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20043 PyObject *resultobj = 0;
20044 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20045 bool result;
20046 void *argp1 = 0 ;
20047 int res1 = 0 ;
20048 PyObject *swig_obj[1] ;
20049
20050 if (!args) SWIG_fail;
20051 swig_obj[0] = args;
20052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20053 if (!SWIG_IsOK(res1)) {
20054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20055 }
20056 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20057 {
20058 PyThreadState* __tstate = wxPyBeginAllowThreads();
20059 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20060 wxPyEndAllowThreads(__tstate);
20061 if (PyErr_Occurred()) SWIG_fail;
20062 }
20063 {
20064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20065 }
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20073 PyObject *resultobj = 0;
20074 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20075 bool result;
20076 void *argp1 = 0 ;
20077 int res1 = 0 ;
20078 PyObject *swig_obj[1] ;
20079
20080 if (!args) SWIG_fail;
20081 swig_obj[0] = args;
20082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20083 if (!SWIG_IsOK(res1)) {
20084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20085 }
20086 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20087 {
20088 PyThreadState* __tstate = wxPyBeginAllowThreads();
20089 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20090 wxPyEndAllowThreads(__tstate);
20091 if (PyErr_Occurred()) SWIG_fail;
20092 }
20093 {
20094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20103 PyObject *resultobj = 0;
20104 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20105 bool result;
20106 void *argp1 = 0 ;
20107 int res1 = 0 ;
20108 PyObject *swig_obj[1] ;
20109
20110 if (!args) SWIG_fail;
20111 swig_obj[0] = args;
20112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20113 if (!SWIG_IsOK(res1)) {
20114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20115 }
20116 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20117 {
20118 PyThreadState* __tstate = wxPyBeginAllowThreads();
20119 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20120 wxPyEndAllowThreads(__tstate);
20121 if (PyErr_Occurred()) SWIG_fail;
20122 }
20123 {
20124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20133 PyObject *resultobj = 0;
20134 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20135 bool result;
20136 void *argp1 = 0 ;
20137 int res1 = 0 ;
20138 PyObject *swig_obj[1] ;
20139
20140 if (!args) SWIG_fail;
20141 swig_obj[0] = args;
20142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20143 if (!SWIG_IsOK(res1)) {
20144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20145 }
20146 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20147 {
20148 PyThreadState* __tstate = wxPyBeginAllowThreads();
20149 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20150 wxPyEndAllowThreads(__tstate);
20151 if (PyErr_Occurred()) SWIG_fail;
20152 }
20153 {
20154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20155 }
20156 return resultobj;
20157 fail:
20158 return NULL;
20159 }
20160
20161
20162 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20163 PyObject *resultobj = 0;
20164 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20165 bool result;
20166 void *argp1 = 0 ;
20167 int res1 = 0 ;
20168 PyObject *swig_obj[1] ;
20169
20170 if (!args) SWIG_fail;
20171 swig_obj[0] = args;
20172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20173 if (!SWIG_IsOK(res1)) {
20174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20175 }
20176 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20177 {
20178 PyThreadState* __tstate = wxPyBeginAllowThreads();
20179 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20180 wxPyEndAllowThreads(__tstate);
20181 if (PyErr_Occurred()) SWIG_fail;
20182 }
20183 {
20184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20185 }
20186 return resultobj;
20187 fail:
20188 return NULL;
20189 }
20190
20191
20192 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20193 PyObject *resultobj = 0;
20194 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20195 bool result;
20196 void *argp1 = 0 ;
20197 int res1 = 0 ;
20198 PyObject *swig_obj[1] ;
20199
20200 if (!args) SWIG_fail;
20201 swig_obj[0] = args;
20202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20203 if (!SWIG_IsOK(res1)) {
20204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20205 }
20206 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20207 {
20208 PyThreadState* __tstate = wxPyBeginAllowThreads();
20209 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20210 wxPyEndAllowThreads(__tstate);
20211 if (PyErr_Occurred()) SWIG_fail;
20212 }
20213 {
20214 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20215 }
20216 return resultobj;
20217 fail:
20218 return NULL;
20219 }
20220
20221
20222 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20223 PyObject *resultobj = 0;
20224 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20225 bool result;
20226 void *argp1 = 0 ;
20227 int res1 = 0 ;
20228 PyObject *swig_obj[1] ;
20229
20230 if (!args) SWIG_fail;
20231 swig_obj[0] = args;
20232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20233 if (!SWIG_IsOK(res1)) {
20234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20235 }
20236 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20237 {
20238 PyThreadState* __tstate = wxPyBeginAllowThreads();
20239 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20240 wxPyEndAllowThreads(__tstate);
20241 if (PyErr_Occurred()) SWIG_fail;
20242 }
20243 {
20244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20245 }
20246 return resultobj;
20247 fail:
20248 return NULL;
20249 }
20250
20251
20252 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20253 PyObject *resultobj = 0;
20254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20255 bool result;
20256 void *argp1 = 0 ;
20257 int res1 = 0 ;
20258 PyObject *swig_obj[1] ;
20259
20260 if (!args) SWIG_fail;
20261 swig_obj[0] = args;
20262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20263 if (!SWIG_IsOK(res1)) {
20264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20265 }
20266 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20267 {
20268 PyThreadState* __tstate = wxPyBeginAllowThreads();
20269 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20270 wxPyEndAllowThreads(__tstate);
20271 if (PyErr_Occurred()) SWIG_fail;
20272 }
20273 {
20274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20275 }
20276 return resultobj;
20277 fail:
20278 return NULL;
20279 }
20280
20281
20282 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20283 PyObject *resultobj = 0;
20284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20285 bool result;
20286 void *argp1 = 0 ;
20287 int res1 = 0 ;
20288 PyObject *swig_obj[1] ;
20289
20290 if (!args) SWIG_fail;
20291 swig_obj[0] = args;
20292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20293 if (!SWIG_IsOK(res1)) {
20294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20295 }
20296 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20297 {
20298 PyThreadState* __tstate = wxPyBeginAllowThreads();
20299 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20300 wxPyEndAllowThreads(__tstate);
20301 if (PyErr_Occurred()) SWIG_fail;
20302 }
20303 {
20304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20305 }
20306 return resultobj;
20307 fail:
20308 return NULL;
20309 }
20310
20311
20312 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20313 PyObject *resultobj = 0;
20314 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20315 bool result;
20316 void *argp1 = 0 ;
20317 int res1 = 0 ;
20318 PyObject *swig_obj[1] ;
20319
20320 if (!args) SWIG_fail;
20321 swig_obj[0] = args;
20322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20323 if (!SWIG_IsOK(res1)) {
20324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20325 }
20326 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20327 {
20328 PyThreadState* __tstate = wxPyBeginAllowThreads();
20329 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20330 wxPyEndAllowThreads(__tstate);
20331 if (PyErr_Occurred()) SWIG_fail;
20332 }
20333 {
20334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20335 }
20336 return resultobj;
20337 fail:
20338 return NULL;
20339 }
20340
20341
20342 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20343 PyObject *resultobj = 0;
20344 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20345 bool result;
20346 void *argp1 = 0 ;
20347 int res1 = 0 ;
20348 PyObject *swig_obj[1] ;
20349
20350 if (!args) SWIG_fail;
20351 swig_obj[0] = args;
20352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20353 if (!SWIG_IsOK(res1)) {
20354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20355 }
20356 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20357 {
20358 PyThreadState* __tstate = wxPyBeginAllowThreads();
20359 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20360 wxPyEndAllowThreads(__tstate);
20361 if (PyErr_Occurred()) SWIG_fail;
20362 }
20363 {
20364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20365 }
20366 return resultobj;
20367 fail:
20368 return NULL;
20369 }
20370
20371
20372 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20373 PyObject *resultobj = 0;
20374 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20375 bool result;
20376 void *argp1 = 0 ;
20377 int res1 = 0 ;
20378 PyObject *swig_obj[1] ;
20379
20380 if (!args) SWIG_fail;
20381 swig_obj[0] = args;
20382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20383 if (!SWIG_IsOK(res1)) {
20384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20385 }
20386 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20387 {
20388 PyThreadState* __tstate = wxPyBeginAllowThreads();
20389 result = (bool)(arg1)->LeftIsDown();
20390 wxPyEndAllowThreads(__tstate);
20391 if (PyErr_Occurred()) SWIG_fail;
20392 }
20393 {
20394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20395 }
20396 return resultobj;
20397 fail:
20398 return NULL;
20399 }
20400
20401
20402 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20403 PyObject *resultobj = 0;
20404 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20405 bool result;
20406 void *argp1 = 0 ;
20407 int res1 = 0 ;
20408 PyObject *swig_obj[1] ;
20409
20410 if (!args) SWIG_fail;
20411 swig_obj[0] = args;
20412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20413 if (!SWIG_IsOK(res1)) {
20414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20415 }
20416 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20417 {
20418 PyThreadState* __tstate = wxPyBeginAllowThreads();
20419 result = (bool)(arg1)->MiddleIsDown();
20420 wxPyEndAllowThreads(__tstate);
20421 if (PyErr_Occurred()) SWIG_fail;
20422 }
20423 {
20424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20425 }
20426 return resultobj;
20427 fail:
20428 return NULL;
20429 }
20430
20431
20432 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20433 PyObject *resultobj = 0;
20434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20435 bool result;
20436 void *argp1 = 0 ;
20437 int res1 = 0 ;
20438 PyObject *swig_obj[1] ;
20439
20440 if (!args) SWIG_fail;
20441 swig_obj[0] = args;
20442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20443 if (!SWIG_IsOK(res1)) {
20444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20445 }
20446 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20447 {
20448 PyThreadState* __tstate = wxPyBeginAllowThreads();
20449 result = (bool)(arg1)->RightIsDown();
20450 wxPyEndAllowThreads(__tstate);
20451 if (PyErr_Occurred()) SWIG_fail;
20452 }
20453 {
20454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20455 }
20456 return resultobj;
20457 fail:
20458 return NULL;
20459 }
20460
20461
20462 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20463 PyObject *resultobj = 0;
20464 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20465 bool result;
20466 void *argp1 = 0 ;
20467 int res1 = 0 ;
20468 PyObject *swig_obj[1] ;
20469
20470 if (!args) SWIG_fail;
20471 swig_obj[0] = args;
20472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20473 if (!SWIG_IsOK(res1)) {
20474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20475 }
20476 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20477 {
20478 PyThreadState* __tstate = wxPyBeginAllowThreads();
20479 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20480 wxPyEndAllowThreads(__tstate);
20481 if (PyErr_Occurred()) SWIG_fail;
20482 }
20483 {
20484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20485 }
20486 return resultobj;
20487 fail:
20488 return NULL;
20489 }
20490
20491
20492 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20493 PyObject *resultobj = 0;
20494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20495 bool result;
20496 void *argp1 = 0 ;
20497 int res1 = 0 ;
20498 PyObject *swig_obj[1] ;
20499
20500 if (!args) SWIG_fail;
20501 swig_obj[0] = args;
20502 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20503 if (!SWIG_IsOK(res1)) {
20504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20505 }
20506 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20507 {
20508 PyThreadState* __tstate = wxPyBeginAllowThreads();
20509 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20510 wxPyEndAllowThreads(__tstate);
20511 if (PyErr_Occurred()) SWIG_fail;
20512 }
20513 {
20514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20515 }
20516 return resultobj;
20517 fail:
20518 return NULL;
20519 }
20520
20521
20522 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20523 PyObject *resultobj = 0;
20524 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20525 bool result;
20526 void *argp1 = 0 ;
20527 int res1 = 0 ;
20528 PyObject *swig_obj[1] ;
20529
20530 if (!args) SWIG_fail;
20531 swig_obj[0] = args;
20532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20533 if (!SWIG_IsOK(res1)) {
20534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20535 }
20536 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20537 {
20538 PyThreadState* __tstate = wxPyBeginAllowThreads();
20539 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20540 wxPyEndAllowThreads(__tstate);
20541 if (PyErr_Occurred()) SWIG_fail;
20542 }
20543 {
20544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20545 }
20546 return resultobj;
20547 fail:
20548 return NULL;
20549 }
20550
20551
20552 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20553 PyObject *resultobj = 0;
20554 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20555 bool result;
20556 void *argp1 = 0 ;
20557 int res1 = 0 ;
20558 PyObject *swig_obj[1] ;
20559
20560 if (!args) SWIG_fail;
20561 swig_obj[0] = args;
20562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20563 if (!SWIG_IsOK(res1)) {
20564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20565 }
20566 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20567 {
20568 PyThreadState* __tstate = wxPyBeginAllowThreads();
20569 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20570 wxPyEndAllowThreads(__tstate);
20571 if (PyErr_Occurred()) SWIG_fail;
20572 }
20573 {
20574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20575 }
20576 return resultobj;
20577 fail:
20578 return NULL;
20579 }
20580
20581
20582 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20583 PyObject *resultobj = 0;
20584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20585 wxPoint result;
20586 void *argp1 = 0 ;
20587 int res1 = 0 ;
20588 PyObject *swig_obj[1] ;
20589
20590 if (!args) SWIG_fail;
20591 swig_obj[0] = args;
20592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20593 if (!SWIG_IsOK(res1)) {
20594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20595 }
20596 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20597 {
20598 PyThreadState* __tstate = wxPyBeginAllowThreads();
20599 result = (arg1)->GetPosition();
20600 wxPyEndAllowThreads(__tstate);
20601 if (PyErr_Occurred()) SWIG_fail;
20602 }
20603 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20604 return resultobj;
20605 fail:
20606 return NULL;
20607 }
20608
20609
20610 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20611 PyObject *resultobj = 0;
20612 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20613 long *arg2 = (long *) 0 ;
20614 long *arg3 = (long *) 0 ;
20615 void *argp1 = 0 ;
20616 int res1 = 0 ;
20617 long temp2 ;
20618 int res2 = SWIG_TMPOBJ ;
20619 long temp3 ;
20620 int res3 = SWIG_TMPOBJ ;
20621 PyObject *swig_obj[1] ;
20622
20623 arg2 = &temp2;
20624 arg3 = &temp3;
20625 if (!args) SWIG_fail;
20626 swig_obj[0] = args;
20627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20628 if (!SWIG_IsOK(res1)) {
20629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20630 }
20631 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20632 {
20633 PyThreadState* __tstate = wxPyBeginAllowThreads();
20634 (arg1)->GetPosition(arg2,arg3);
20635 wxPyEndAllowThreads(__tstate);
20636 if (PyErr_Occurred()) SWIG_fail;
20637 }
20638 resultobj = SWIG_Py_Void();
20639 if (SWIG_IsTmpObj(res2)) {
20640 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20641 } else {
20642 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20644 }
20645 if (SWIG_IsTmpObj(res3)) {
20646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20647 } else {
20648 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20650 }
20651 return resultobj;
20652 fail:
20653 return NULL;
20654 }
20655
20656
20657 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20658 PyObject *resultobj = 0;
20659 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20660 wxDC *arg2 = 0 ;
20661 wxPoint result;
20662 void *argp1 = 0 ;
20663 int res1 = 0 ;
20664 void *argp2 = 0 ;
20665 int res2 = 0 ;
20666 PyObject * obj0 = 0 ;
20667 PyObject * obj1 = 0 ;
20668 char * kwnames[] = {
20669 (char *) "self",(char *) "dc", NULL
20670 };
20671
20672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20674 if (!SWIG_IsOK(res1)) {
20675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20676 }
20677 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20678 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20679 if (!SWIG_IsOK(res2)) {
20680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20681 }
20682 if (!argp2) {
20683 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20684 }
20685 arg2 = reinterpret_cast< wxDC * >(argp2);
20686 {
20687 PyThreadState* __tstate = wxPyBeginAllowThreads();
20688 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20689 wxPyEndAllowThreads(__tstate);
20690 if (PyErr_Occurred()) SWIG_fail;
20691 }
20692 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20693 return resultobj;
20694 fail:
20695 return NULL;
20696 }
20697
20698
20699 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20700 PyObject *resultobj = 0;
20701 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20702 int result;
20703 void *argp1 = 0 ;
20704 int res1 = 0 ;
20705 PyObject *swig_obj[1] ;
20706
20707 if (!args) SWIG_fail;
20708 swig_obj[0] = args;
20709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20710 if (!SWIG_IsOK(res1)) {
20711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20712 }
20713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20714 {
20715 PyThreadState* __tstate = wxPyBeginAllowThreads();
20716 result = (int)((wxMouseEvent const *)arg1)->GetX();
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 resultobj = SWIG_From_int(static_cast< int >(result));
20721 return resultobj;
20722 fail:
20723 return NULL;
20724 }
20725
20726
20727 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20728 PyObject *resultobj = 0;
20729 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20730 int result;
20731 void *argp1 = 0 ;
20732 int res1 = 0 ;
20733 PyObject *swig_obj[1] ;
20734
20735 if (!args) SWIG_fail;
20736 swig_obj[0] = args;
20737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20738 if (!SWIG_IsOK(res1)) {
20739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20740 }
20741 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 result = (int)((wxMouseEvent const *)arg1)->GetY();
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 resultobj = SWIG_From_int(static_cast< int >(result));
20749 return resultobj;
20750 fail:
20751 return NULL;
20752 }
20753
20754
20755 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20756 PyObject *resultobj = 0;
20757 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20758 int result;
20759 void *argp1 = 0 ;
20760 int res1 = 0 ;
20761 PyObject *swig_obj[1] ;
20762
20763 if (!args) SWIG_fail;
20764 swig_obj[0] = args;
20765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20766 if (!SWIG_IsOK(res1)) {
20767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20768 }
20769 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20770 {
20771 PyThreadState* __tstate = wxPyBeginAllowThreads();
20772 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20773 wxPyEndAllowThreads(__tstate);
20774 if (PyErr_Occurred()) SWIG_fail;
20775 }
20776 resultobj = SWIG_From_int(static_cast< int >(result));
20777 return resultobj;
20778 fail:
20779 return NULL;
20780 }
20781
20782
20783 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20784 PyObject *resultobj = 0;
20785 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20786 int result;
20787 void *argp1 = 0 ;
20788 int res1 = 0 ;
20789 PyObject *swig_obj[1] ;
20790
20791 if (!args) SWIG_fail;
20792 swig_obj[0] = args;
20793 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20794 if (!SWIG_IsOK(res1)) {
20795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20796 }
20797 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20798 {
20799 PyThreadState* __tstate = wxPyBeginAllowThreads();
20800 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20801 wxPyEndAllowThreads(__tstate);
20802 if (PyErr_Occurred()) SWIG_fail;
20803 }
20804 resultobj = SWIG_From_int(static_cast< int >(result));
20805 return resultobj;
20806 fail:
20807 return NULL;
20808 }
20809
20810
20811 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20812 PyObject *resultobj = 0;
20813 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20814 int result;
20815 void *argp1 = 0 ;
20816 int res1 = 0 ;
20817 PyObject *swig_obj[1] ;
20818
20819 if (!args) SWIG_fail;
20820 swig_obj[0] = args;
20821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20822 if (!SWIG_IsOK(res1)) {
20823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20824 }
20825 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20826 {
20827 PyThreadState* __tstate = wxPyBeginAllowThreads();
20828 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20829 wxPyEndAllowThreads(__tstate);
20830 if (PyErr_Occurred()) SWIG_fail;
20831 }
20832 resultobj = SWIG_From_int(static_cast< int >(result));
20833 return resultobj;
20834 fail:
20835 return NULL;
20836 }
20837
20838
20839 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20840 PyObject *resultobj = 0;
20841 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20842 bool result;
20843 void *argp1 = 0 ;
20844 int res1 = 0 ;
20845 PyObject *swig_obj[1] ;
20846
20847 if (!args) SWIG_fail;
20848 swig_obj[0] = args;
20849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20850 if (!SWIG_IsOK(res1)) {
20851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20852 }
20853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 {
20861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20862 }
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20870 PyObject *resultobj = 0;
20871 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20872 int arg2 ;
20873 void *argp1 = 0 ;
20874 int res1 = 0 ;
20875 int val2 ;
20876 int ecode2 = 0 ;
20877 PyObject *swig_obj[2] ;
20878
20879 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20881 if (!SWIG_IsOK(res1)) {
20882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20883 }
20884 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20885 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20886 if (!SWIG_IsOK(ecode2)) {
20887 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20888 }
20889 arg2 = static_cast< int >(val2);
20890 if (arg1) (arg1)->m_x = arg2;
20891
20892 resultobj = SWIG_Py_Void();
20893 return resultobj;
20894 fail:
20895 return NULL;
20896 }
20897
20898
20899 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20900 PyObject *resultobj = 0;
20901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20902 int result;
20903 void *argp1 = 0 ;
20904 int res1 = 0 ;
20905 PyObject *swig_obj[1] ;
20906
20907 if (!args) SWIG_fail;
20908 swig_obj[0] = args;
20909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20910 if (!SWIG_IsOK(res1)) {
20911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20912 }
20913 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20914 result = (int) ((arg1)->m_x);
20915 resultobj = SWIG_From_int(static_cast< int >(result));
20916 return resultobj;
20917 fail:
20918 return NULL;
20919 }
20920
20921
20922 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20923 PyObject *resultobj = 0;
20924 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20925 int arg2 ;
20926 void *argp1 = 0 ;
20927 int res1 = 0 ;
20928 int val2 ;
20929 int ecode2 = 0 ;
20930 PyObject *swig_obj[2] ;
20931
20932 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
20933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20934 if (!SWIG_IsOK(res1)) {
20935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20936 }
20937 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20938 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20939 if (!SWIG_IsOK(ecode2)) {
20940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
20941 }
20942 arg2 = static_cast< int >(val2);
20943 if (arg1) (arg1)->m_y = arg2;
20944
20945 resultobj = SWIG_Py_Void();
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953 PyObject *resultobj = 0;
20954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20955 int result;
20956 void *argp1 = 0 ;
20957 int res1 = 0 ;
20958 PyObject *swig_obj[1] ;
20959
20960 if (!args) SWIG_fail;
20961 swig_obj[0] = args;
20962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20963 if (!SWIG_IsOK(res1)) {
20964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20965 }
20966 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20967 result = (int) ((arg1)->m_y);
20968 resultobj = SWIG_From_int(static_cast< int >(result));
20969 return resultobj;
20970 fail:
20971 return NULL;
20972 }
20973
20974
20975 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20976 PyObject *resultobj = 0;
20977 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20978 bool arg2 ;
20979 void *argp1 = 0 ;
20980 int res1 = 0 ;
20981 bool val2 ;
20982 int ecode2 = 0 ;
20983 PyObject *swig_obj[2] ;
20984
20985 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
20986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20987 if (!SWIG_IsOK(res1)) {
20988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20989 }
20990 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20991 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
20992 if (!SWIG_IsOK(ecode2)) {
20993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
20994 }
20995 arg2 = static_cast< bool >(val2);
20996 if (arg1) (arg1)->m_leftDown = arg2;
20997
20998 resultobj = SWIG_Py_Void();
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21006 PyObject *resultobj = 0;
21007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21008 bool result;
21009 void *argp1 = 0 ;
21010 int res1 = 0 ;
21011 PyObject *swig_obj[1] ;
21012
21013 if (!args) SWIG_fail;
21014 swig_obj[0] = args;
21015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21016 if (!SWIG_IsOK(res1)) {
21017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21018 }
21019 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21020 result = (bool) ((arg1)->m_leftDown);
21021 {
21022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21023 }
21024 return resultobj;
21025 fail:
21026 return NULL;
21027 }
21028
21029
21030 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21031 PyObject *resultobj = 0;
21032 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21033 bool arg2 ;
21034 void *argp1 = 0 ;
21035 int res1 = 0 ;
21036 bool val2 ;
21037 int ecode2 = 0 ;
21038 PyObject *swig_obj[2] ;
21039
21040 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21041 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21042 if (!SWIG_IsOK(res1)) {
21043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21044 }
21045 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21046 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21047 if (!SWIG_IsOK(ecode2)) {
21048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21049 }
21050 arg2 = static_cast< bool >(val2);
21051 if (arg1) (arg1)->m_middleDown = arg2;
21052
21053 resultobj = SWIG_Py_Void();
21054 return resultobj;
21055 fail:
21056 return NULL;
21057 }
21058
21059
21060 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21061 PyObject *resultobj = 0;
21062 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21063 bool result;
21064 void *argp1 = 0 ;
21065 int res1 = 0 ;
21066 PyObject *swig_obj[1] ;
21067
21068 if (!args) SWIG_fail;
21069 swig_obj[0] = args;
21070 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21071 if (!SWIG_IsOK(res1)) {
21072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21073 }
21074 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21075 result = (bool) ((arg1)->m_middleDown);
21076 {
21077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21078 }
21079 return resultobj;
21080 fail:
21081 return NULL;
21082 }
21083
21084
21085 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21086 PyObject *resultobj = 0;
21087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21088 bool arg2 ;
21089 void *argp1 = 0 ;
21090 int res1 = 0 ;
21091 bool val2 ;
21092 int ecode2 = 0 ;
21093 PyObject *swig_obj[2] ;
21094
21095 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21099 }
21100 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21101 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21102 if (!SWIG_IsOK(ecode2)) {
21103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21104 }
21105 arg2 = static_cast< bool >(val2);
21106 if (arg1) (arg1)->m_rightDown = arg2;
21107
21108 resultobj = SWIG_Py_Void();
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21116 PyObject *resultobj = 0;
21117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21118 bool result;
21119 void *argp1 = 0 ;
21120 int res1 = 0 ;
21121 PyObject *swig_obj[1] ;
21122
21123 if (!args) SWIG_fail;
21124 swig_obj[0] = args;
21125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21126 if (!SWIG_IsOK(res1)) {
21127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21128 }
21129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21130 result = (bool) ((arg1)->m_rightDown);
21131 {
21132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21133 }
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21141 PyObject *resultobj = 0;
21142 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21143 bool arg2 ;
21144 void *argp1 = 0 ;
21145 int res1 = 0 ;
21146 bool val2 ;
21147 int ecode2 = 0 ;
21148 PyObject *swig_obj[2] ;
21149
21150 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21152 if (!SWIG_IsOK(res1)) {
21153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21154 }
21155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21156 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21157 if (!SWIG_IsOK(ecode2)) {
21158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21159 }
21160 arg2 = static_cast< bool >(val2);
21161 if (arg1) (arg1)->m_controlDown = arg2;
21162
21163 resultobj = SWIG_Py_Void();
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21171 PyObject *resultobj = 0;
21172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21173 bool result;
21174 void *argp1 = 0 ;
21175 int res1 = 0 ;
21176 PyObject *swig_obj[1] ;
21177
21178 if (!args) SWIG_fail;
21179 swig_obj[0] = args;
21180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21181 if (!SWIG_IsOK(res1)) {
21182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21183 }
21184 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21185 result = (bool) ((arg1)->m_controlDown);
21186 {
21187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21188 }
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21196 PyObject *resultobj = 0;
21197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21198 bool arg2 ;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 bool val2 ;
21202 int ecode2 = 0 ;
21203 PyObject *swig_obj[2] ;
21204
21205 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21207 if (!SWIG_IsOK(res1)) {
21208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21209 }
21210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21211 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21212 if (!SWIG_IsOK(ecode2)) {
21213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21214 }
21215 arg2 = static_cast< bool >(val2);
21216 if (arg1) (arg1)->m_shiftDown = arg2;
21217
21218 resultobj = SWIG_Py_Void();
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21226 PyObject *resultobj = 0;
21227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21228 bool result;
21229 void *argp1 = 0 ;
21230 int res1 = 0 ;
21231 PyObject *swig_obj[1] ;
21232
21233 if (!args) SWIG_fail;
21234 swig_obj[0] = args;
21235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21236 if (!SWIG_IsOK(res1)) {
21237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21238 }
21239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21240 result = (bool) ((arg1)->m_shiftDown);
21241 {
21242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21243 }
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21251 PyObject *resultobj = 0;
21252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21253 bool arg2 ;
21254 void *argp1 = 0 ;
21255 int res1 = 0 ;
21256 bool val2 ;
21257 int ecode2 = 0 ;
21258 PyObject *swig_obj[2] ;
21259
21260 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21264 }
21265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21266 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21269 }
21270 arg2 = static_cast< bool >(val2);
21271 if (arg1) (arg1)->m_altDown = arg2;
21272
21273 resultobj = SWIG_Py_Void();
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21281 PyObject *resultobj = 0;
21282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21283 bool result;
21284 void *argp1 = 0 ;
21285 int res1 = 0 ;
21286 PyObject *swig_obj[1] ;
21287
21288 if (!args) SWIG_fail;
21289 swig_obj[0] = args;
21290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21293 }
21294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21295 result = (bool) ((arg1)->m_altDown);
21296 {
21297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21298 }
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21306 PyObject *resultobj = 0;
21307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21308 bool arg2 ;
21309 void *argp1 = 0 ;
21310 int res1 = 0 ;
21311 bool val2 ;
21312 int ecode2 = 0 ;
21313 PyObject *swig_obj[2] ;
21314
21315 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21317 if (!SWIG_IsOK(res1)) {
21318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21319 }
21320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21321 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21322 if (!SWIG_IsOK(ecode2)) {
21323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21324 }
21325 arg2 = static_cast< bool >(val2);
21326 if (arg1) (arg1)->m_metaDown = arg2;
21327
21328 resultobj = SWIG_Py_Void();
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21336 PyObject *resultobj = 0;
21337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21338 bool result;
21339 void *argp1 = 0 ;
21340 int res1 = 0 ;
21341 PyObject *swig_obj[1] ;
21342
21343 if (!args) SWIG_fail;
21344 swig_obj[0] = args;
21345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21346 if (!SWIG_IsOK(res1)) {
21347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21348 }
21349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21350 result = (bool) ((arg1)->m_metaDown);
21351 {
21352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21353 }
21354 return resultobj;
21355 fail:
21356 return NULL;
21357 }
21358
21359
21360 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21361 PyObject *resultobj = 0;
21362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21363 int arg2 ;
21364 void *argp1 = 0 ;
21365 int res1 = 0 ;
21366 int val2 ;
21367 int ecode2 = 0 ;
21368 PyObject *swig_obj[2] ;
21369
21370 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21374 }
21375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21376 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21377 if (!SWIG_IsOK(ecode2)) {
21378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21379 }
21380 arg2 = static_cast< int >(val2);
21381 if (arg1) (arg1)->m_wheelRotation = arg2;
21382
21383 resultobj = SWIG_Py_Void();
21384 return resultobj;
21385 fail:
21386 return NULL;
21387 }
21388
21389
21390 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21391 PyObject *resultobj = 0;
21392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21393 int result;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 PyObject *swig_obj[1] ;
21397
21398 if (!args) SWIG_fail;
21399 swig_obj[0] = args;
21400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21401 if (!SWIG_IsOK(res1)) {
21402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21403 }
21404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21405 result = (int) ((arg1)->m_wheelRotation);
21406 resultobj = SWIG_From_int(static_cast< int >(result));
21407 return resultobj;
21408 fail:
21409 return NULL;
21410 }
21411
21412
21413 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21414 PyObject *resultobj = 0;
21415 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21416 int arg2 ;
21417 void *argp1 = 0 ;
21418 int res1 = 0 ;
21419 int val2 ;
21420 int ecode2 = 0 ;
21421 PyObject *swig_obj[2] ;
21422
21423 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21425 if (!SWIG_IsOK(res1)) {
21426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21427 }
21428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21429 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21430 if (!SWIG_IsOK(ecode2)) {
21431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21432 }
21433 arg2 = static_cast< int >(val2);
21434 if (arg1) (arg1)->m_wheelDelta = arg2;
21435
21436 resultobj = SWIG_Py_Void();
21437 return resultobj;
21438 fail:
21439 return NULL;
21440 }
21441
21442
21443 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21444 PyObject *resultobj = 0;
21445 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21446 int result;
21447 void *argp1 = 0 ;
21448 int res1 = 0 ;
21449 PyObject *swig_obj[1] ;
21450
21451 if (!args) SWIG_fail;
21452 swig_obj[0] = args;
21453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21454 if (!SWIG_IsOK(res1)) {
21455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21456 }
21457 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21458 result = (int) ((arg1)->m_wheelDelta);
21459 resultobj = SWIG_From_int(static_cast< int >(result));
21460 return resultobj;
21461 fail:
21462 return NULL;
21463 }
21464
21465
21466 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21467 PyObject *resultobj = 0;
21468 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21469 int arg2 ;
21470 void *argp1 = 0 ;
21471 int res1 = 0 ;
21472 int val2 ;
21473 int ecode2 = 0 ;
21474 PyObject *swig_obj[2] ;
21475
21476 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21477 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21478 if (!SWIG_IsOK(res1)) {
21479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21480 }
21481 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21482 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21483 if (!SWIG_IsOK(ecode2)) {
21484 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21485 }
21486 arg2 = static_cast< int >(val2);
21487 if (arg1) (arg1)->m_linesPerAction = arg2;
21488
21489 resultobj = SWIG_Py_Void();
21490 return resultobj;
21491 fail:
21492 return NULL;
21493 }
21494
21495
21496 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21497 PyObject *resultobj = 0;
21498 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21499 int result;
21500 void *argp1 = 0 ;
21501 int res1 = 0 ;
21502 PyObject *swig_obj[1] ;
21503
21504 if (!args) SWIG_fail;
21505 swig_obj[0] = args;
21506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21507 if (!SWIG_IsOK(res1)) {
21508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21509 }
21510 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21511 result = (int) ((arg1)->m_linesPerAction);
21512 resultobj = SWIG_From_int(static_cast< int >(result));
21513 return resultobj;
21514 fail:
21515 return NULL;
21516 }
21517
21518
21519 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21520 PyObject *obj;
21521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21522 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21523 return SWIG_Py_Void();
21524 }
21525
21526 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21527 return SWIG_Python_InitShadowInstance(args);
21528 }
21529
21530 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21531 PyObject *resultobj = 0;
21532 int arg1 = (int) 0 ;
21533 int arg2 = (int) 0 ;
21534 wxSetCursorEvent *result = 0 ;
21535 int val1 ;
21536 int ecode1 = 0 ;
21537 int val2 ;
21538 int ecode2 = 0 ;
21539 PyObject * obj0 = 0 ;
21540 PyObject * obj1 = 0 ;
21541 char * kwnames[] = {
21542 (char *) "x",(char *) "y", NULL
21543 };
21544
21545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21546 if (obj0) {
21547 ecode1 = SWIG_AsVal_int(obj0, &val1);
21548 if (!SWIG_IsOK(ecode1)) {
21549 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21550 }
21551 arg1 = static_cast< int >(val1);
21552 }
21553 if (obj1) {
21554 ecode2 = SWIG_AsVal_int(obj1, &val2);
21555 if (!SWIG_IsOK(ecode2)) {
21556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21557 }
21558 arg2 = static_cast< int >(val2);
21559 }
21560 {
21561 PyThreadState* __tstate = wxPyBeginAllowThreads();
21562 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21563 wxPyEndAllowThreads(__tstate);
21564 if (PyErr_Occurred()) SWIG_fail;
21565 }
21566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21567 return resultobj;
21568 fail:
21569 return NULL;
21570 }
21571
21572
21573 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21574 PyObject *resultobj = 0;
21575 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21576 int result;
21577 void *argp1 = 0 ;
21578 int res1 = 0 ;
21579 PyObject *swig_obj[1] ;
21580
21581 if (!args) SWIG_fail;
21582 swig_obj[0] = args;
21583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21584 if (!SWIG_IsOK(res1)) {
21585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21586 }
21587 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21588 {
21589 PyThreadState* __tstate = wxPyBeginAllowThreads();
21590 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21591 wxPyEndAllowThreads(__tstate);
21592 if (PyErr_Occurred()) SWIG_fail;
21593 }
21594 resultobj = SWIG_From_int(static_cast< int >(result));
21595 return resultobj;
21596 fail:
21597 return NULL;
21598 }
21599
21600
21601 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21602 PyObject *resultobj = 0;
21603 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21604 int result;
21605 void *argp1 = 0 ;
21606 int res1 = 0 ;
21607 PyObject *swig_obj[1] ;
21608
21609 if (!args) SWIG_fail;
21610 swig_obj[0] = args;
21611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21612 if (!SWIG_IsOK(res1)) {
21613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21614 }
21615 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21616 {
21617 PyThreadState* __tstate = wxPyBeginAllowThreads();
21618 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21619 wxPyEndAllowThreads(__tstate);
21620 if (PyErr_Occurred()) SWIG_fail;
21621 }
21622 resultobj = SWIG_From_int(static_cast< int >(result));
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21630 PyObject *resultobj = 0;
21631 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21632 wxCursor *arg2 = 0 ;
21633 void *argp1 = 0 ;
21634 int res1 = 0 ;
21635 void *argp2 = 0 ;
21636 int res2 = 0 ;
21637 PyObject * obj0 = 0 ;
21638 PyObject * obj1 = 0 ;
21639 char * kwnames[] = {
21640 (char *) "self",(char *) "cursor", NULL
21641 };
21642
21643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21644 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21645 if (!SWIG_IsOK(res1)) {
21646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21647 }
21648 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21649 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21650 if (!SWIG_IsOK(res2)) {
21651 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21652 }
21653 if (!argp2) {
21654 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21655 }
21656 arg2 = reinterpret_cast< wxCursor * >(argp2);
21657 {
21658 PyThreadState* __tstate = wxPyBeginAllowThreads();
21659 (arg1)->SetCursor((wxCursor const &)*arg2);
21660 wxPyEndAllowThreads(__tstate);
21661 if (PyErr_Occurred()) SWIG_fail;
21662 }
21663 resultobj = SWIG_Py_Void();
21664 return resultobj;
21665 fail:
21666 return NULL;
21667 }
21668
21669
21670 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21671 PyObject *resultobj = 0;
21672 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21673 wxCursor *result = 0 ;
21674 void *argp1 = 0 ;
21675 int res1 = 0 ;
21676 PyObject *swig_obj[1] ;
21677
21678 if (!args) SWIG_fail;
21679 swig_obj[0] = args;
21680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21681 if (!SWIG_IsOK(res1)) {
21682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21683 }
21684 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21685 {
21686 PyThreadState* __tstate = wxPyBeginAllowThreads();
21687 {
21688 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21689 result = (wxCursor *) &_result_ref;
21690 }
21691 wxPyEndAllowThreads(__tstate);
21692 if (PyErr_Occurred()) SWIG_fail;
21693 }
21694 {
21695 wxCursor* resultptr = new wxCursor(*result);
21696 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21697 }
21698 return resultobj;
21699 fail:
21700 return NULL;
21701 }
21702
21703
21704 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21705 PyObject *resultobj = 0;
21706 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21707 bool result;
21708 void *argp1 = 0 ;
21709 int res1 = 0 ;
21710 PyObject *swig_obj[1] ;
21711
21712 if (!args) SWIG_fail;
21713 swig_obj[0] = args;
21714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21715 if (!SWIG_IsOK(res1)) {
21716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21717 }
21718 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21719 {
21720 PyThreadState* __tstate = wxPyBeginAllowThreads();
21721 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21722 wxPyEndAllowThreads(__tstate);
21723 if (PyErr_Occurred()) SWIG_fail;
21724 }
21725 {
21726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21727 }
21728 return resultobj;
21729 fail:
21730 return NULL;
21731 }
21732
21733
21734 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21735 PyObject *obj;
21736 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21737 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21738 return SWIG_Py_Void();
21739 }
21740
21741 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 return SWIG_Python_InitShadowInstance(args);
21743 }
21744
21745 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21746 PyObject *resultobj = 0;
21747 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21748 wxKeyEvent *result = 0 ;
21749 int val1 ;
21750 int ecode1 = 0 ;
21751 PyObject * obj0 = 0 ;
21752 char * kwnames[] = {
21753 (char *) "eventType", NULL
21754 };
21755
21756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21757 if (obj0) {
21758 ecode1 = SWIG_AsVal_int(obj0, &val1);
21759 if (!SWIG_IsOK(ecode1)) {
21760 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21761 }
21762 arg1 = static_cast< wxEventType >(val1);
21763 }
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21778 PyObject *resultobj = 0;
21779 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21780 int result;
21781 void *argp1 = 0 ;
21782 int res1 = 0 ;
21783 PyObject *swig_obj[1] ;
21784
21785 if (!args) SWIG_fail;
21786 swig_obj[0] = args;
21787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21788 if (!SWIG_IsOK(res1)) {
21789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21790 }
21791 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21795 wxPyEndAllowThreads(__tstate);
21796 if (PyErr_Occurred()) SWIG_fail;
21797 }
21798 resultobj = SWIG_From_int(static_cast< int >(result));
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21806 PyObject *resultobj = 0;
21807 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21808 bool result;
21809 void *argp1 = 0 ;
21810 int res1 = 0 ;
21811 PyObject *swig_obj[1] ;
21812
21813 if (!args) SWIG_fail;
21814 swig_obj[0] = args;
21815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21816 if (!SWIG_IsOK(res1)) {
21817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21818 }
21819 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21820 {
21821 PyThreadState* __tstate = wxPyBeginAllowThreads();
21822 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21823 wxPyEndAllowThreads(__tstate);
21824 if (PyErr_Occurred()) SWIG_fail;
21825 }
21826 {
21827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21828 }
21829 return resultobj;
21830 fail:
21831 return NULL;
21832 }
21833
21834
21835 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21836 PyObject *resultobj = 0;
21837 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21838 bool result;
21839 void *argp1 = 0 ;
21840 int res1 = 0 ;
21841 PyObject *swig_obj[1] ;
21842
21843 if (!args) SWIG_fail;
21844 swig_obj[0] = args;
21845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21846 if (!SWIG_IsOK(res1)) {
21847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21848 }
21849 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21853 wxPyEndAllowThreads(__tstate);
21854 if (PyErr_Occurred()) SWIG_fail;
21855 }
21856 {
21857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21858 }
21859 return resultobj;
21860 fail:
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21866 PyObject *resultobj = 0;
21867 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21868 bool result;
21869 void *argp1 = 0 ;
21870 int res1 = 0 ;
21871 PyObject *swig_obj[1] ;
21872
21873 if (!args) SWIG_fail;
21874 swig_obj[0] = args;
21875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21876 if (!SWIG_IsOK(res1)) {
21877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21878 }
21879 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 {
21887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21888 }
21889 return resultobj;
21890 fail:
21891 return NULL;
21892 }
21893
21894
21895 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21896 PyObject *resultobj = 0;
21897 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21898 bool result;
21899 void *argp1 = 0 ;
21900 int res1 = 0 ;
21901 PyObject *swig_obj[1] ;
21902
21903 if (!args) SWIG_fail;
21904 swig_obj[0] = args;
21905 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21906 if (!SWIG_IsOK(res1)) {
21907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21908 }
21909 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21910 {
21911 PyThreadState* __tstate = wxPyBeginAllowThreads();
21912 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
21913 wxPyEndAllowThreads(__tstate);
21914 if (PyErr_Occurred()) SWIG_fail;
21915 }
21916 {
21917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21918 }
21919 return resultobj;
21920 fail:
21921 return NULL;
21922 }
21923
21924
21925 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21926 PyObject *resultobj = 0;
21927 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21928 bool result;
21929 void *argp1 = 0 ;
21930 int res1 = 0 ;
21931 PyObject *swig_obj[1] ;
21932
21933 if (!args) SWIG_fail;
21934 swig_obj[0] = args;
21935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21936 if (!SWIG_IsOK(res1)) {
21937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21938 }
21939 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21940 {
21941 PyThreadState* __tstate = wxPyBeginAllowThreads();
21942 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
21943 wxPyEndAllowThreads(__tstate);
21944 if (PyErr_Occurred()) SWIG_fail;
21945 }
21946 {
21947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21948 }
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21956 PyObject *resultobj = 0;
21957 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21958 bool result;
21959 void *argp1 = 0 ;
21960 int res1 = 0 ;
21961 PyObject *swig_obj[1] ;
21962
21963 if (!args) SWIG_fail;
21964 swig_obj[0] = args;
21965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21966 if (!SWIG_IsOK(res1)) {
21967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21968 }
21969 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21970 {
21971 PyThreadState* __tstate = wxPyBeginAllowThreads();
21972 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
21973 wxPyEndAllowThreads(__tstate);
21974 if (PyErr_Occurred()) SWIG_fail;
21975 }
21976 {
21977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21978 }
21979 return resultobj;
21980 fail:
21981 return NULL;
21982 }
21983
21984
21985 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21986 PyObject *resultobj = 0;
21987 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21988 int result;
21989 void *argp1 = 0 ;
21990 int res1 = 0 ;
21991 PyObject *swig_obj[1] ;
21992
21993 if (!args) SWIG_fail;
21994 swig_obj[0] = args;
21995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21996 if (!SWIG_IsOK(res1)) {
21997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21998 }
21999 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22000 {
22001 PyThreadState* __tstate = wxPyBeginAllowThreads();
22002 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22003 wxPyEndAllowThreads(__tstate);
22004 if (PyErr_Occurred()) SWIG_fail;
22005 }
22006 resultobj = SWIG_From_int(static_cast< int >(result));
22007 return resultobj;
22008 fail:
22009 return NULL;
22010 }
22011
22012
22013 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22014 PyObject *resultobj = 0;
22015 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22016 int result;
22017 void *argp1 = 0 ;
22018 int res1 = 0 ;
22019 PyObject *swig_obj[1] ;
22020
22021 if (!args) SWIG_fail;
22022 swig_obj[0] = args;
22023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22024 if (!SWIG_IsOK(res1)) {
22025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22026 }
22027 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22028 {
22029 PyThreadState* __tstate = wxPyBeginAllowThreads();
22030 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22031 wxPyEndAllowThreads(__tstate);
22032 if (PyErr_Occurred()) SWIG_fail;
22033 }
22034 resultobj = SWIG_From_int(static_cast< int >(result));
22035 return resultobj;
22036 fail:
22037 return NULL;
22038 }
22039
22040
22041 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22042 PyObject *resultobj = 0;
22043 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22044 unsigned int result;
22045 void *argp1 = 0 ;
22046 int res1 = 0 ;
22047 PyObject *swig_obj[1] ;
22048
22049 if (!args) SWIG_fail;
22050 swig_obj[0] = args;
22051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22052 if (!SWIG_IsOK(res1)) {
22053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22054 }
22055 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22056 {
22057 PyThreadState* __tstate = wxPyBeginAllowThreads();
22058 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22059 wxPyEndAllowThreads(__tstate);
22060 if (PyErr_Occurred()) SWIG_fail;
22061 }
22062 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22063 return resultobj;
22064 fail:
22065 return NULL;
22066 }
22067
22068
22069 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22070 PyObject *resultobj = 0;
22071 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22072 unsigned int result;
22073 void *argp1 = 0 ;
22074 int res1 = 0 ;
22075 PyObject *swig_obj[1] ;
22076
22077 if (!args) SWIG_fail;
22078 swig_obj[0] = args;
22079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22080 if (!SWIG_IsOK(res1)) {
22081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22082 }
22083 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22084 {
22085 PyThreadState* __tstate = wxPyBeginAllowThreads();
22086 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22091 return resultobj;
22092 fail:
22093 return NULL;
22094 }
22095
22096
22097 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22098 PyObject *resultobj = 0;
22099 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22100 wxPoint result;
22101 void *argp1 = 0 ;
22102 int res1 = 0 ;
22103 PyObject *swig_obj[1] ;
22104
22105 if (!args) SWIG_fail;
22106 swig_obj[0] = args;
22107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22108 if (!SWIG_IsOK(res1)) {
22109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22110 }
22111 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22112 {
22113 PyThreadState* __tstate = wxPyBeginAllowThreads();
22114 result = (arg1)->GetPosition();
22115 wxPyEndAllowThreads(__tstate);
22116 if (PyErr_Occurred()) SWIG_fail;
22117 }
22118 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22119 return resultobj;
22120 fail:
22121 return NULL;
22122 }
22123
22124
22125 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22126 PyObject *resultobj = 0;
22127 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22128 long *arg2 = (long *) 0 ;
22129 long *arg3 = (long *) 0 ;
22130 void *argp1 = 0 ;
22131 int res1 = 0 ;
22132 long temp2 ;
22133 int res2 = SWIG_TMPOBJ ;
22134 long temp3 ;
22135 int res3 = SWIG_TMPOBJ ;
22136 PyObject *swig_obj[1] ;
22137
22138 arg2 = &temp2;
22139 arg3 = &temp3;
22140 if (!args) SWIG_fail;
22141 swig_obj[0] = args;
22142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22143 if (!SWIG_IsOK(res1)) {
22144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22145 }
22146 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22147 {
22148 PyThreadState* __tstate = wxPyBeginAllowThreads();
22149 (arg1)->GetPosition(arg2,arg3);
22150 wxPyEndAllowThreads(__tstate);
22151 if (PyErr_Occurred()) SWIG_fail;
22152 }
22153 resultobj = SWIG_Py_Void();
22154 if (SWIG_IsTmpObj(res2)) {
22155 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22156 } else {
22157 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22158 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22159 }
22160 if (SWIG_IsTmpObj(res3)) {
22161 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22162 } else {
22163 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22164 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22165 }
22166 return resultobj;
22167 fail:
22168 return NULL;
22169 }
22170
22171
22172 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22173 PyObject *resultobj = 0;
22174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22175 int result;
22176 void *argp1 = 0 ;
22177 int res1 = 0 ;
22178 PyObject *swig_obj[1] ;
22179
22180 if (!args) SWIG_fail;
22181 swig_obj[0] = args;
22182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22183 if (!SWIG_IsOK(res1)) {
22184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22185 }
22186 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22187 {
22188 PyThreadState* __tstate = wxPyBeginAllowThreads();
22189 result = (int)((wxKeyEvent const *)arg1)->GetX();
22190 wxPyEndAllowThreads(__tstate);
22191 if (PyErr_Occurred()) SWIG_fail;
22192 }
22193 resultobj = SWIG_From_int(static_cast< int >(result));
22194 return resultobj;
22195 fail:
22196 return NULL;
22197 }
22198
22199
22200 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22201 PyObject *resultobj = 0;
22202 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22203 int result;
22204 void *argp1 = 0 ;
22205 int res1 = 0 ;
22206 PyObject *swig_obj[1] ;
22207
22208 if (!args) SWIG_fail;
22209 swig_obj[0] = args;
22210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22211 if (!SWIG_IsOK(res1)) {
22212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22213 }
22214 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22215 {
22216 PyThreadState* __tstate = wxPyBeginAllowThreads();
22217 result = (int)((wxKeyEvent const *)arg1)->GetY();
22218 wxPyEndAllowThreads(__tstate);
22219 if (PyErr_Occurred()) SWIG_fail;
22220 }
22221 resultobj = SWIG_From_int(static_cast< int >(result));
22222 return resultobj;
22223 fail:
22224 return NULL;
22225 }
22226
22227
22228 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22229 PyObject *resultobj = 0;
22230 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22231 int arg2 ;
22232 void *argp1 = 0 ;
22233 int res1 = 0 ;
22234 int val2 ;
22235 int ecode2 = 0 ;
22236 PyObject *swig_obj[2] ;
22237
22238 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22240 if (!SWIG_IsOK(res1)) {
22241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22242 }
22243 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22244 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22245 if (!SWIG_IsOK(ecode2)) {
22246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22247 }
22248 arg2 = static_cast< int >(val2);
22249 if (arg1) (arg1)->m_x = arg2;
22250
22251 resultobj = SWIG_Py_Void();
22252 return resultobj;
22253 fail:
22254 return NULL;
22255 }
22256
22257
22258 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22259 PyObject *resultobj = 0;
22260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22261 int result;
22262 void *argp1 = 0 ;
22263 int res1 = 0 ;
22264 PyObject *swig_obj[1] ;
22265
22266 if (!args) SWIG_fail;
22267 swig_obj[0] = args;
22268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22269 if (!SWIG_IsOK(res1)) {
22270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22271 }
22272 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22273 result = (int) ((arg1)->m_x);
22274 resultobj = SWIG_From_int(static_cast< int >(result));
22275 return resultobj;
22276 fail:
22277 return NULL;
22278 }
22279
22280
22281 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22282 PyObject *resultobj = 0;
22283 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22284 int arg2 ;
22285 void *argp1 = 0 ;
22286 int res1 = 0 ;
22287 int val2 ;
22288 int ecode2 = 0 ;
22289 PyObject *swig_obj[2] ;
22290
22291 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22293 if (!SWIG_IsOK(res1)) {
22294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22295 }
22296 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22297 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22298 if (!SWIG_IsOK(ecode2)) {
22299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22300 }
22301 arg2 = static_cast< int >(val2);
22302 if (arg1) (arg1)->m_y = arg2;
22303
22304 resultobj = SWIG_Py_Void();
22305 return resultobj;
22306 fail:
22307 return NULL;
22308 }
22309
22310
22311 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22312 PyObject *resultobj = 0;
22313 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22314 int result;
22315 void *argp1 = 0 ;
22316 int res1 = 0 ;
22317 PyObject *swig_obj[1] ;
22318
22319 if (!args) SWIG_fail;
22320 swig_obj[0] = args;
22321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22322 if (!SWIG_IsOK(res1)) {
22323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22324 }
22325 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22326 result = (int) ((arg1)->m_y);
22327 resultobj = SWIG_From_int(static_cast< int >(result));
22328 return resultobj;
22329 fail:
22330 return NULL;
22331 }
22332
22333
22334 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22335 PyObject *resultobj = 0;
22336 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22337 long arg2 ;
22338 void *argp1 = 0 ;
22339 int res1 = 0 ;
22340 long val2 ;
22341 int ecode2 = 0 ;
22342 PyObject *swig_obj[2] ;
22343
22344 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22346 if (!SWIG_IsOK(res1)) {
22347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22348 }
22349 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22350 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22351 if (!SWIG_IsOK(ecode2)) {
22352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22353 }
22354 arg2 = static_cast< long >(val2);
22355 if (arg1) (arg1)->m_keyCode = arg2;
22356
22357 resultobj = SWIG_Py_Void();
22358 return resultobj;
22359 fail:
22360 return NULL;
22361 }
22362
22363
22364 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22365 PyObject *resultobj = 0;
22366 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22367 long result;
22368 void *argp1 = 0 ;
22369 int res1 = 0 ;
22370 PyObject *swig_obj[1] ;
22371
22372 if (!args) SWIG_fail;
22373 swig_obj[0] = args;
22374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22375 if (!SWIG_IsOK(res1)) {
22376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22377 }
22378 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22379 result = (long) ((arg1)->m_keyCode);
22380 resultobj = SWIG_From_long(static_cast< long >(result));
22381 return resultobj;
22382 fail:
22383 return NULL;
22384 }
22385
22386
22387 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22388 PyObject *resultobj = 0;
22389 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22390 bool arg2 ;
22391 void *argp1 = 0 ;
22392 int res1 = 0 ;
22393 bool val2 ;
22394 int ecode2 = 0 ;
22395 PyObject *swig_obj[2] ;
22396
22397 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22399 if (!SWIG_IsOK(res1)) {
22400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22401 }
22402 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22403 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22404 if (!SWIG_IsOK(ecode2)) {
22405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22406 }
22407 arg2 = static_cast< bool >(val2);
22408 if (arg1) (arg1)->m_controlDown = arg2;
22409
22410 resultobj = SWIG_Py_Void();
22411 return resultobj;
22412 fail:
22413 return NULL;
22414 }
22415
22416
22417 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22418 PyObject *resultobj = 0;
22419 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22420 bool result;
22421 void *argp1 = 0 ;
22422 int res1 = 0 ;
22423 PyObject *swig_obj[1] ;
22424
22425 if (!args) SWIG_fail;
22426 swig_obj[0] = args;
22427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22428 if (!SWIG_IsOK(res1)) {
22429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22430 }
22431 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22432 result = (bool) ((arg1)->m_controlDown);
22433 {
22434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22435 }
22436 return resultobj;
22437 fail:
22438 return NULL;
22439 }
22440
22441
22442 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22443 PyObject *resultobj = 0;
22444 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22445 bool arg2 ;
22446 void *argp1 = 0 ;
22447 int res1 = 0 ;
22448 bool val2 ;
22449 int ecode2 = 0 ;
22450 PyObject *swig_obj[2] ;
22451
22452 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22454 if (!SWIG_IsOK(res1)) {
22455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22456 }
22457 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22458 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22459 if (!SWIG_IsOK(ecode2)) {
22460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22461 }
22462 arg2 = static_cast< bool >(val2);
22463 if (arg1) (arg1)->m_shiftDown = arg2;
22464
22465 resultobj = SWIG_Py_Void();
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22473 PyObject *resultobj = 0;
22474 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22475 bool result;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 PyObject *swig_obj[1] ;
22479
22480 if (!args) SWIG_fail;
22481 swig_obj[0] = args;
22482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22483 if (!SWIG_IsOK(res1)) {
22484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22485 }
22486 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22487 result = (bool) ((arg1)->m_shiftDown);
22488 {
22489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22490 }
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22500 bool arg2 ;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 bool val2 ;
22504 int ecode2 = 0 ;
22505 PyObject *swig_obj[2] ;
22506
22507 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22514 if (!SWIG_IsOK(ecode2)) {
22515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22516 }
22517 arg2 = static_cast< bool >(val2);
22518 if (arg1) (arg1)->m_altDown = arg2;
22519
22520 resultobj = SWIG_Py_Void();
22521 return resultobj;
22522 fail:
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *resultobj = 0;
22529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22530 bool result;
22531 void *argp1 = 0 ;
22532 int res1 = 0 ;
22533 PyObject *swig_obj[1] ;
22534
22535 if (!args) SWIG_fail;
22536 swig_obj[0] = args;
22537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 result = (bool) ((arg1)->m_altDown);
22543 {
22544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22545 }
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22553 PyObject *resultobj = 0;
22554 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22555 bool arg2 ;
22556 void *argp1 = 0 ;
22557 int res1 = 0 ;
22558 bool val2 ;
22559 int ecode2 = 0 ;
22560 PyObject *swig_obj[2] ;
22561
22562 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22564 if (!SWIG_IsOK(res1)) {
22565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22566 }
22567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22568 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22569 if (!SWIG_IsOK(ecode2)) {
22570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22571 }
22572 arg2 = static_cast< bool >(val2);
22573 if (arg1) (arg1)->m_metaDown = arg2;
22574
22575 resultobj = SWIG_Py_Void();
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 bool result;
22586 void *argp1 = 0 ;
22587 int res1 = 0 ;
22588 PyObject *swig_obj[1] ;
22589
22590 if (!args) SWIG_fail;
22591 swig_obj[0] = args;
22592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22593 if (!SWIG_IsOK(res1)) {
22594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22595 }
22596 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22597 result = (bool) ((arg1)->m_metaDown);
22598 {
22599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22600 }
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22608 PyObject *resultobj = 0;
22609 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22610 bool arg2 ;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 bool val2 ;
22614 int ecode2 = 0 ;
22615 PyObject *swig_obj[2] ;
22616
22617 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22621 }
22622 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22623 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22624 if (!SWIG_IsOK(ecode2)) {
22625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22626 }
22627 arg2 = static_cast< bool >(val2);
22628 if (arg1) (arg1)->m_scanCode = arg2;
22629
22630 resultobj = SWIG_Py_Void();
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22638 PyObject *resultobj = 0;
22639 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22640 bool result;
22641 void *argp1 = 0 ;
22642 int res1 = 0 ;
22643 PyObject *swig_obj[1] ;
22644
22645 if (!args) SWIG_fail;
22646 swig_obj[0] = args;
22647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22648 if (!SWIG_IsOK(res1)) {
22649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22650 }
22651 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22652 result = (bool) ((arg1)->m_scanCode);
22653 {
22654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22655 }
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22665 unsigned int arg2 ;
22666 void *argp1 = 0 ;
22667 int res1 = 0 ;
22668 unsigned int val2 ;
22669 int ecode2 = 0 ;
22670 PyObject *swig_obj[2] ;
22671
22672 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22674 if (!SWIG_IsOK(res1)) {
22675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22676 }
22677 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22678 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22679 if (!SWIG_IsOK(ecode2)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22681 }
22682 arg2 = static_cast< unsigned int >(val2);
22683 if (arg1) (arg1)->m_rawCode = arg2;
22684
22685 resultobj = SWIG_Py_Void();
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22695 unsigned int result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22707 result = (unsigned int) ((arg1)->m_rawCode);
22708 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22709 return resultobj;
22710 fail:
22711 return NULL;
22712 }
22713
22714
22715 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22716 PyObject *resultobj = 0;
22717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22718 unsigned int arg2 ;
22719 void *argp1 = 0 ;
22720 int res1 = 0 ;
22721 unsigned int val2 ;
22722 int ecode2 = 0 ;
22723 PyObject *swig_obj[2] ;
22724
22725 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22727 if (!SWIG_IsOK(res1)) {
22728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22729 }
22730 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22731 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22732 if (!SWIG_IsOK(ecode2)) {
22733 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22734 }
22735 arg2 = static_cast< unsigned int >(val2);
22736 if (arg1) (arg1)->m_rawFlags = arg2;
22737
22738 resultobj = SWIG_Py_Void();
22739 return resultobj;
22740 fail:
22741 return NULL;
22742 }
22743
22744
22745 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22746 PyObject *resultobj = 0;
22747 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22748 unsigned int result;
22749 void *argp1 = 0 ;
22750 int res1 = 0 ;
22751 PyObject *swig_obj[1] ;
22752
22753 if (!args) SWIG_fail;
22754 swig_obj[0] = args;
22755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22756 if (!SWIG_IsOK(res1)) {
22757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22758 }
22759 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22760 result = (unsigned int) ((arg1)->m_rawFlags);
22761 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22762 return resultobj;
22763 fail:
22764 return NULL;
22765 }
22766
22767
22768 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22769 PyObject *obj;
22770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22771 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22772 return SWIG_Py_Void();
22773 }
22774
22775 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22776 return SWIG_Python_InitShadowInstance(args);
22777 }
22778
22779 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22780 PyObject *resultobj = 0;
22781 wxSize const &arg1_defvalue = wxDefaultSize ;
22782 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22783 int arg2 = (int) 0 ;
22784 wxSizeEvent *result = 0 ;
22785 wxSize temp1 ;
22786 int val2 ;
22787 int ecode2 = 0 ;
22788 PyObject * obj0 = 0 ;
22789 PyObject * obj1 = 0 ;
22790 char * kwnames[] = {
22791 (char *) "sz",(char *) "winid", NULL
22792 };
22793
22794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22795 if (obj0) {
22796 {
22797 arg1 = &temp1;
22798 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22799 }
22800 }
22801 if (obj1) {
22802 ecode2 = SWIG_AsVal_int(obj1, &val2);
22803 if (!SWIG_IsOK(ecode2)) {
22804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22805 }
22806 arg2 = static_cast< int >(val2);
22807 }
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22815 return resultobj;
22816 fail:
22817 return NULL;
22818 }
22819
22820
22821 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22822 PyObject *resultobj = 0;
22823 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22824 wxSize result;
22825 void *argp1 = 0 ;
22826 int res1 = 0 ;
22827 PyObject *swig_obj[1] ;
22828
22829 if (!args) SWIG_fail;
22830 swig_obj[0] = args;
22831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22832 if (!SWIG_IsOK(res1)) {
22833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22834 }
22835 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22836 {
22837 PyThreadState* __tstate = wxPyBeginAllowThreads();
22838 result = ((wxSizeEvent const *)arg1)->GetSize();
22839 wxPyEndAllowThreads(__tstate);
22840 if (PyErr_Occurred()) SWIG_fail;
22841 }
22842 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22843 return resultobj;
22844 fail:
22845 return NULL;
22846 }
22847
22848
22849 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22850 PyObject *resultobj = 0;
22851 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22852 wxRect result;
22853 void *argp1 = 0 ;
22854 int res1 = 0 ;
22855 PyObject *swig_obj[1] ;
22856
22857 if (!args) SWIG_fail;
22858 swig_obj[0] = args;
22859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22860 if (!SWIG_IsOK(res1)) {
22861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22862 }
22863 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22864 {
22865 PyThreadState* __tstate = wxPyBeginAllowThreads();
22866 result = ((wxSizeEvent const *)arg1)->GetRect();
22867 wxPyEndAllowThreads(__tstate);
22868 if (PyErr_Occurred()) SWIG_fail;
22869 }
22870 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22871 return resultobj;
22872 fail:
22873 return NULL;
22874 }
22875
22876
22877 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22878 PyObject *resultobj = 0;
22879 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22880 wxRect arg2 ;
22881 void *argp1 = 0 ;
22882 int res1 = 0 ;
22883 void *argp2 ;
22884 int res2 = 0 ;
22885 PyObject * obj0 = 0 ;
22886 PyObject * obj1 = 0 ;
22887 char * kwnames[] = {
22888 (char *) "self",(char *) "rect", NULL
22889 };
22890
22891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
22892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22893 if (!SWIG_IsOK(res1)) {
22894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22895 }
22896 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22897 {
22898 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
22899 if (!SWIG_IsOK(res2)) {
22900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22901 }
22902 if (!argp2) {
22903 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
22904 } else {
22905 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
22906 arg2 = *temp;
22907 if (SWIG_IsNewObj(res2)) delete temp;
22908 }
22909 }
22910 {
22911 PyThreadState* __tstate = wxPyBeginAllowThreads();
22912 (arg1)->SetRect(arg2);
22913 wxPyEndAllowThreads(__tstate);
22914 if (PyErr_Occurred()) SWIG_fail;
22915 }
22916 resultobj = SWIG_Py_Void();
22917 return resultobj;
22918 fail:
22919 return NULL;
22920 }
22921
22922
22923 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22924 PyObject *resultobj = 0;
22925 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22926 wxSize arg2 ;
22927 void *argp1 = 0 ;
22928 int res1 = 0 ;
22929 void *argp2 ;
22930 int res2 = 0 ;
22931 PyObject * obj0 = 0 ;
22932 PyObject * obj1 = 0 ;
22933 char * kwnames[] = {
22934 (char *) "self",(char *) "size", NULL
22935 };
22936
22937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
22938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22939 if (!SWIG_IsOK(res1)) {
22940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22941 }
22942 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22943 {
22944 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
22945 if (!SWIG_IsOK(res2)) {
22946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22947 }
22948 if (!argp2) {
22949 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
22950 } else {
22951 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
22952 arg2 = *temp;
22953 if (SWIG_IsNewObj(res2)) delete temp;
22954 }
22955 }
22956 {
22957 PyThreadState* __tstate = wxPyBeginAllowThreads();
22958 wxSizeEvent_SetSize(arg1,arg2);
22959 wxPyEndAllowThreads(__tstate);
22960 if (PyErr_Occurred()) SWIG_fail;
22961 }
22962 resultobj = SWIG_Py_Void();
22963 return resultobj;
22964 fail:
22965 return NULL;
22966 }
22967
22968
22969 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22970 PyObject *resultobj = 0;
22971 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22972 wxSize *arg2 = (wxSize *) 0 ;
22973 void *argp1 = 0 ;
22974 int res1 = 0 ;
22975 void *argp2 = 0 ;
22976 int res2 = 0 ;
22977 PyObject *swig_obj[2] ;
22978
22979 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
22980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22981 if (!SWIG_IsOK(res1)) {
22982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
22983 }
22984 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22985 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
22986 if (!SWIG_IsOK(res2)) {
22987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
22988 }
22989 arg2 = reinterpret_cast< wxSize * >(argp2);
22990 if (arg1) (arg1)->m_size = *arg2;
22991
22992 resultobj = SWIG_Py_Void();
22993 return resultobj;
22994 fail:
22995 return NULL;
22996 }
22997
22998
22999 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23000 PyObject *resultobj = 0;
23001 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23002 wxSize *result = 0 ;
23003 void *argp1 = 0 ;
23004 int res1 = 0 ;
23005 PyObject *swig_obj[1] ;
23006
23007 if (!args) SWIG_fail;
23008 swig_obj[0] = args;
23009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23010 if (!SWIG_IsOK(res1)) {
23011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23012 }
23013 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23014 result = (wxSize *)& ((arg1)->m_size);
23015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23016 return resultobj;
23017 fail:
23018 return NULL;
23019 }
23020
23021
23022 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23023 PyObject *resultobj = 0;
23024 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23025 wxRect *arg2 = (wxRect *) 0 ;
23026 void *argp1 = 0 ;
23027 int res1 = 0 ;
23028 void *argp2 = 0 ;
23029 int res2 = 0 ;
23030 PyObject *swig_obj[2] ;
23031
23032 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23034 if (!SWIG_IsOK(res1)) {
23035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23036 }
23037 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23038 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23039 if (!SWIG_IsOK(res2)) {
23040 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23041 }
23042 arg2 = reinterpret_cast< wxRect * >(argp2);
23043 if (arg1) (arg1)->m_rect = *arg2;
23044
23045 resultobj = SWIG_Py_Void();
23046 return resultobj;
23047 fail:
23048 return NULL;
23049 }
23050
23051
23052 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23053 PyObject *resultobj = 0;
23054 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23055 wxRect *result = 0 ;
23056 void *argp1 = 0 ;
23057 int res1 = 0 ;
23058 PyObject *swig_obj[1] ;
23059
23060 if (!args) SWIG_fail;
23061 swig_obj[0] = args;
23062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23063 if (!SWIG_IsOK(res1)) {
23064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23065 }
23066 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23067 result = (wxRect *)& ((arg1)->m_rect);
23068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23069 return resultobj;
23070 fail:
23071 return NULL;
23072 }
23073
23074
23075 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23076 PyObject *obj;
23077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23078 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23079 return SWIG_Py_Void();
23080 }
23081
23082 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23083 return SWIG_Python_InitShadowInstance(args);
23084 }
23085
23086 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23087 PyObject *resultobj = 0;
23088 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23089 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23090 int arg2 = (int) 0 ;
23091 wxMoveEvent *result = 0 ;
23092 wxPoint temp1 ;
23093 int val2 ;
23094 int ecode2 = 0 ;
23095 PyObject * obj0 = 0 ;
23096 PyObject * obj1 = 0 ;
23097 char * kwnames[] = {
23098 (char *) "pos",(char *) "winid", NULL
23099 };
23100
23101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23102 if (obj0) {
23103 {
23104 arg1 = &temp1;
23105 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23106 }
23107 }
23108 if (obj1) {
23109 ecode2 = SWIG_AsVal_int(obj1, &val2);
23110 if (!SWIG_IsOK(ecode2)) {
23111 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23112 }
23113 arg2 = static_cast< int >(val2);
23114 }
23115 {
23116 PyThreadState* __tstate = wxPyBeginAllowThreads();
23117 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23118 wxPyEndAllowThreads(__tstate);
23119 if (PyErr_Occurred()) SWIG_fail;
23120 }
23121 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23122 return resultobj;
23123 fail:
23124 return NULL;
23125 }
23126
23127
23128 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23129 PyObject *resultobj = 0;
23130 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23131 wxPoint result;
23132 void *argp1 = 0 ;
23133 int res1 = 0 ;
23134 PyObject *swig_obj[1] ;
23135
23136 if (!args) SWIG_fail;
23137 swig_obj[0] = args;
23138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23139 if (!SWIG_IsOK(res1)) {
23140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23141 }
23142 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23143 {
23144 PyThreadState* __tstate = wxPyBeginAllowThreads();
23145 result = ((wxMoveEvent const *)arg1)->GetPosition();
23146 wxPyEndAllowThreads(__tstate);
23147 if (PyErr_Occurred()) SWIG_fail;
23148 }
23149 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23150 return resultobj;
23151 fail:
23152 return NULL;
23153 }
23154
23155
23156 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23157 PyObject *resultobj = 0;
23158 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23159 wxRect result;
23160 void *argp1 = 0 ;
23161 int res1 = 0 ;
23162 PyObject *swig_obj[1] ;
23163
23164 if (!args) SWIG_fail;
23165 swig_obj[0] = args;
23166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23167 if (!SWIG_IsOK(res1)) {
23168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23169 }
23170 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23171 {
23172 PyThreadState* __tstate = wxPyBeginAllowThreads();
23173 result = ((wxMoveEvent const *)arg1)->GetRect();
23174 wxPyEndAllowThreads(__tstate);
23175 if (PyErr_Occurred()) SWIG_fail;
23176 }
23177 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23185 PyObject *resultobj = 0;
23186 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23187 wxRect *arg2 = 0 ;
23188 void *argp1 = 0 ;
23189 int res1 = 0 ;
23190 wxRect temp2 ;
23191 PyObject * obj0 = 0 ;
23192 PyObject * obj1 = 0 ;
23193 char * kwnames[] = {
23194 (char *) "self",(char *) "rect", NULL
23195 };
23196
23197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23199 if (!SWIG_IsOK(res1)) {
23200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23201 }
23202 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23203 {
23204 arg2 = &temp2;
23205 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23206 }
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 (arg1)->SetRect((wxRect const &)*arg2);
23210 wxPyEndAllowThreads(__tstate);
23211 if (PyErr_Occurred()) SWIG_fail;
23212 }
23213 resultobj = SWIG_Py_Void();
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj = 0;
23222 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23223 wxPoint *arg2 = 0 ;
23224 void *argp1 = 0 ;
23225 int res1 = 0 ;
23226 wxPoint temp2 ;
23227 PyObject * obj0 = 0 ;
23228 PyObject * obj1 = 0 ;
23229 char * kwnames[] = {
23230 (char *) "self",(char *) "pos", NULL
23231 };
23232
23233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23235 if (!SWIG_IsOK(res1)) {
23236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23237 }
23238 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23239 {
23240 arg2 = &temp2;
23241 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23242 }
23243 {
23244 PyThreadState* __tstate = wxPyBeginAllowThreads();
23245 (arg1)->SetPosition((wxPoint const &)*arg2);
23246 wxPyEndAllowThreads(__tstate);
23247 if (PyErr_Occurred()) SWIG_fail;
23248 }
23249 resultobj = SWIG_Py_Void();
23250 return resultobj;
23251 fail:
23252 return NULL;
23253 }
23254
23255
23256 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23257 PyObject *obj;
23258 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23259 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23260 return SWIG_Py_Void();
23261 }
23262
23263 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23264 return SWIG_Python_InitShadowInstance(args);
23265 }
23266
23267 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23268 PyObject *resultobj = 0;
23269 int arg1 = (int) 0 ;
23270 wxPaintEvent *result = 0 ;
23271 int val1 ;
23272 int ecode1 = 0 ;
23273 PyObject * obj0 = 0 ;
23274 char * kwnames[] = {
23275 (char *) "Id", NULL
23276 };
23277
23278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23279 if (obj0) {
23280 ecode1 = SWIG_AsVal_int(obj0, &val1);
23281 if (!SWIG_IsOK(ecode1)) {
23282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23283 }
23284 arg1 = static_cast< int >(val1);
23285 }
23286 {
23287 PyThreadState* __tstate = wxPyBeginAllowThreads();
23288 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23289 wxPyEndAllowThreads(__tstate);
23290 if (PyErr_Occurred()) SWIG_fail;
23291 }
23292 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23293 return resultobj;
23294 fail:
23295 return NULL;
23296 }
23297
23298
23299 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23300 PyObject *obj;
23301 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23302 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23303 return SWIG_Py_Void();
23304 }
23305
23306 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23307 return SWIG_Python_InitShadowInstance(args);
23308 }
23309
23310 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23311 PyObject *resultobj = 0;
23312 int arg1 = (int) 0 ;
23313 wxNcPaintEvent *result = 0 ;
23314 int val1 ;
23315 int ecode1 = 0 ;
23316 PyObject * obj0 = 0 ;
23317 char * kwnames[] = {
23318 (char *) "winid", NULL
23319 };
23320
23321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23322 if (obj0) {
23323 ecode1 = SWIG_AsVal_int(obj0, &val1);
23324 if (!SWIG_IsOK(ecode1)) {
23325 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23326 }
23327 arg1 = static_cast< int >(val1);
23328 }
23329 {
23330 PyThreadState* __tstate = wxPyBeginAllowThreads();
23331 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23332 wxPyEndAllowThreads(__tstate);
23333 if (PyErr_Occurred()) SWIG_fail;
23334 }
23335 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23336 return resultobj;
23337 fail:
23338 return NULL;
23339 }
23340
23341
23342 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23343 PyObject *obj;
23344 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23345 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23346 return SWIG_Py_Void();
23347 }
23348
23349 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23350 return SWIG_Python_InitShadowInstance(args);
23351 }
23352
23353 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23354 PyObject *resultobj = 0;
23355 int arg1 = (int) 0 ;
23356 wxDC *arg2 = (wxDC *) NULL ;
23357 wxEraseEvent *result = 0 ;
23358 int val1 ;
23359 int ecode1 = 0 ;
23360 void *argp2 = 0 ;
23361 int res2 = 0 ;
23362 PyObject * obj0 = 0 ;
23363 PyObject * obj1 = 0 ;
23364 char * kwnames[] = {
23365 (char *) "Id",(char *) "dc", NULL
23366 };
23367
23368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23369 if (obj0) {
23370 ecode1 = SWIG_AsVal_int(obj0, &val1);
23371 if (!SWIG_IsOK(ecode1)) {
23372 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23373 }
23374 arg1 = static_cast< int >(val1);
23375 }
23376 if (obj1) {
23377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23378 if (!SWIG_IsOK(res2)) {
23379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23380 }
23381 arg2 = reinterpret_cast< wxDC * >(argp2);
23382 }
23383 {
23384 PyThreadState* __tstate = wxPyBeginAllowThreads();
23385 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23386 wxPyEndAllowThreads(__tstate);
23387 if (PyErr_Occurred()) SWIG_fail;
23388 }
23389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23390 return resultobj;
23391 fail:
23392 return NULL;
23393 }
23394
23395
23396 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23397 PyObject *resultobj = 0;
23398 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23399 wxDC *result = 0 ;
23400 void *argp1 = 0 ;
23401 int res1 = 0 ;
23402 PyObject *swig_obj[1] ;
23403
23404 if (!args) SWIG_fail;
23405 swig_obj[0] = args;
23406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23407 if (!SWIG_IsOK(res1)) {
23408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23409 }
23410 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23411 {
23412 PyThreadState* __tstate = wxPyBeginAllowThreads();
23413 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23414 wxPyEndAllowThreads(__tstate);
23415 if (PyErr_Occurred()) SWIG_fail;
23416 }
23417 {
23418 resultobj = wxPyMake_wxObject(result, (bool)0);
23419 }
23420 return resultobj;
23421 fail:
23422 return NULL;
23423 }
23424
23425
23426 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23427 PyObject *obj;
23428 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23429 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23430 return SWIG_Py_Void();
23431 }
23432
23433 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23434 return SWIG_Python_InitShadowInstance(args);
23435 }
23436
23437 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23438 PyObject *resultobj = 0;
23439 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23440 int arg2 = (int) 0 ;
23441 wxFocusEvent *result = 0 ;
23442 int val1 ;
23443 int ecode1 = 0 ;
23444 int val2 ;
23445 int ecode2 = 0 ;
23446 PyObject * obj0 = 0 ;
23447 PyObject * obj1 = 0 ;
23448 char * kwnames[] = {
23449 (char *) "type",(char *) "winid", NULL
23450 };
23451
23452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23453 if (obj0) {
23454 ecode1 = SWIG_AsVal_int(obj0, &val1);
23455 if (!SWIG_IsOK(ecode1)) {
23456 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23457 }
23458 arg1 = static_cast< wxEventType >(val1);
23459 }
23460 if (obj1) {
23461 ecode2 = SWIG_AsVal_int(obj1, &val2);
23462 if (!SWIG_IsOK(ecode2)) {
23463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23464 }
23465 arg2 = static_cast< int >(val2);
23466 }
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23481 PyObject *resultobj = 0;
23482 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23483 wxWindow *result = 0 ;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 PyObject *swig_obj[1] ;
23487
23488 if (!args) SWIG_fail;
23489 swig_obj[0] = args;
23490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23491 if (!SWIG_IsOK(res1)) {
23492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23493 }
23494 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23495 {
23496 PyThreadState* __tstate = wxPyBeginAllowThreads();
23497 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23498 wxPyEndAllowThreads(__tstate);
23499 if (PyErr_Occurred()) SWIG_fail;
23500 }
23501 {
23502 resultobj = wxPyMake_wxObject(result, (bool)0);
23503 }
23504 return resultobj;
23505 fail:
23506 return NULL;
23507 }
23508
23509
23510 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23511 PyObject *resultobj = 0;
23512 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23513 wxWindow *arg2 = (wxWindow *) 0 ;
23514 void *argp1 = 0 ;
23515 int res1 = 0 ;
23516 void *argp2 = 0 ;
23517 int res2 = 0 ;
23518 PyObject * obj0 = 0 ;
23519 PyObject * obj1 = 0 ;
23520 char * kwnames[] = {
23521 (char *) "self",(char *) "win", NULL
23522 };
23523
23524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23525 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23526 if (!SWIG_IsOK(res1)) {
23527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23528 }
23529 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23530 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23531 if (!SWIG_IsOK(res2)) {
23532 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23533 }
23534 arg2 = reinterpret_cast< wxWindow * >(argp2);
23535 {
23536 PyThreadState* __tstate = wxPyBeginAllowThreads();
23537 (arg1)->SetWindow(arg2);
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 resultobj = SWIG_Py_Void();
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23549 PyObject *obj;
23550 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23551 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23552 return SWIG_Py_Void();
23553 }
23554
23555 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23556 return SWIG_Python_InitShadowInstance(args);
23557 }
23558
23559 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23560 PyObject *resultobj = 0;
23561 wxWindow *arg1 = (wxWindow *) NULL ;
23562 wxChildFocusEvent *result = 0 ;
23563 void *argp1 = 0 ;
23564 int res1 = 0 ;
23565 PyObject * obj0 = 0 ;
23566 char * kwnames[] = {
23567 (char *) "win", NULL
23568 };
23569
23570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23571 if (obj0) {
23572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23573 if (!SWIG_IsOK(res1)) {
23574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23575 }
23576 arg1 = reinterpret_cast< wxWindow * >(argp1);
23577 }
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23581 wxPyEndAllowThreads(__tstate);
23582 if (PyErr_Occurred()) SWIG_fail;
23583 }
23584 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23592 PyObject *resultobj = 0;
23593 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23594 wxWindow *result = 0 ;
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_wxChildFocusEvent, 0 | 0 );
23602 if (!SWIG_IsOK(res1)) {
23603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23604 }
23605 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23606 {
23607 PyThreadState* __tstate = wxPyBeginAllowThreads();
23608 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23609 wxPyEndAllowThreads(__tstate);
23610 if (PyErr_Occurred()) SWIG_fail;
23611 }
23612 {
23613 resultobj = wxPyMake_wxObject(result, (bool)0);
23614 }
23615 return resultobj;
23616 fail:
23617 return NULL;
23618 }
23619
23620
23621 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23622 PyObject *obj;
23623 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23624 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23625 return SWIG_Py_Void();
23626 }
23627
23628 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23629 return SWIG_Python_InitShadowInstance(args);
23630 }
23631
23632 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23633 PyObject *resultobj = 0;
23634 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23635 bool arg2 = (bool) true ;
23636 int arg3 = (int) 0 ;
23637 wxActivateEvent *result = 0 ;
23638 int val1 ;
23639 int ecode1 = 0 ;
23640 bool val2 ;
23641 int ecode2 = 0 ;
23642 int val3 ;
23643 int ecode3 = 0 ;
23644 PyObject * obj0 = 0 ;
23645 PyObject * obj1 = 0 ;
23646 PyObject * obj2 = 0 ;
23647 char * kwnames[] = {
23648 (char *) "type",(char *) "active",(char *) "Id", NULL
23649 };
23650
23651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23652 if (obj0) {
23653 ecode1 = SWIG_AsVal_int(obj0, &val1);
23654 if (!SWIG_IsOK(ecode1)) {
23655 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23656 }
23657 arg1 = static_cast< wxEventType >(val1);
23658 }
23659 if (obj1) {
23660 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23661 if (!SWIG_IsOK(ecode2)) {
23662 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23663 }
23664 arg2 = static_cast< bool >(val2);
23665 }
23666 if (obj2) {
23667 ecode3 = SWIG_AsVal_int(obj2, &val3);
23668 if (!SWIG_IsOK(ecode3)) {
23669 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23670 }
23671 arg3 = static_cast< int >(val3);
23672 }
23673 {
23674 PyThreadState* __tstate = wxPyBeginAllowThreads();
23675 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23676 wxPyEndAllowThreads(__tstate);
23677 if (PyErr_Occurred()) SWIG_fail;
23678 }
23679 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23687 PyObject *resultobj = 0;
23688 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23689 bool result;
23690 void *argp1 = 0 ;
23691 int res1 = 0 ;
23692 PyObject *swig_obj[1] ;
23693
23694 if (!args) SWIG_fail;
23695 swig_obj[0] = args;
23696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23697 if (!SWIG_IsOK(res1)) {
23698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23699 }
23700 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23701 {
23702 PyThreadState* __tstate = wxPyBeginAllowThreads();
23703 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23704 wxPyEndAllowThreads(__tstate);
23705 if (PyErr_Occurred()) SWIG_fail;
23706 }
23707 {
23708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23709 }
23710 return resultobj;
23711 fail:
23712 return NULL;
23713 }
23714
23715
23716 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23717 PyObject *obj;
23718 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23719 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23720 return SWIG_Py_Void();
23721 }
23722
23723 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23724 return SWIG_Python_InitShadowInstance(args);
23725 }
23726
23727 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23728 PyObject *resultobj = 0;
23729 int arg1 = (int) 0 ;
23730 wxInitDialogEvent *result = 0 ;
23731 int val1 ;
23732 int ecode1 = 0 ;
23733 PyObject * obj0 = 0 ;
23734 char * kwnames[] = {
23735 (char *) "Id", NULL
23736 };
23737
23738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23739 if (obj0) {
23740 ecode1 = SWIG_AsVal_int(obj0, &val1);
23741 if (!SWIG_IsOK(ecode1)) {
23742 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23743 }
23744 arg1 = static_cast< int >(val1);
23745 }
23746 {
23747 PyThreadState* __tstate = wxPyBeginAllowThreads();
23748 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23749 wxPyEndAllowThreads(__tstate);
23750 if (PyErr_Occurred()) SWIG_fail;
23751 }
23752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23753 return resultobj;
23754 fail:
23755 return NULL;
23756 }
23757
23758
23759 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23760 PyObject *obj;
23761 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23762 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23763 return SWIG_Py_Void();
23764 }
23765
23766 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23767 return SWIG_Python_InitShadowInstance(args);
23768 }
23769
23770 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj = 0;
23772 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23773 int arg2 = (int) 0 ;
23774 wxMenu *arg3 = (wxMenu *) NULL ;
23775 wxMenuEvent *result = 0 ;
23776 int val1 ;
23777 int ecode1 = 0 ;
23778 int val2 ;
23779 int ecode2 = 0 ;
23780 void *argp3 = 0 ;
23781 int res3 = 0 ;
23782 PyObject * obj0 = 0 ;
23783 PyObject * obj1 = 0 ;
23784 PyObject * obj2 = 0 ;
23785 char * kwnames[] = {
23786 (char *) "type",(char *) "winid",(char *) "menu", NULL
23787 };
23788
23789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23790 if (obj0) {
23791 ecode1 = SWIG_AsVal_int(obj0, &val1);
23792 if (!SWIG_IsOK(ecode1)) {
23793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23794 }
23795 arg1 = static_cast< wxEventType >(val1);
23796 }
23797 if (obj1) {
23798 ecode2 = SWIG_AsVal_int(obj1, &val2);
23799 if (!SWIG_IsOK(ecode2)) {
23800 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23801 }
23802 arg2 = static_cast< int >(val2);
23803 }
23804 if (obj2) {
23805 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23806 if (!SWIG_IsOK(res3)) {
23807 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23808 }
23809 arg3 = reinterpret_cast< wxMenu * >(argp3);
23810 }
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23818 return resultobj;
23819 fail:
23820 return NULL;
23821 }
23822
23823
23824 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23825 PyObject *resultobj = 0;
23826 wxMenuEvent *arg1 = (wxMenuEvent *) 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_wxMenuEvent, 0 | 0 );
23835 if (!SWIG_IsOK(res1)) {
23836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23837 }
23838 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23839 {
23840 PyThreadState* __tstate = wxPyBeginAllowThreads();
23841 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
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_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23853 PyObject *resultobj = 0;
23854 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23855 bool 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_wxMenuEvent, 0 | 0 );
23863 if (!SWIG_IsOK(res1)) {
23864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23865 }
23866 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23867 {
23868 PyThreadState* __tstate = wxPyBeginAllowThreads();
23869 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23870 wxPyEndAllowThreads(__tstate);
23871 if (PyErr_Occurred()) SWIG_fail;
23872 }
23873 {
23874 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23875 }
23876 return resultobj;
23877 fail:
23878 return NULL;
23879 }
23880
23881
23882 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23883 PyObject *resultobj = 0;
23884 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23885 wxMenu *result = 0 ;
23886 void *argp1 = 0 ;
23887 int res1 = 0 ;
23888 PyObject *swig_obj[1] ;
23889
23890 if (!args) SWIG_fail;
23891 swig_obj[0] = args;
23892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23893 if (!SWIG_IsOK(res1)) {
23894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23895 }
23896 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23897 {
23898 PyThreadState* __tstate = wxPyBeginAllowThreads();
23899 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
23900 wxPyEndAllowThreads(__tstate);
23901 if (PyErr_Occurred()) SWIG_fail;
23902 }
23903 {
23904 resultobj = wxPyMake_wxObject(result, (bool)0);
23905 }
23906 return resultobj;
23907 fail:
23908 return NULL;
23909 }
23910
23911
23912 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23913 PyObject *obj;
23914 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23915 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
23916 return SWIG_Py_Void();
23917 }
23918
23919 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23920 return SWIG_Python_InitShadowInstance(args);
23921 }
23922
23923 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23924 PyObject *resultobj = 0;
23925 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23926 int arg2 = (int) 0 ;
23927 wxCloseEvent *result = 0 ;
23928 int val1 ;
23929 int ecode1 = 0 ;
23930 int val2 ;
23931 int ecode2 = 0 ;
23932 PyObject * obj0 = 0 ;
23933 PyObject * obj1 = 0 ;
23934 char * kwnames[] = {
23935 (char *) "type",(char *) "winid", NULL
23936 };
23937
23938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23939 if (obj0) {
23940 ecode1 = SWIG_AsVal_int(obj0, &val1);
23941 if (!SWIG_IsOK(ecode1)) {
23942 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23943 }
23944 arg1 = static_cast< wxEventType >(val1);
23945 }
23946 if (obj1) {
23947 ecode2 = SWIG_AsVal_int(obj1, &val2);
23948 if (!SWIG_IsOK(ecode2)) {
23949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
23950 }
23951 arg2 = static_cast< int >(val2);
23952 }
23953 {
23954 PyThreadState* __tstate = wxPyBeginAllowThreads();
23955 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
23956 wxPyEndAllowThreads(__tstate);
23957 if (PyErr_Occurred()) SWIG_fail;
23958 }
23959 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
23960 return resultobj;
23961 fail:
23962 return NULL;
23963 }
23964
23965
23966 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23967 PyObject *resultobj = 0;
23968 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
23969 bool arg2 ;
23970 void *argp1 = 0 ;
23971 int res1 = 0 ;
23972 bool val2 ;
23973 int ecode2 = 0 ;
23974 PyObject * obj0 = 0 ;
23975 PyObject * obj1 = 0 ;
23976 char * kwnames[] = {
23977 (char *) "self",(char *) "logOff", NULL
23978 };
23979
23980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
23981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
23982 if (!SWIG_IsOK(res1)) {
23983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
23984 }
23985 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
23986 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23987 if (!SWIG_IsOK(ecode2)) {
23988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
23989 }
23990 arg2 = static_cast< bool >(val2);
23991 {
23992 PyThreadState* __tstate = wxPyBeginAllowThreads();
23993 (arg1)->SetLoggingOff(arg2);
23994 wxPyEndAllowThreads(__tstate);
23995 if (PyErr_Occurred()) SWIG_fail;
23996 }
23997 resultobj = SWIG_Py_Void();
23998 return resultobj;
23999 fail:
24000 return NULL;
24001 }
24002
24003
24004 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24005 PyObject *resultobj = 0;
24006 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24007 bool result;
24008 void *argp1 = 0 ;
24009 int res1 = 0 ;
24010 PyObject *swig_obj[1] ;
24011
24012 if (!args) SWIG_fail;
24013 swig_obj[0] = args;
24014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24015 if (!SWIG_IsOK(res1)) {
24016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24017 }
24018 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24019 {
24020 PyThreadState* __tstate = wxPyBeginAllowThreads();
24021 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24022 wxPyEndAllowThreads(__tstate);
24023 if (PyErr_Occurred()) SWIG_fail;
24024 }
24025 {
24026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24027 }
24028 return resultobj;
24029 fail:
24030 return NULL;
24031 }
24032
24033
24034 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24035 PyObject *resultobj = 0;
24036 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24037 bool arg2 = (bool) true ;
24038 void *argp1 = 0 ;
24039 int res1 = 0 ;
24040 bool val2 ;
24041 int ecode2 = 0 ;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044 char * kwnames[] = {
24045 (char *) "self",(char *) "veto", NULL
24046 };
24047
24048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24050 if (!SWIG_IsOK(res1)) {
24051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24052 }
24053 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24054 if (obj1) {
24055 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24056 if (!SWIG_IsOK(ecode2)) {
24057 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24058 }
24059 arg2 = static_cast< bool >(val2);
24060 }
24061 {
24062 PyThreadState* __tstate = wxPyBeginAllowThreads();
24063 (arg1)->Veto(arg2);
24064 wxPyEndAllowThreads(__tstate);
24065 if (PyErr_Occurred()) SWIG_fail;
24066 }
24067 resultobj = SWIG_Py_Void();
24068 return resultobj;
24069 fail:
24070 return NULL;
24071 }
24072
24073
24074 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24075 PyObject *resultobj = 0;
24076 wxCloseEvent *arg1 = (wxCloseEvent *) 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_wxCloseEvent, 0 | 0 );
24085 if (!SWIG_IsOK(res1)) {
24086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24087 }
24088 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24089 {
24090 PyThreadState* __tstate = wxPyBeginAllowThreads();
24091 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24092 wxPyEndAllowThreads(__tstate);
24093 if (PyErr_Occurred()) SWIG_fail;
24094 }
24095 {
24096 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24097 }
24098 return resultobj;
24099 fail:
24100 return NULL;
24101 }
24102
24103
24104 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24105 PyObject *resultobj = 0;
24106 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24107 bool arg2 ;
24108 void *argp1 = 0 ;
24109 int res1 = 0 ;
24110 bool val2 ;
24111 int ecode2 = 0 ;
24112 PyObject * obj0 = 0 ;
24113 PyObject * obj1 = 0 ;
24114 char * kwnames[] = {
24115 (char *) "self",(char *) "canVeto", NULL
24116 };
24117
24118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24119 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24120 if (!SWIG_IsOK(res1)) {
24121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24122 }
24123 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24124 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24125 if (!SWIG_IsOK(ecode2)) {
24126 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24127 }
24128 arg2 = static_cast< bool >(val2);
24129 {
24130 PyThreadState* __tstate = wxPyBeginAllowThreads();
24131 (arg1)->SetCanVeto(arg2);
24132 wxPyEndAllowThreads(__tstate);
24133 if (PyErr_Occurred()) SWIG_fail;
24134 }
24135 resultobj = SWIG_Py_Void();
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24143 PyObject *resultobj = 0;
24144 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24145 bool result;
24146 void *argp1 = 0 ;
24147 int res1 = 0 ;
24148 PyObject *swig_obj[1] ;
24149
24150 if (!args) SWIG_fail;
24151 swig_obj[0] = args;
24152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24155 }
24156 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *obj;
24174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24175 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24176 return SWIG_Py_Void();
24177 }
24178
24179 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24180 return SWIG_Python_InitShadowInstance(args);
24181 }
24182
24183 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj = 0;
24185 int arg1 = (int) 0 ;
24186 bool arg2 = (bool) false ;
24187 wxShowEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 bool val2 ;
24191 int ecode2 = 0 ;
24192 PyObject * obj0 = 0 ;
24193 PyObject * obj1 = 0 ;
24194 char * kwnames[] = {
24195 (char *) "winid",(char *) "show", NULL
24196 };
24197
24198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24199 if (obj0) {
24200 ecode1 = SWIG_AsVal_int(obj0, &val1);
24201 if (!SWIG_IsOK(ecode1)) {
24202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24203 }
24204 arg1 = static_cast< int >(val1);
24205 }
24206 if (obj1) {
24207 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24210 }
24211 arg2 = static_cast< bool >(val2);
24212 }
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj = 0;
24228 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24229 bool arg2 ;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 bool val2 ;
24233 int ecode2 = 0 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "show", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24244 }
24245 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24247 if (!SWIG_IsOK(ecode2)) {
24248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24249 }
24250 arg2 = static_cast< bool >(val2);
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 (arg1)->SetShow(arg2);
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 resultobj = SWIG_Py_Void();
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24267 bool result;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 PyObject *swig_obj[1] ;
24271
24272 if (!args) SWIG_fail;
24273 swig_obj[0] = args;
24274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24277 }
24278 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24287 }
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24295 PyObject *obj;
24296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24297 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24298 return SWIG_Py_Void();
24299 }
24300
24301 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24302 return SWIG_Python_InitShadowInstance(args);
24303 }
24304
24305 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24306 PyObject *resultobj = 0;
24307 int arg1 = (int) 0 ;
24308 bool arg2 = (bool) true ;
24309 wxIconizeEvent *result = 0 ;
24310 int val1 ;
24311 int ecode1 = 0 ;
24312 bool val2 ;
24313 int ecode2 = 0 ;
24314 PyObject * obj0 = 0 ;
24315 PyObject * obj1 = 0 ;
24316 char * kwnames[] = {
24317 (char *) "id",(char *) "iconized", NULL
24318 };
24319
24320 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24321 if (obj0) {
24322 ecode1 = SWIG_AsVal_int(obj0, &val1);
24323 if (!SWIG_IsOK(ecode1)) {
24324 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24325 }
24326 arg1 = static_cast< int >(val1);
24327 }
24328 if (obj1) {
24329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24330 if (!SWIG_IsOK(ecode2)) {
24331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24332 }
24333 arg2 = static_cast< bool >(val2);
24334 }
24335 {
24336 PyThreadState* __tstate = wxPyBeginAllowThreads();
24337 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24338 wxPyEndAllowThreads(__tstate);
24339 if (PyErr_Occurred()) SWIG_fail;
24340 }
24341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24342 return resultobj;
24343 fail:
24344 return NULL;
24345 }
24346
24347
24348 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24349 PyObject *resultobj = 0;
24350 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24351 bool result;
24352 void *argp1 = 0 ;
24353 int res1 = 0 ;
24354 PyObject *swig_obj[1] ;
24355
24356 if (!args) SWIG_fail;
24357 swig_obj[0] = args;
24358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24359 if (!SWIG_IsOK(res1)) {
24360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24361 }
24362 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24363 {
24364 PyThreadState* __tstate = wxPyBeginAllowThreads();
24365 result = (bool)(arg1)->Iconized();
24366 wxPyEndAllowThreads(__tstate);
24367 if (PyErr_Occurred()) SWIG_fail;
24368 }
24369 {
24370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24371 }
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24379 PyObject *obj;
24380 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24381 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24382 return SWIG_Py_Void();
24383 }
24384
24385 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24386 return SWIG_Python_InitShadowInstance(args);
24387 }
24388
24389 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24390 PyObject *resultobj = 0;
24391 int arg1 = (int) 0 ;
24392 wxMaximizeEvent *result = 0 ;
24393 int val1 ;
24394 int ecode1 = 0 ;
24395 PyObject * obj0 = 0 ;
24396 char * kwnames[] = {
24397 (char *) "id", NULL
24398 };
24399
24400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24401 if (obj0) {
24402 ecode1 = SWIG_AsVal_int(obj0, &val1);
24403 if (!SWIG_IsOK(ecode1)) {
24404 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24405 }
24406 arg1 = static_cast< int >(val1);
24407 }
24408 {
24409 PyThreadState* __tstate = wxPyBeginAllowThreads();
24410 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24411 wxPyEndAllowThreads(__tstate);
24412 if (PyErr_Occurred()) SWIG_fail;
24413 }
24414 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24415 return resultobj;
24416 fail:
24417 return NULL;
24418 }
24419
24420
24421 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24422 PyObject *obj;
24423 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24424 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24425 return SWIG_Py_Void();
24426 }
24427
24428 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24429 return SWIG_Python_InitShadowInstance(args);
24430 }
24431
24432 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *resultobj = 0;
24434 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24435 wxPoint result;
24436 void *argp1 = 0 ;
24437 int res1 = 0 ;
24438 PyObject *swig_obj[1] ;
24439
24440 if (!args) SWIG_fail;
24441 swig_obj[0] = args;
24442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24443 if (!SWIG_IsOK(res1)) {
24444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24445 }
24446 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24447 {
24448 PyThreadState* __tstate = wxPyBeginAllowThreads();
24449 result = (arg1)->GetPosition();
24450 wxPyEndAllowThreads(__tstate);
24451 if (PyErr_Occurred()) SWIG_fail;
24452 }
24453 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24454 return resultobj;
24455 fail:
24456 return NULL;
24457 }
24458
24459
24460 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24461 PyObject *resultobj = 0;
24462 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24463 int result;
24464 void *argp1 = 0 ;
24465 int res1 = 0 ;
24466 PyObject *swig_obj[1] ;
24467
24468 if (!args) SWIG_fail;
24469 swig_obj[0] = args;
24470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24471 if (!SWIG_IsOK(res1)) {
24472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24473 }
24474 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24475 {
24476 PyThreadState* __tstate = wxPyBeginAllowThreads();
24477 result = (int)(arg1)->GetNumberOfFiles();
24478 wxPyEndAllowThreads(__tstate);
24479 if (PyErr_Occurred()) SWIG_fail;
24480 }
24481 resultobj = SWIG_From_int(static_cast< int >(result));
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *resultobj = 0;
24490 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24491 PyObject *result = 0 ;
24492 void *argp1 = 0 ;
24493 int res1 = 0 ;
24494 PyObject *swig_obj[1] ;
24495
24496 if (!args) SWIG_fail;
24497 swig_obj[0] = args;
24498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24499 if (!SWIG_IsOK(res1)) {
24500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24501 }
24502 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24503 {
24504 PyThreadState* __tstate = wxPyBeginAllowThreads();
24505 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24506 wxPyEndAllowThreads(__tstate);
24507 if (PyErr_Occurred()) SWIG_fail;
24508 }
24509 resultobj = result;
24510 return resultobj;
24511 fail:
24512 return NULL;
24513 }
24514
24515
24516 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24517 PyObject *obj;
24518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24519 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24520 return SWIG_Py_Void();
24521 }
24522
24523 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24524 PyObject *resultobj = 0;
24525 int arg1 = (int) 0 ;
24526 wxUpdateUIEvent *result = 0 ;
24527 int val1 ;
24528 int ecode1 = 0 ;
24529 PyObject * obj0 = 0 ;
24530 char * kwnames[] = {
24531 (char *) "commandId", NULL
24532 };
24533
24534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24535 if (obj0) {
24536 ecode1 = SWIG_AsVal_int(obj0, &val1);
24537 if (!SWIG_IsOK(ecode1)) {
24538 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24539 }
24540 arg1 = static_cast< int >(val1);
24541 }
24542 {
24543 PyThreadState* __tstate = wxPyBeginAllowThreads();
24544 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24545 wxPyEndAllowThreads(__tstate);
24546 if (PyErr_Occurred()) SWIG_fail;
24547 }
24548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24549 return resultobj;
24550 fail:
24551 return NULL;
24552 }
24553
24554
24555 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24556 PyObject *resultobj = 0;
24557 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24558 bool result;
24559 void *argp1 = 0 ;
24560 int res1 = 0 ;
24561 PyObject *swig_obj[1] ;
24562
24563 if (!args) SWIG_fail;
24564 swig_obj[0] = args;
24565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24566 if (!SWIG_IsOK(res1)) {
24567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24568 }
24569 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24570 {
24571 PyThreadState* __tstate = wxPyBeginAllowThreads();
24572 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24573 wxPyEndAllowThreads(__tstate);
24574 if (PyErr_Occurred()) SWIG_fail;
24575 }
24576 {
24577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24578 }
24579 return resultobj;
24580 fail:
24581 return NULL;
24582 }
24583
24584
24585 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24586 PyObject *resultobj = 0;
24587 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24588 bool result;
24589 void *argp1 = 0 ;
24590 int res1 = 0 ;
24591 PyObject *swig_obj[1] ;
24592
24593 if (!args) SWIG_fail;
24594 swig_obj[0] = args;
24595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24596 if (!SWIG_IsOK(res1)) {
24597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24598 }
24599 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24600 {
24601 PyThreadState* __tstate = wxPyBeginAllowThreads();
24602 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24603 wxPyEndAllowThreads(__tstate);
24604 if (PyErr_Occurred()) SWIG_fail;
24605 }
24606 {
24607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24608 }
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24616 PyObject *resultobj = 0;
24617 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24618 bool result;
24619 void *argp1 = 0 ;
24620 int res1 = 0 ;
24621 PyObject *swig_obj[1] ;
24622
24623 if (!args) SWIG_fail;
24624 swig_obj[0] = args;
24625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24626 if (!SWIG_IsOK(res1)) {
24627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24628 }
24629 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24630 {
24631 PyThreadState* __tstate = wxPyBeginAllowThreads();
24632 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24633 wxPyEndAllowThreads(__tstate);
24634 if (PyErr_Occurred()) SWIG_fail;
24635 }
24636 {
24637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24638 }
24639 return resultobj;
24640 fail:
24641 return NULL;
24642 }
24643
24644
24645 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 PyObject *resultobj = 0;
24647 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24648 wxString result;
24649 void *argp1 = 0 ;
24650 int res1 = 0 ;
24651 PyObject *swig_obj[1] ;
24652
24653 if (!args) SWIG_fail;
24654 swig_obj[0] = args;
24655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24656 if (!SWIG_IsOK(res1)) {
24657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24658 }
24659 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24660 {
24661 PyThreadState* __tstate = wxPyBeginAllowThreads();
24662 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24663 wxPyEndAllowThreads(__tstate);
24664 if (PyErr_Occurred()) SWIG_fail;
24665 }
24666 {
24667 #if wxUSE_UNICODE
24668 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24669 #else
24670 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24671 #endif
24672 }
24673 return resultobj;
24674 fail:
24675 return NULL;
24676 }
24677
24678
24679 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24680 PyObject *resultobj = 0;
24681 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24682 bool result;
24683 void *argp1 = 0 ;
24684 int res1 = 0 ;
24685 PyObject *swig_obj[1] ;
24686
24687 if (!args) SWIG_fail;
24688 swig_obj[0] = args;
24689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24690 if (!SWIG_IsOK(res1)) {
24691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24692 }
24693 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24694 {
24695 PyThreadState* __tstate = wxPyBeginAllowThreads();
24696 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24697 wxPyEndAllowThreads(__tstate);
24698 if (PyErr_Occurred()) SWIG_fail;
24699 }
24700 {
24701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24702 }
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24710 PyObject *resultobj = 0;
24711 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24712 bool result;
24713 void *argp1 = 0 ;
24714 int res1 = 0 ;
24715 PyObject *swig_obj[1] ;
24716
24717 if (!args) SWIG_fail;
24718 swig_obj[0] = args;
24719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24720 if (!SWIG_IsOK(res1)) {
24721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24722 }
24723 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24724 {
24725 PyThreadState* __tstate = wxPyBeginAllowThreads();
24726 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24727 wxPyEndAllowThreads(__tstate);
24728 if (PyErr_Occurred()) SWIG_fail;
24729 }
24730 {
24731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24732 }
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24740 PyObject *resultobj = 0;
24741 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24742 bool result;
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_wxUpdateUIEvent, 0 | 0 );
24750 if (!SWIG_IsOK(res1)) {
24751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24752 }
24753 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24754 {
24755 PyThreadState* __tstate = wxPyBeginAllowThreads();
24756 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24757 wxPyEndAllowThreads(__tstate);
24758 if (PyErr_Occurred()) SWIG_fail;
24759 }
24760 {
24761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24762 }
24763 return resultobj;
24764 fail:
24765 return NULL;
24766 }
24767
24768
24769 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24770 PyObject *resultobj = 0;
24771 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24772 bool result;
24773 void *argp1 = 0 ;
24774 int res1 = 0 ;
24775 PyObject *swig_obj[1] ;
24776
24777 if (!args) SWIG_fail;
24778 swig_obj[0] = args;
24779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24780 if (!SWIG_IsOK(res1)) {
24781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24782 }
24783 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24784 {
24785 PyThreadState* __tstate = wxPyBeginAllowThreads();
24786 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24787 wxPyEndAllowThreads(__tstate);
24788 if (PyErr_Occurred()) SWIG_fail;
24789 }
24790 {
24791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24792 }
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24800 PyObject *resultobj = 0;
24801 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24802 bool arg2 ;
24803 void *argp1 = 0 ;
24804 int res1 = 0 ;
24805 bool val2 ;
24806 int ecode2 = 0 ;
24807 PyObject * obj0 = 0 ;
24808 PyObject * obj1 = 0 ;
24809 char * kwnames[] = {
24810 (char *) "self",(char *) "check", NULL
24811 };
24812
24813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24815 if (!SWIG_IsOK(res1)) {
24816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24817 }
24818 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24819 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24820 if (!SWIG_IsOK(ecode2)) {
24821 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24822 }
24823 arg2 = static_cast< bool >(val2);
24824 {
24825 PyThreadState* __tstate = wxPyBeginAllowThreads();
24826 (arg1)->Check(arg2);
24827 wxPyEndAllowThreads(__tstate);
24828 if (PyErr_Occurred()) SWIG_fail;
24829 }
24830 resultobj = SWIG_Py_Void();
24831 return resultobj;
24832 fail:
24833 return NULL;
24834 }
24835
24836
24837 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24838 PyObject *resultobj = 0;
24839 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24840 bool arg2 ;
24841 void *argp1 = 0 ;
24842 int res1 = 0 ;
24843 bool val2 ;
24844 int ecode2 = 0 ;
24845 PyObject * obj0 = 0 ;
24846 PyObject * obj1 = 0 ;
24847 char * kwnames[] = {
24848 (char *) "self",(char *) "enable", NULL
24849 };
24850
24851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24853 if (!SWIG_IsOK(res1)) {
24854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24855 }
24856 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24857 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24858 if (!SWIG_IsOK(ecode2)) {
24859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24860 }
24861 arg2 = static_cast< bool >(val2);
24862 {
24863 PyThreadState* __tstate = wxPyBeginAllowThreads();
24864 (arg1)->Enable(arg2);
24865 wxPyEndAllowThreads(__tstate);
24866 if (PyErr_Occurred()) SWIG_fail;
24867 }
24868 resultobj = SWIG_Py_Void();
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24876 PyObject *resultobj = 0;
24877 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24878 bool arg2 ;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 bool val2 ;
24882 int ecode2 = 0 ;
24883 PyObject * obj0 = 0 ;
24884 PyObject * obj1 = 0 ;
24885 char * kwnames[] = {
24886 (char *) "self",(char *) "show", NULL
24887 };
24888
24889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
24890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24891 if (!SWIG_IsOK(res1)) {
24892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24893 }
24894 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24895 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24896 if (!SWIG_IsOK(ecode2)) {
24897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
24898 }
24899 arg2 = static_cast< bool >(val2);
24900 {
24901 PyThreadState* __tstate = wxPyBeginAllowThreads();
24902 (arg1)->Show(arg2);
24903 wxPyEndAllowThreads(__tstate);
24904 if (PyErr_Occurred()) SWIG_fail;
24905 }
24906 resultobj = SWIG_Py_Void();
24907 return resultobj;
24908 fail:
24909 return NULL;
24910 }
24911
24912
24913 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24914 PyObject *resultobj = 0;
24915 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24916 wxString *arg2 = 0 ;
24917 void *argp1 = 0 ;
24918 int res1 = 0 ;
24919 bool temp2 = false ;
24920 PyObject * obj0 = 0 ;
24921 PyObject * obj1 = 0 ;
24922 char * kwnames[] = {
24923 (char *) "self",(char *) "text", NULL
24924 };
24925
24926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
24927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24928 if (!SWIG_IsOK(res1)) {
24929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24930 }
24931 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24932 {
24933 arg2 = wxString_in_helper(obj1);
24934 if (arg2 == NULL) SWIG_fail;
24935 temp2 = true;
24936 }
24937 {
24938 PyThreadState* __tstate = wxPyBeginAllowThreads();
24939 (arg1)->SetText((wxString const &)*arg2);
24940 wxPyEndAllowThreads(__tstate);
24941 if (PyErr_Occurred()) SWIG_fail;
24942 }
24943 resultobj = SWIG_Py_Void();
24944 {
24945 if (temp2)
24946 delete arg2;
24947 }
24948 return resultobj;
24949 fail:
24950 {
24951 if (temp2)
24952 delete arg2;
24953 }
24954 return NULL;
24955 }
24956
24957
24958 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24959 PyObject *resultobj = 0;
24960 long arg1 ;
24961 long val1 ;
24962 int ecode1 = 0 ;
24963 PyObject * obj0 = 0 ;
24964 char * kwnames[] = {
24965 (char *) "updateInterval", NULL
24966 };
24967
24968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
24969 ecode1 = SWIG_AsVal_long(obj0, &val1);
24970 if (!SWIG_IsOK(ecode1)) {
24971 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
24972 }
24973 arg1 = static_cast< long >(val1);
24974 {
24975 PyThreadState* __tstate = wxPyBeginAllowThreads();
24976 wxUpdateUIEvent::SetUpdateInterval(arg1);
24977 wxPyEndAllowThreads(__tstate);
24978 if (PyErr_Occurred()) SWIG_fail;
24979 }
24980 resultobj = SWIG_Py_Void();
24981 return resultobj;
24982 fail:
24983 return NULL;
24984 }
24985
24986
24987 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24988 PyObject *resultobj = 0;
24989 long result;
24990
24991 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
24992 {
24993 PyThreadState* __tstate = wxPyBeginAllowThreads();
24994 result = (long)wxUpdateUIEvent::GetUpdateInterval();
24995 wxPyEndAllowThreads(__tstate);
24996 if (PyErr_Occurred()) SWIG_fail;
24997 }
24998 resultobj = SWIG_From_long(static_cast< long >(result));
24999 return resultobj;
25000 fail:
25001 return NULL;
25002 }
25003
25004
25005 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25006 PyObject *resultobj = 0;
25007 wxWindow *arg1 = (wxWindow *) 0 ;
25008 bool result;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 PyObject * obj0 = 0 ;
25012 char * kwnames[] = {
25013 (char *) "win", NULL
25014 };
25015
25016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25018 if (!SWIG_IsOK(res1)) {
25019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25020 }
25021 arg1 = reinterpret_cast< wxWindow * >(argp1);
25022 {
25023 PyThreadState* __tstate = wxPyBeginAllowThreads();
25024 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25025 wxPyEndAllowThreads(__tstate);
25026 if (PyErr_Occurred()) SWIG_fail;
25027 }
25028 {
25029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25030 }
25031 return resultobj;
25032 fail:
25033 return NULL;
25034 }
25035
25036
25037 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25038 PyObject *resultobj = 0;
25039
25040 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25041 {
25042 PyThreadState* __tstate = wxPyBeginAllowThreads();
25043 wxUpdateUIEvent::ResetUpdateTime();
25044 wxPyEndAllowThreads(__tstate);
25045 if (PyErr_Occurred()) SWIG_fail;
25046 }
25047 resultobj = SWIG_Py_Void();
25048 return resultobj;
25049 fail:
25050 return NULL;
25051 }
25052
25053
25054 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj = 0;
25056 wxUpdateUIMode arg1 ;
25057 int val1 ;
25058 int ecode1 = 0 ;
25059 PyObject * obj0 = 0 ;
25060 char * kwnames[] = {
25061 (char *) "mode", NULL
25062 };
25063
25064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25065 ecode1 = SWIG_AsVal_int(obj0, &val1);
25066 if (!SWIG_IsOK(ecode1)) {
25067 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25068 }
25069 arg1 = static_cast< wxUpdateUIMode >(val1);
25070 {
25071 PyThreadState* __tstate = wxPyBeginAllowThreads();
25072 wxUpdateUIEvent::SetMode(arg1);
25073 wxPyEndAllowThreads(__tstate);
25074 if (PyErr_Occurred()) SWIG_fail;
25075 }
25076 resultobj = SWIG_Py_Void();
25077 return resultobj;
25078 fail:
25079 return NULL;
25080 }
25081
25082
25083 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25084 PyObject *resultobj = 0;
25085 wxUpdateUIMode result;
25086
25087 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25088 {
25089 PyThreadState* __tstate = wxPyBeginAllowThreads();
25090 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 resultobj = SWIG_From_int(static_cast< int >(result));
25095 return resultobj;
25096 fail:
25097 return NULL;
25098 }
25099
25100
25101 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25102 PyObject *obj;
25103 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25104 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25105 return SWIG_Py_Void();
25106 }
25107
25108 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25109 return SWIG_Python_InitShadowInstance(args);
25110 }
25111
25112 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25113 PyObject *resultobj = 0;
25114 wxSysColourChangedEvent *result = 0 ;
25115
25116 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25117 {
25118 PyThreadState* __tstate = wxPyBeginAllowThreads();
25119 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25120 wxPyEndAllowThreads(__tstate);
25121 if (PyErr_Occurred()) SWIG_fail;
25122 }
25123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25124 return resultobj;
25125 fail:
25126 return NULL;
25127 }
25128
25129
25130 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25131 PyObject *obj;
25132 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25133 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25134 return SWIG_Py_Void();
25135 }
25136
25137 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25138 return SWIG_Python_InitShadowInstance(args);
25139 }
25140
25141 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25142 PyObject *resultobj = 0;
25143 int arg1 = (int) 0 ;
25144 wxWindow *arg2 = (wxWindow *) NULL ;
25145 wxMouseCaptureChangedEvent *result = 0 ;
25146 int val1 ;
25147 int ecode1 = 0 ;
25148 void *argp2 = 0 ;
25149 int res2 = 0 ;
25150 PyObject * obj0 = 0 ;
25151 PyObject * obj1 = 0 ;
25152 char * kwnames[] = {
25153 (char *) "winid",(char *) "gainedCapture", NULL
25154 };
25155
25156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25157 if (obj0) {
25158 ecode1 = SWIG_AsVal_int(obj0, &val1);
25159 if (!SWIG_IsOK(ecode1)) {
25160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25161 }
25162 arg1 = static_cast< int >(val1);
25163 }
25164 if (obj1) {
25165 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25166 if (!SWIG_IsOK(res2)) {
25167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25168 }
25169 arg2 = reinterpret_cast< wxWindow * >(argp2);
25170 }
25171 {
25172 PyThreadState* __tstate = wxPyBeginAllowThreads();
25173 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25174 wxPyEndAllowThreads(__tstate);
25175 if (PyErr_Occurred()) SWIG_fail;
25176 }
25177 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25185 PyObject *resultobj = 0;
25186 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25187 wxWindow *result = 0 ;
25188 void *argp1 = 0 ;
25189 int res1 = 0 ;
25190 PyObject *swig_obj[1] ;
25191
25192 if (!args) SWIG_fail;
25193 swig_obj[0] = args;
25194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25195 if (!SWIG_IsOK(res1)) {
25196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25197 }
25198 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25199 {
25200 PyThreadState* __tstate = wxPyBeginAllowThreads();
25201 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25202 wxPyEndAllowThreads(__tstate);
25203 if (PyErr_Occurred()) SWIG_fail;
25204 }
25205 {
25206 resultobj = wxPyMake_wxObject(result, (bool)0);
25207 }
25208 return resultobj;
25209 fail:
25210 return NULL;
25211 }
25212
25213
25214 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25215 PyObject *obj;
25216 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25217 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25218 return SWIG_Py_Void();
25219 }
25220
25221 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25222 return SWIG_Python_InitShadowInstance(args);
25223 }
25224
25225 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25226 PyObject *resultobj = 0;
25227 wxDisplayChangedEvent *result = 0 ;
25228
25229 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25230 {
25231 PyThreadState* __tstate = wxPyBeginAllowThreads();
25232 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25233 wxPyEndAllowThreads(__tstate);
25234 if (PyErr_Occurred()) SWIG_fail;
25235 }
25236 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25237 return resultobj;
25238 fail:
25239 return NULL;
25240 }
25241
25242
25243 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25244 PyObject *obj;
25245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25246 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25247 return SWIG_Py_Void();
25248 }
25249
25250 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25251 return SWIG_Python_InitShadowInstance(args);
25252 }
25253
25254 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25255 PyObject *resultobj = 0;
25256 int arg1 = (int) 0 ;
25257 wxPaletteChangedEvent *result = 0 ;
25258 int val1 ;
25259 int ecode1 = 0 ;
25260 PyObject * obj0 = 0 ;
25261 char * kwnames[] = {
25262 (char *) "id", NULL
25263 };
25264
25265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25266 if (obj0) {
25267 ecode1 = SWIG_AsVal_int(obj0, &val1);
25268 if (!SWIG_IsOK(ecode1)) {
25269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25270 }
25271 arg1 = static_cast< int >(val1);
25272 }
25273 {
25274 PyThreadState* __tstate = wxPyBeginAllowThreads();
25275 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25276 wxPyEndAllowThreads(__tstate);
25277 if (PyErr_Occurred()) SWIG_fail;
25278 }
25279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25280 return resultobj;
25281 fail:
25282 return NULL;
25283 }
25284
25285
25286 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25287 PyObject *resultobj = 0;
25288 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25289 wxWindow *arg2 = (wxWindow *) 0 ;
25290 void *argp1 = 0 ;
25291 int res1 = 0 ;
25292 void *argp2 = 0 ;
25293 int res2 = 0 ;
25294 PyObject * obj0 = 0 ;
25295 PyObject * obj1 = 0 ;
25296 char * kwnames[] = {
25297 (char *) "self",(char *) "win", NULL
25298 };
25299
25300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25302 if (!SWIG_IsOK(res1)) {
25303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25304 }
25305 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25307 if (!SWIG_IsOK(res2)) {
25308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25309 }
25310 arg2 = reinterpret_cast< wxWindow * >(argp2);
25311 {
25312 PyThreadState* __tstate = wxPyBeginAllowThreads();
25313 (arg1)->SetChangedWindow(arg2);
25314 wxPyEndAllowThreads(__tstate);
25315 if (PyErr_Occurred()) SWIG_fail;
25316 }
25317 resultobj = SWIG_Py_Void();
25318 return resultobj;
25319 fail:
25320 return NULL;
25321 }
25322
25323
25324 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 PyObject *resultobj = 0;
25326 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25327 wxWindow *result = 0 ;
25328 void *argp1 = 0 ;
25329 int res1 = 0 ;
25330 PyObject *swig_obj[1] ;
25331
25332 if (!args) SWIG_fail;
25333 swig_obj[0] = args;
25334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25335 if (!SWIG_IsOK(res1)) {
25336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25337 }
25338 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 result = (wxWindow *)(arg1)->GetChangedWindow();
25342 wxPyEndAllowThreads(__tstate);
25343 if (PyErr_Occurred()) SWIG_fail;
25344 }
25345 {
25346 resultobj = wxPyMake_wxObject(result, (bool)0);
25347 }
25348 return resultobj;
25349 fail:
25350 return NULL;
25351 }
25352
25353
25354 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25355 PyObject *obj;
25356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25357 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25358 return SWIG_Py_Void();
25359 }
25360
25361 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 return SWIG_Python_InitShadowInstance(args);
25363 }
25364
25365 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25366 PyObject *resultobj = 0;
25367 int arg1 = (int) 0 ;
25368 wxQueryNewPaletteEvent *result = 0 ;
25369 int val1 ;
25370 int ecode1 = 0 ;
25371 PyObject * obj0 = 0 ;
25372 char * kwnames[] = {
25373 (char *) "winid", NULL
25374 };
25375
25376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25377 if (obj0) {
25378 ecode1 = SWIG_AsVal_int(obj0, &val1);
25379 if (!SWIG_IsOK(ecode1)) {
25380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25381 }
25382 arg1 = static_cast< int >(val1);
25383 }
25384 {
25385 PyThreadState* __tstate = wxPyBeginAllowThreads();
25386 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25387 wxPyEndAllowThreads(__tstate);
25388 if (PyErr_Occurred()) SWIG_fail;
25389 }
25390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25391 return resultobj;
25392 fail:
25393 return NULL;
25394 }
25395
25396
25397 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25398 PyObject *resultobj = 0;
25399 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25400 bool arg2 ;
25401 void *argp1 = 0 ;
25402 int res1 = 0 ;
25403 bool val2 ;
25404 int ecode2 = 0 ;
25405 PyObject * obj0 = 0 ;
25406 PyObject * obj1 = 0 ;
25407 char * kwnames[] = {
25408 (char *) "self",(char *) "realized", NULL
25409 };
25410
25411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25413 if (!SWIG_IsOK(res1)) {
25414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25415 }
25416 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25417 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25418 if (!SWIG_IsOK(ecode2)) {
25419 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25420 }
25421 arg2 = static_cast< bool >(val2);
25422 {
25423 PyThreadState* __tstate = wxPyBeginAllowThreads();
25424 (arg1)->SetPaletteRealized(arg2);
25425 wxPyEndAllowThreads(__tstate);
25426 if (PyErr_Occurred()) SWIG_fail;
25427 }
25428 resultobj = SWIG_Py_Void();
25429 return resultobj;
25430 fail:
25431 return NULL;
25432 }
25433
25434
25435 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25436 PyObject *resultobj = 0;
25437 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25438 bool result;
25439 void *argp1 = 0 ;
25440 int res1 = 0 ;
25441 PyObject *swig_obj[1] ;
25442
25443 if (!args) SWIG_fail;
25444 swig_obj[0] = args;
25445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25446 if (!SWIG_IsOK(res1)) {
25447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25448 }
25449 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25450 {
25451 PyThreadState* __tstate = wxPyBeginAllowThreads();
25452 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 {
25457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25458 }
25459 return resultobj;
25460 fail:
25461 return NULL;
25462 }
25463
25464
25465 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25466 PyObject *obj;
25467 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25468 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25469 return SWIG_Py_Void();
25470 }
25471
25472 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 return SWIG_Python_InitShadowInstance(args);
25474 }
25475
25476 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25477 PyObject *resultobj = 0;
25478 wxNavigationKeyEvent *result = 0 ;
25479
25480 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25481 {
25482 PyThreadState* __tstate = wxPyBeginAllowThreads();
25483 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25484 wxPyEndAllowThreads(__tstate);
25485 if (PyErr_Occurred()) SWIG_fail;
25486 }
25487 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25488 return resultobj;
25489 fail:
25490 return NULL;
25491 }
25492
25493
25494 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25495 PyObject *resultobj = 0;
25496 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25497 bool result;
25498 void *argp1 = 0 ;
25499 int res1 = 0 ;
25500 PyObject *swig_obj[1] ;
25501
25502 if (!args) SWIG_fail;
25503 swig_obj[0] = args;
25504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25505 if (!SWIG_IsOK(res1)) {
25506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25507 }
25508 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25509 {
25510 PyThreadState* __tstate = wxPyBeginAllowThreads();
25511 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25512 wxPyEndAllowThreads(__tstate);
25513 if (PyErr_Occurred()) SWIG_fail;
25514 }
25515 {
25516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25517 }
25518 return resultobj;
25519 fail:
25520 return NULL;
25521 }
25522
25523
25524 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25525 PyObject *resultobj = 0;
25526 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25527 bool arg2 ;
25528 void *argp1 = 0 ;
25529 int res1 = 0 ;
25530 bool val2 ;
25531 int ecode2 = 0 ;
25532 PyObject * obj0 = 0 ;
25533 PyObject * obj1 = 0 ;
25534 char * kwnames[] = {
25535 (char *) "self",(char *) "forward", NULL
25536 };
25537
25538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25540 if (!SWIG_IsOK(res1)) {
25541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25542 }
25543 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25544 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25545 if (!SWIG_IsOK(ecode2)) {
25546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25547 }
25548 arg2 = static_cast< bool >(val2);
25549 {
25550 PyThreadState* __tstate = wxPyBeginAllowThreads();
25551 (arg1)->SetDirection(arg2);
25552 wxPyEndAllowThreads(__tstate);
25553 if (PyErr_Occurred()) SWIG_fail;
25554 }
25555 resultobj = SWIG_Py_Void();
25556 return resultobj;
25557 fail:
25558 return NULL;
25559 }
25560
25561
25562 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25563 PyObject *resultobj = 0;
25564 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25565 bool result;
25566 void *argp1 = 0 ;
25567 int res1 = 0 ;
25568 PyObject *swig_obj[1] ;
25569
25570 if (!args) SWIG_fail;
25571 swig_obj[0] = args;
25572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25573 if (!SWIG_IsOK(res1)) {
25574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25575 }
25576 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25580 wxPyEndAllowThreads(__tstate);
25581 if (PyErr_Occurred()) SWIG_fail;
25582 }
25583 {
25584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25585 }
25586 return resultobj;
25587 fail:
25588 return NULL;
25589 }
25590
25591
25592 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25593 PyObject *resultobj = 0;
25594 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25595 bool arg2 ;
25596 void *argp1 = 0 ;
25597 int res1 = 0 ;
25598 bool val2 ;
25599 int ecode2 = 0 ;
25600 PyObject * obj0 = 0 ;
25601 PyObject * obj1 = 0 ;
25602 char * kwnames[] = {
25603 (char *) "self",(char *) "ischange", NULL
25604 };
25605
25606 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25607 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25608 if (!SWIG_IsOK(res1)) {
25609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25610 }
25611 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25612 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25613 if (!SWIG_IsOK(ecode2)) {
25614 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25615 }
25616 arg2 = static_cast< bool >(val2);
25617 {
25618 PyThreadState* __tstate = wxPyBeginAllowThreads();
25619 (arg1)->SetWindowChange(arg2);
25620 wxPyEndAllowThreads(__tstate);
25621 if (PyErr_Occurred()) SWIG_fail;
25622 }
25623 resultobj = SWIG_Py_Void();
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25631 PyObject *resultobj = 0;
25632 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25633 bool result;
25634 void *argp1 = 0 ;
25635 int res1 = 0 ;
25636 PyObject *swig_obj[1] ;
25637
25638 if (!args) SWIG_fail;
25639 swig_obj[0] = args;
25640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25641 if (!SWIG_IsOK(res1)) {
25642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25643 }
25644 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25645 {
25646 PyThreadState* __tstate = wxPyBeginAllowThreads();
25647 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25648 wxPyEndAllowThreads(__tstate);
25649 if (PyErr_Occurred()) SWIG_fail;
25650 }
25651 {
25652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25653 }
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25661 PyObject *resultobj = 0;
25662 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25663 bool arg2 ;
25664 void *argp1 = 0 ;
25665 int res1 = 0 ;
25666 bool val2 ;
25667 int ecode2 = 0 ;
25668 PyObject * obj0 = 0 ;
25669 PyObject * obj1 = 0 ;
25670 char * kwnames[] = {
25671 (char *) "self",(char *) "bIs", NULL
25672 };
25673
25674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25676 if (!SWIG_IsOK(res1)) {
25677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25678 }
25679 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25680 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25681 if (!SWIG_IsOK(ecode2)) {
25682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25683 }
25684 arg2 = static_cast< bool >(val2);
25685 {
25686 PyThreadState* __tstate = wxPyBeginAllowThreads();
25687 (arg1)->SetFromTab(arg2);
25688 wxPyEndAllowThreads(__tstate);
25689 if (PyErr_Occurred()) SWIG_fail;
25690 }
25691 resultobj = SWIG_Py_Void();
25692 return resultobj;
25693 fail:
25694 return NULL;
25695 }
25696
25697
25698 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25699 PyObject *resultobj = 0;
25700 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25701 long arg2 ;
25702 void *argp1 = 0 ;
25703 int res1 = 0 ;
25704 long val2 ;
25705 int ecode2 = 0 ;
25706 PyObject * obj0 = 0 ;
25707 PyObject * obj1 = 0 ;
25708 char * kwnames[] = {
25709 (char *) "self",(char *) "flags", NULL
25710 };
25711
25712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25714 if (!SWIG_IsOK(res1)) {
25715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25716 }
25717 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25718 ecode2 = SWIG_AsVal_long(obj1, &val2);
25719 if (!SWIG_IsOK(ecode2)) {
25720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25721 }
25722 arg2 = static_cast< long >(val2);
25723 {
25724 PyThreadState* __tstate = wxPyBeginAllowThreads();
25725 (arg1)->SetFlags(arg2);
25726 wxPyEndAllowThreads(__tstate);
25727 if (PyErr_Occurred()) SWIG_fail;
25728 }
25729 resultobj = SWIG_Py_Void();
25730 return resultobj;
25731 fail:
25732 return NULL;
25733 }
25734
25735
25736 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25737 PyObject *resultobj = 0;
25738 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25739 wxWindow *result = 0 ;
25740 void *argp1 = 0 ;
25741 int res1 = 0 ;
25742 PyObject *swig_obj[1] ;
25743
25744 if (!args) SWIG_fail;
25745 swig_obj[0] = args;
25746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25747 if (!SWIG_IsOK(res1)) {
25748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25749 }
25750 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25751 {
25752 PyThreadState* __tstate = wxPyBeginAllowThreads();
25753 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25754 wxPyEndAllowThreads(__tstate);
25755 if (PyErr_Occurred()) SWIG_fail;
25756 }
25757 {
25758 resultobj = wxPyMake_wxObject(result, (bool)0);
25759 }
25760 return resultobj;
25761 fail:
25762 return NULL;
25763 }
25764
25765
25766 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25767 PyObject *resultobj = 0;
25768 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25769 wxWindow *arg2 = (wxWindow *) 0 ;
25770 void *argp1 = 0 ;
25771 int res1 = 0 ;
25772 void *argp2 = 0 ;
25773 int res2 = 0 ;
25774 PyObject * obj0 = 0 ;
25775 PyObject * obj1 = 0 ;
25776 char * kwnames[] = {
25777 (char *) "self",(char *) "win", NULL
25778 };
25779
25780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25782 if (!SWIG_IsOK(res1)) {
25783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25784 }
25785 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25787 if (!SWIG_IsOK(res2)) {
25788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25789 }
25790 arg2 = reinterpret_cast< wxWindow * >(argp2);
25791 {
25792 PyThreadState* __tstate = wxPyBeginAllowThreads();
25793 (arg1)->SetCurrentFocus(arg2);
25794 wxPyEndAllowThreads(__tstate);
25795 if (PyErr_Occurred()) SWIG_fail;
25796 }
25797 resultobj = SWIG_Py_Void();
25798 return resultobj;
25799 fail:
25800 return NULL;
25801 }
25802
25803
25804 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25805 PyObject *obj;
25806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25807 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25808 return SWIG_Py_Void();
25809 }
25810
25811 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25812 return SWIG_Python_InitShadowInstance(args);
25813 }
25814
25815 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25816 PyObject *resultobj = 0;
25817 wxWindow *arg1 = (wxWindow *) NULL ;
25818 wxWindowCreateEvent *result = 0 ;
25819 void *argp1 = 0 ;
25820 int res1 = 0 ;
25821 PyObject * obj0 = 0 ;
25822 char * kwnames[] = {
25823 (char *) "win", NULL
25824 };
25825
25826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25827 if (obj0) {
25828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25829 if (!SWIG_IsOK(res1)) {
25830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25831 }
25832 arg1 = reinterpret_cast< wxWindow * >(argp1);
25833 }
25834 {
25835 PyThreadState* __tstate = wxPyBeginAllowThreads();
25836 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25837 wxPyEndAllowThreads(__tstate);
25838 if (PyErr_Occurred()) SWIG_fail;
25839 }
25840 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25841 return resultobj;
25842 fail:
25843 return NULL;
25844 }
25845
25846
25847 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25848 PyObject *resultobj = 0;
25849 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25850 wxWindow *result = 0 ;
25851 void *argp1 = 0 ;
25852 int res1 = 0 ;
25853 PyObject *swig_obj[1] ;
25854
25855 if (!args) SWIG_fail;
25856 swig_obj[0] = args;
25857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25858 if (!SWIG_IsOK(res1)) {
25859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25860 }
25861 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25862 {
25863 PyThreadState* __tstate = wxPyBeginAllowThreads();
25864 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25865 wxPyEndAllowThreads(__tstate);
25866 if (PyErr_Occurred()) SWIG_fail;
25867 }
25868 {
25869 resultobj = wxPyMake_wxObject(result, (bool)0);
25870 }
25871 return resultobj;
25872 fail:
25873 return NULL;
25874 }
25875
25876
25877 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25878 PyObject *obj;
25879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25880 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25881 return SWIG_Py_Void();
25882 }
25883
25884 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25885 return SWIG_Python_InitShadowInstance(args);
25886 }
25887
25888 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25889 PyObject *resultobj = 0;
25890 wxWindow *arg1 = (wxWindow *) NULL ;
25891 wxWindowDestroyEvent *result = 0 ;
25892 void *argp1 = 0 ;
25893 int res1 = 0 ;
25894 PyObject * obj0 = 0 ;
25895 char * kwnames[] = {
25896 (char *) "win", NULL
25897 };
25898
25899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
25900 if (obj0) {
25901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25902 if (!SWIG_IsOK(res1)) {
25903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25904 }
25905 arg1 = reinterpret_cast< wxWindow * >(argp1);
25906 }
25907 {
25908 PyThreadState* __tstate = wxPyBeginAllowThreads();
25909 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
25910 wxPyEndAllowThreads(__tstate);
25911 if (PyErr_Occurred()) SWIG_fail;
25912 }
25913 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
25914 return resultobj;
25915 fail:
25916 return NULL;
25917 }
25918
25919
25920 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25921 PyObject *resultobj = 0;
25922 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
25923 wxWindow *result = 0 ;
25924 void *argp1 = 0 ;
25925 int res1 = 0 ;
25926 PyObject *swig_obj[1] ;
25927
25928 if (!args) SWIG_fail;
25929 swig_obj[0] = args;
25930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
25931 if (!SWIG_IsOK(res1)) {
25932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
25933 }
25934 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
25935 {
25936 PyThreadState* __tstate = wxPyBeginAllowThreads();
25937 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
25938 wxPyEndAllowThreads(__tstate);
25939 if (PyErr_Occurred()) SWIG_fail;
25940 }
25941 {
25942 resultobj = wxPyMake_wxObject(result, (bool)0);
25943 }
25944 return resultobj;
25945 fail:
25946 return NULL;
25947 }
25948
25949
25950 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25951 PyObject *obj;
25952 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25953 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
25954 return SWIG_Py_Void();
25955 }
25956
25957 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 return SWIG_Python_InitShadowInstance(args);
25959 }
25960
25961 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25962 PyObject *resultobj = 0;
25963 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
25964 int arg2 = (int) 0 ;
25965 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25966 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25967 wxContextMenuEvent *result = 0 ;
25968 int val1 ;
25969 int ecode1 = 0 ;
25970 int val2 ;
25971 int ecode2 = 0 ;
25972 wxPoint temp3 ;
25973 PyObject * obj0 = 0 ;
25974 PyObject * obj1 = 0 ;
25975 PyObject * obj2 = 0 ;
25976 char * kwnames[] = {
25977 (char *) "type",(char *) "winid",(char *) "pt", NULL
25978 };
25979
25980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
25981 if (obj0) {
25982 ecode1 = SWIG_AsVal_int(obj0, &val1);
25983 if (!SWIG_IsOK(ecode1)) {
25984 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
25985 }
25986 arg1 = static_cast< wxEventType >(val1);
25987 }
25988 if (obj1) {
25989 ecode2 = SWIG_AsVal_int(obj1, &val2);
25990 if (!SWIG_IsOK(ecode2)) {
25991 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
25992 }
25993 arg2 = static_cast< int >(val2);
25994 }
25995 if (obj2) {
25996 {
25997 arg3 = &temp3;
25998 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25999 }
26000 }
26001 {
26002 PyThreadState* __tstate = wxPyBeginAllowThreads();
26003 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26008 return resultobj;
26009 fail:
26010 return NULL;
26011 }
26012
26013
26014 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26015 PyObject *resultobj = 0;
26016 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26017 wxPoint *result = 0 ;
26018 void *argp1 = 0 ;
26019 int res1 = 0 ;
26020 PyObject *swig_obj[1] ;
26021
26022 if (!args) SWIG_fail;
26023 swig_obj[0] = args;
26024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26025 if (!SWIG_IsOK(res1)) {
26026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26027 }
26028 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26029 {
26030 PyThreadState* __tstate = wxPyBeginAllowThreads();
26031 {
26032 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26033 result = (wxPoint *) &_result_ref;
26034 }
26035 wxPyEndAllowThreads(__tstate);
26036 if (PyErr_Occurred()) SWIG_fail;
26037 }
26038 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26039 return resultobj;
26040 fail:
26041 return NULL;
26042 }
26043
26044
26045 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26046 PyObject *resultobj = 0;
26047 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26048 wxPoint *arg2 = 0 ;
26049 void *argp1 = 0 ;
26050 int res1 = 0 ;
26051 wxPoint temp2 ;
26052 PyObject * obj0 = 0 ;
26053 PyObject * obj1 = 0 ;
26054 char * kwnames[] = {
26055 (char *) "self",(char *) "pos", NULL
26056 };
26057
26058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26060 if (!SWIG_IsOK(res1)) {
26061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26062 }
26063 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26064 {
26065 arg2 = &temp2;
26066 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26067 }
26068 {
26069 PyThreadState* __tstate = wxPyBeginAllowThreads();
26070 (arg1)->SetPosition((wxPoint const &)*arg2);
26071 wxPyEndAllowThreads(__tstate);
26072 if (PyErr_Occurred()) SWIG_fail;
26073 }
26074 resultobj = SWIG_Py_Void();
26075 return resultobj;
26076 fail:
26077 return NULL;
26078 }
26079
26080
26081 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26082 PyObject *obj;
26083 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26084 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26085 return SWIG_Py_Void();
26086 }
26087
26088 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26089 return SWIG_Python_InitShadowInstance(args);
26090 }
26091
26092 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26093 PyObject *resultobj = 0;
26094 wxIdleEvent *result = 0 ;
26095
26096 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26097 {
26098 PyThreadState* __tstate = wxPyBeginAllowThreads();
26099 result = (wxIdleEvent *)new wxIdleEvent();
26100 wxPyEndAllowThreads(__tstate);
26101 if (PyErr_Occurred()) SWIG_fail;
26102 }
26103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26104 return resultobj;
26105 fail:
26106 return NULL;
26107 }
26108
26109
26110 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26111 PyObject *resultobj = 0;
26112 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26113 bool arg2 = (bool) true ;
26114 void *argp1 = 0 ;
26115 int res1 = 0 ;
26116 bool val2 ;
26117 int ecode2 = 0 ;
26118 PyObject * obj0 = 0 ;
26119 PyObject * obj1 = 0 ;
26120 char * kwnames[] = {
26121 (char *) "self",(char *) "needMore", NULL
26122 };
26123
26124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26126 if (!SWIG_IsOK(res1)) {
26127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26128 }
26129 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26130 if (obj1) {
26131 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26132 if (!SWIG_IsOK(ecode2)) {
26133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26134 }
26135 arg2 = static_cast< bool >(val2);
26136 }
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 (arg1)->RequestMore(arg2);
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 resultobj = SWIG_Py_Void();
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26151 PyObject *resultobj = 0;
26152 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26153 bool result;
26154 void *argp1 = 0 ;
26155 int res1 = 0 ;
26156 PyObject *swig_obj[1] ;
26157
26158 if (!args) SWIG_fail;
26159 swig_obj[0] = args;
26160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26163 }
26164 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26165 {
26166 PyThreadState* __tstate = wxPyBeginAllowThreads();
26167 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 {
26172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26173 }
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26181 PyObject *resultobj = 0;
26182 wxIdleMode arg1 ;
26183 int val1 ;
26184 int ecode1 = 0 ;
26185 PyObject * obj0 = 0 ;
26186 char * kwnames[] = {
26187 (char *) "mode", NULL
26188 };
26189
26190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26191 ecode1 = SWIG_AsVal_int(obj0, &val1);
26192 if (!SWIG_IsOK(ecode1)) {
26193 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26194 }
26195 arg1 = static_cast< wxIdleMode >(val1);
26196 {
26197 PyThreadState* __tstate = wxPyBeginAllowThreads();
26198 wxIdleEvent::SetMode(arg1);
26199 wxPyEndAllowThreads(__tstate);
26200 if (PyErr_Occurred()) SWIG_fail;
26201 }
26202 resultobj = SWIG_Py_Void();
26203 return resultobj;
26204 fail:
26205 return NULL;
26206 }
26207
26208
26209 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26210 PyObject *resultobj = 0;
26211 wxIdleMode result;
26212
26213 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26214 {
26215 PyThreadState* __tstate = wxPyBeginAllowThreads();
26216 result = (wxIdleMode)wxIdleEvent::GetMode();
26217 wxPyEndAllowThreads(__tstate);
26218 if (PyErr_Occurred()) SWIG_fail;
26219 }
26220 resultobj = SWIG_From_int(static_cast< int >(result));
26221 return resultobj;
26222 fail:
26223 return NULL;
26224 }
26225
26226
26227 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26228 PyObject *resultobj = 0;
26229 wxWindow *arg1 = (wxWindow *) 0 ;
26230 bool result;
26231 void *argp1 = 0 ;
26232 int res1 = 0 ;
26233 PyObject * obj0 = 0 ;
26234 char * kwnames[] = {
26235 (char *) "win", NULL
26236 };
26237
26238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26239 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26240 if (!SWIG_IsOK(res1)) {
26241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26242 }
26243 arg1 = reinterpret_cast< wxWindow * >(argp1);
26244 {
26245 PyThreadState* __tstate = wxPyBeginAllowThreads();
26246 result = (bool)wxIdleEvent::CanSend(arg1);
26247 wxPyEndAllowThreads(__tstate);
26248 if (PyErr_Occurred()) SWIG_fail;
26249 }
26250 {
26251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26252 }
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26260 PyObject *obj;
26261 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26262 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26263 return SWIG_Py_Void();
26264 }
26265
26266 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26267 return SWIG_Python_InitShadowInstance(args);
26268 }
26269
26270 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26271 PyObject *resultobj = 0;
26272 int arg1 = (int) 0 ;
26273 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26274 wxPyEvent *result = 0 ;
26275 int val1 ;
26276 int ecode1 = 0 ;
26277 int val2 ;
26278 int ecode2 = 0 ;
26279 PyObject * obj0 = 0 ;
26280 PyObject * obj1 = 0 ;
26281 char * kwnames[] = {
26282 (char *) "winid",(char *) "eventType", NULL
26283 };
26284
26285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26286 if (obj0) {
26287 ecode1 = SWIG_AsVal_int(obj0, &val1);
26288 if (!SWIG_IsOK(ecode1)) {
26289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26290 }
26291 arg1 = static_cast< int >(val1);
26292 }
26293 if (obj1) {
26294 ecode2 = SWIG_AsVal_int(obj1, &val2);
26295 if (!SWIG_IsOK(ecode2)) {
26296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26297 }
26298 arg2 = static_cast< wxEventType >(val2);
26299 }
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26303 wxPyEndAllowThreads(__tstate);
26304 if (PyErr_Occurred()) SWIG_fail;
26305 }
26306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26307 return resultobj;
26308 fail:
26309 return NULL;
26310 }
26311
26312
26313 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26314 PyObject *resultobj = 0;
26315 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26316 void *argp1 = 0 ;
26317 int res1 = 0 ;
26318 PyObject *swig_obj[1] ;
26319
26320 if (!args) SWIG_fail;
26321 swig_obj[0] = args;
26322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26323 if (!SWIG_IsOK(res1)) {
26324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26325 }
26326 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26327 {
26328 PyThreadState* __tstate = wxPyBeginAllowThreads();
26329 delete arg1;
26330
26331 wxPyEndAllowThreads(__tstate);
26332 if (PyErr_Occurred()) SWIG_fail;
26333 }
26334 resultobj = SWIG_Py_Void();
26335 return resultobj;
26336 fail:
26337 return NULL;
26338 }
26339
26340
26341 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26342 PyObject *resultobj = 0;
26343 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26344 PyObject *arg2 = (PyObject *) 0 ;
26345 void *argp1 = 0 ;
26346 int res1 = 0 ;
26347 PyObject * obj0 = 0 ;
26348 PyObject * obj1 = 0 ;
26349 char * kwnames[] = {
26350 (char *) "self",(char *) "self", NULL
26351 };
26352
26353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26355 if (!SWIG_IsOK(res1)) {
26356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26357 }
26358 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26359 arg2 = obj1;
26360 {
26361 PyThreadState* __tstate = wxPyBeginAllowThreads();
26362 (arg1)->SetSelf(arg2);
26363 wxPyEndAllowThreads(__tstate);
26364 if (PyErr_Occurred()) SWIG_fail;
26365 }
26366 resultobj = SWIG_Py_Void();
26367 return resultobj;
26368 fail:
26369 return NULL;
26370 }
26371
26372
26373 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26374 PyObject *resultobj = 0;
26375 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26376 PyObject *result = 0 ;
26377 void *argp1 = 0 ;
26378 int res1 = 0 ;
26379 PyObject *swig_obj[1] ;
26380
26381 if (!args) SWIG_fail;
26382 swig_obj[0] = args;
26383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26384 if (!SWIG_IsOK(res1)) {
26385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26386 }
26387 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26388 {
26389 PyThreadState* __tstate = wxPyBeginAllowThreads();
26390 result = (PyObject *)(arg1)->GetSelf();
26391 wxPyEndAllowThreads(__tstate);
26392 if (PyErr_Occurred()) SWIG_fail;
26393 }
26394 resultobj = result;
26395 return resultobj;
26396 fail:
26397 return NULL;
26398 }
26399
26400
26401 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26402 PyObject *obj;
26403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26404 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26405 return SWIG_Py_Void();
26406 }
26407
26408 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26409 return SWIG_Python_InitShadowInstance(args);
26410 }
26411
26412 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26413 PyObject *resultobj = 0;
26414 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26415 int arg2 = (int) 0 ;
26416 wxPyCommandEvent *result = 0 ;
26417 int val1 ;
26418 int ecode1 = 0 ;
26419 int val2 ;
26420 int ecode2 = 0 ;
26421 PyObject * obj0 = 0 ;
26422 PyObject * obj1 = 0 ;
26423 char * kwnames[] = {
26424 (char *) "eventType",(char *) "id", NULL
26425 };
26426
26427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26428 if (obj0) {
26429 ecode1 = SWIG_AsVal_int(obj0, &val1);
26430 if (!SWIG_IsOK(ecode1)) {
26431 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26432 }
26433 arg1 = static_cast< wxEventType >(val1);
26434 }
26435 if (obj1) {
26436 ecode2 = SWIG_AsVal_int(obj1, &val2);
26437 if (!SWIG_IsOK(ecode2)) {
26438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26439 }
26440 arg2 = static_cast< int >(val2);
26441 }
26442 {
26443 PyThreadState* __tstate = wxPyBeginAllowThreads();
26444 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26445 wxPyEndAllowThreads(__tstate);
26446 if (PyErr_Occurred()) SWIG_fail;
26447 }
26448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26449 return resultobj;
26450 fail:
26451 return NULL;
26452 }
26453
26454
26455 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26456 PyObject *resultobj = 0;
26457 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26458 void *argp1 = 0 ;
26459 int res1 = 0 ;
26460 PyObject *swig_obj[1] ;
26461
26462 if (!args) SWIG_fail;
26463 swig_obj[0] = args;
26464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26465 if (!SWIG_IsOK(res1)) {
26466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26467 }
26468 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26469 {
26470 PyThreadState* __tstate = wxPyBeginAllowThreads();
26471 delete arg1;
26472
26473 wxPyEndAllowThreads(__tstate);
26474 if (PyErr_Occurred()) SWIG_fail;
26475 }
26476 resultobj = SWIG_Py_Void();
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26486 PyObject *arg2 = (PyObject *) 0 ;
26487 void *argp1 = 0 ;
26488 int res1 = 0 ;
26489 PyObject * obj0 = 0 ;
26490 PyObject * obj1 = 0 ;
26491 char * kwnames[] = {
26492 (char *) "self",(char *) "self", NULL
26493 };
26494
26495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26497 if (!SWIG_IsOK(res1)) {
26498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26499 }
26500 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26501 arg2 = obj1;
26502 {
26503 PyThreadState* __tstate = wxPyBeginAllowThreads();
26504 (arg1)->SetSelf(arg2);
26505 wxPyEndAllowThreads(__tstate);
26506 if (PyErr_Occurred()) SWIG_fail;
26507 }
26508 resultobj = SWIG_Py_Void();
26509 return resultobj;
26510 fail:
26511 return NULL;
26512 }
26513
26514
26515 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 PyObject *resultobj = 0;
26517 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26518 PyObject *result = 0 ;
26519 void *argp1 = 0 ;
26520 int res1 = 0 ;
26521 PyObject *swig_obj[1] ;
26522
26523 if (!args) SWIG_fail;
26524 swig_obj[0] = args;
26525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26526 if (!SWIG_IsOK(res1)) {
26527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26528 }
26529 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26530 {
26531 PyThreadState* __tstate = wxPyBeginAllowThreads();
26532 result = (PyObject *)(arg1)->GetSelf();
26533 wxPyEndAllowThreads(__tstate);
26534 if (PyErr_Occurred()) SWIG_fail;
26535 }
26536 resultobj = result;
26537 return resultobj;
26538 fail:
26539 return NULL;
26540 }
26541
26542
26543 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26544 PyObject *obj;
26545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26547 return SWIG_Py_Void();
26548 }
26549
26550 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26551 return SWIG_Python_InitShadowInstance(args);
26552 }
26553
26554 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26555 PyObject *resultobj = 0;
26556 wxWindow *arg1 = (wxWindow *) 0 ;
26557 wxDateTime *arg2 = 0 ;
26558 wxEventType arg3 ;
26559 wxDateEvent *result = 0 ;
26560 void *argp1 = 0 ;
26561 int res1 = 0 ;
26562 void *argp2 = 0 ;
26563 int res2 = 0 ;
26564 int val3 ;
26565 int ecode3 = 0 ;
26566 PyObject * obj0 = 0 ;
26567 PyObject * obj1 = 0 ;
26568 PyObject * obj2 = 0 ;
26569 char * kwnames[] = {
26570 (char *) "win",(char *) "dt",(char *) "type", NULL
26571 };
26572
26573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26575 if (!SWIG_IsOK(res1)) {
26576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26577 }
26578 arg1 = reinterpret_cast< wxWindow * >(argp1);
26579 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26580 if (!SWIG_IsOK(res2)) {
26581 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26582 }
26583 if (!argp2) {
26584 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26585 }
26586 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26587 ecode3 = SWIG_AsVal_int(obj2, &val3);
26588 if (!SWIG_IsOK(ecode3)) {
26589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26590 }
26591 arg3 = static_cast< wxEventType >(val3);
26592 {
26593 PyThreadState* __tstate = wxPyBeginAllowThreads();
26594 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26595 wxPyEndAllowThreads(__tstate);
26596 if (PyErr_Occurred()) SWIG_fail;
26597 }
26598 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26599 return resultobj;
26600 fail:
26601 return NULL;
26602 }
26603
26604
26605 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26606 PyObject *resultobj = 0;
26607 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26608 wxDateTime *result = 0 ;
26609 void *argp1 = 0 ;
26610 int res1 = 0 ;
26611 PyObject *swig_obj[1] ;
26612
26613 if (!args) SWIG_fail;
26614 swig_obj[0] = args;
26615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26616 if (!SWIG_IsOK(res1)) {
26617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26618 }
26619 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26620 {
26621 PyThreadState* __tstate = wxPyBeginAllowThreads();
26622 {
26623 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26624 result = (wxDateTime *) &_result_ref;
26625 }
26626 wxPyEndAllowThreads(__tstate);
26627 if (PyErr_Occurred()) SWIG_fail;
26628 }
26629 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26630 return resultobj;
26631 fail:
26632 return NULL;
26633 }
26634
26635
26636 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26637 PyObject *resultobj = 0;
26638 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26639 wxDateTime *arg2 = 0 ;
26640 void *argp1 = 0 ;
26641 int res1 = 0 ;
26642 void *argp2 = 0 ;
26643 int res2 = 0 ;
26644 PyObject * obj0 = 0 ;
26645 PyObject * obj1 = 0 ;
26646 char * kwnames[] = {
26647 (char *) "self",(char *) "date", NULL
26648 };
26649
26650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26652 if (!SWIG_IsOK(res1)) {
26653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26654 }
26655 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26656 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26657 if (!SWIG_IsOK(res2)) {
26658 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26659 }
26660 if (!argp2) {
26661 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26662 }
26663 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26664 {
26665 PyThreadState* __tstate = wxPyBeginAllowThreads();
26666 (arg1)->SetDate((wxDateTime const &)*arg2);
26667 wxPyEndAllowThreads(__tstate);
26668 if (PyErr_Occurred()) SWIG_fail;
26669 }
26670 resultobj = SWIG_Py_Void();
26671 return resultobj;
26672 fail:
26673 return NULL;
26674 }
26675
26676
26677 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26678 PyObject *obj;
26679 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26680 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26681 return SWIG_Py_Void();
26682 }
26683
26684 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26685 return SWIG_Python_InitShadowInstance(args);
26686 }
26687
26688 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26689 PyObject *resultobj = 0;
26690 wxPyApp *result = 0 ;
26691
26692 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 result = (wxPyApp *)new_wxPyApp();
26696 wxPyEndAllowThreads(__tstate);
26697 if (PyErr_Occurred()) SWIG_fail;
26698 }
26699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26700 return resultobj;
26701 fail:
26702 return NULL;
26703 }
26704
26705
26706 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26707 PyObject *resultobj = 0;
26708 wxPyApp *arg1 = (wxPyApp *) 0 ;
26709 void *argp1 = 0 ;
26710 int res1 = 0 ;
26711 PyObject *swig_obj[1] ;
26712
26713 if (!args) SWIG_fail;
26714 swig_obj[0] = args;
26715 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26716 if (!SWIG_IsOK(res1)) {
26717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26718 }
26719 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26720 {
26721 PyThreadState* __tstate = wxPyBeginAllowThreads();
26722 delete arg1;
26723
26724 wxPyEndAllowThreads(__tstate);
26725 if (PyErr_Occurred()) SWIG_fail;
26726 }
26727 resultobj = SWIG_Py_Void();
26728 return resultobj;
26729 fail:
26730 return NULL;
26731 }
26732
26733
26734 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26735 PyObject *resultobj = 0;
26736 wxPyApp *arg1 = (wxPyApp *) 0 ;
26737 PyObject *arg2 = (PyObject *) 0 ;
26738 PyObject *arg3 = (PyObject *) 0 ;
26739 bool arg4 ;
26740 void *argp1 = 0 ;
26741 int res1 = 0 ;
26742 bool val4 ;
26743 int ecode4 = 0 ;
26744 PyObject * obj0 = 0 ;
26745 PyObject * obj1 = 0 ;
26746 PyObject * obj2 = 0 ;
26747 PyObject * obj3 = 0 ;
26748 char * kwnames[] = {
26749 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26750 };
26751
26752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26754 if (!SWIG_IsOK(res1)) {
26755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26756 }
26757 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26758 arg2 = obj1;
26759 arg3 = obj2;
26760 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26761 if (!SWIG_IsOK(ecode4)) {
26762 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26763 }
26764 arg4 = static_cast< bool >(val4);
26765 {
26766 PyThreadState* __tstate = wxPyBeginAllowThreads();
26767 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26768 wxPyEndAllowThreads(__tstate);
26769 if (PyErr_Occurred()) SWIG_fail;
26770 }
26771 resultobj = SWIG_Py_Void();
26772 return resultobj;
26773 fail:
26774 return NULL;
26775 }
26776
26777
26778 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26779 PyObject *resultobj = 0;
26780 wxPyApp *arg1 = (wxPyApp *) 0 ;
26781 wxString result;
26782 void *argp1 = 0 ;
26783 int res1 = 0 ;
26784 PyObject *swig_obj[1] ;
26785
26786 if (!args) SWIG_fail;
26787 swig_obj[0] = args;
26788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26789 if (!SWIG_IsOK(res1)) {
26790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26791 }
26792 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26793 {
26794 PyThreadState* __tstate = wxPyBeginAllowThreads();
26795 result = ((wxPyApp const *)arg1)->GetAppName();
26796 wxPyEndAllowThreads(__tstate);
26797 if (PyErr_Occurred()) SWIG_fail;
26798 }
26799 {
26800 #if wxUSE_UNICODE
26801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26802 #else
26803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26804 #endif
26805 }
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26813 PyObject *resultobj = 0;
26814 wxPyApp *arg1 = (wxPyApp *) 0 ;
26815 wxString *arg2 = 0 ;
26816 void *argp1 = 0 ;
26817 int res1 = 0 ;
26818 bool temp2 = false ;
26819 PyObject * obj0 = 0 ;
26820 PyObject * obj1 = 0 ;
26821 char * kwnames[] = {
26822 (char *) "self",(char *) "name", NULL
26823 };
26824
26825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26827 if (!SWIG_IsOK(res1)) {
26828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26829 }
26830 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26831 {
26832 arg2 = wxString_in_helper(obj1);
26833 if (arg2 == NULL) SWIG_fail;
26834 temp2 = true;
26835 }
26836 {
26837 PyThreadState* __tstate = wxPyBeginAllowThreads();
26838 (arg1)->SetAppName((wxString const &)*arg2);
26839 wxPyEndAllowThreads(__tstate);
26840 if (PyErr_Occurred()) SWIG_fail;
26841 }
26842 resultobj = SWIG_Py_Void();
26843 {
26844 if (temp2)
26845 delete arg2;
26846 }
26847 return resultobj;
26848 fail:
26849 {
26850 if (temp2)
26851 delete arg2;
26852 }
26853 return NULL;
26854 }
26855
26856
26857 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26858 PyObject *resultobj = 0;
26859 wxPyApp *arg1 = (wxPyApp *) 0 ;
26860 wxString result;
26861 void *argp1 = 0 ;
26862 int res1 = 0 ;
26863 PyObject *swig_obj[1] ;
26864
26865 if (!args) SWIG_fail;
26866 swig_obj[0] = args;
26867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26868 if (!SWIG_IsOK(res1)) {
26869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26870 }
26871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26872 {
26873 PyThreadState* __tstate = wxPyBeginAllowThreads();
26874 result = ((wxPyApp const *)arg1)->GetClassName();
26875 wxPyEndAllowThreads(__tstate);
26876 if (PyErr_Occurred()) SWIG_fail;
26877 }
26878 {
26879 #if wxUSE_UNICODE
26880 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26881 #else
26882 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26883 #endif
26884 }
26885 return resultobj;
26886 fail:
26887 return NULL;
26888 }
26889
26890
26891 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26892 PyObject *resultobj = 0;
26893 wxPyApp *arg1 = (wxPyApp *) 0 ;
26894 wxString *arg2 = 0 ;
26895 void *argp1 = 0 ;
26896 int res1 = 0 ;
26897 bool temp2 = false ;
26898 PyObject * obj0 = 0 ;
26899 PyObject * obj1 = 0 ;
26900 char * kwnames[] = {
26901 (char *) "self",(char *) "name", NULL
26902 };
26903
26904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
26905 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26906 if (!SWIG_IsOK(res1)) {
26907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26908 }
26909 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26910 {
26911 arg2 = wxString_in_helper(obj1);
26912 if (arg2 == NULL) SWIG_fail;
26913 temp2 = true;
26914 }
26915 {
26916 PyThreadState* __tstate = wxPyBeginAllowThreads();
26917 (arg1)->SetClassName((wxString const &)*arg2);
26918 wxPyEndAllowThreads(__tstate);
26919 if (PyErr_Occurred()) SWIG_fail;
26920 }
26921 resultobj = SWIG_Py_Void();
26922 {
26923 if (temp2)
26924 delete arg2;
26925 }
26926 return resultobj;
26927 fail:
26928 {
26929 if (temp2)
26930 delete arg2;
26931 }
26932 return NULL;
26933 }
26934
26935
26936 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26937 PyObject *resultobj = 0;
26938 wxPyApp *arg1 = (wxPyApp *) 0 ;
26939 wxString *result = 0 ;
26940 void *argp1 = 0 ;
26941 int res1 = 0 ;
26942 PyObject *swig_obj[1] ;
26943
26944 if (!args) SWIG_fail;
26945 swig_obj[0] = args;
26946 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26947 if (!SWIG_IsOK(res1)) {
26948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26949 }
26950 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26951 {
26952 PyThreadState* __tstate = wxPyBeginAllowThreads();
26953 {
26954 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
26955 result = (wxString *) &_result_ref;
26956 }
26957 wxPyEndAllowThreads(__tstate);
26958 if (PyErr_Occurred()) SWIG_fail;
26959 }
26960 {
26961 #if wxUSE_UNICODE
26962 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
26963 #else
26964 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
26965 #endif
26966 }
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj = 0;
26975 wxPyApp *arg1 = (wxPyApp *) 0 ;
26976 wxString *arg2 = 0 ;
26977 void *argp1 = 0 ;
26978 int res1 = 0 ;
26979 bool temp2 = false ;
26980 PyObject * obj0 = 0 ;
26981 PyObject * obj1 = 0 ;
26982 char * kwnames[] = {
26983 (char *) "self",(char *) "name", NULL
26984 };
26985
26986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
26987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26988 if (!SWIG_IsOK(res1)) {
26989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26990 }
26991 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26992 {
26993 arg2 = wxString_in_helper(obj1);
26994 if (arg2 == NULL) SWIG_fail;
26995 temp2 = true;
26996 }
26997 {
26998 PyThreadState* __tstate = wxPyBeginAllowThreads();
26999 (arg1)->SetVendorName((wxString const &)*arg2);
27000 wxPyEndAllowThreads(__tstate);
27001 if (PyErr_Occurred()) SWIG_fail;
27002 }
27003 resultobj = SWIG_Py_Void();
27004 {
27005 if (temp2)
27006 delete arg2;
27007 }
27008 return resultobj;
27009 fail:
27010 {
27011 if (temp2)
27012 delete arg2;
27013 }
27014 return NULL;
27015 }
27016
27017
27018 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27019 PyObject *resultobj = 0;
27020 wxPyApp *arg1 = (wxPyApp *) 0 ;
27021 wxAppTraits *result = 0 ;
27022 void *argp1 = 0 ;
27023 int res1 = 0 ;
27024 PyObject *swig_obj[1] ;
27025
27026 if (!args) SWIG_fail;
27027 swig_obj[0] = args;
27028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27029 if (!SWIG_IsOK(res1)) {
27030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27031 }
27032 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27033 {
27034 PyThreadState* __tstate = wxPyBeginAllowThreads();
27035 result = (wxAppTraits *)(arg1)->GetTraits();
27036 wxPyEndAllowThreads(__tstate);
27037 if (PyErr_Occurred()) SWIG_fail;
27038 }
27039 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27040 return resultobj;
27041 fail:
27042 return NULL;
27043 }
27044
27045
27046 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27047 PyObject *resultobj = 0;
27048 wxPyApp *arg1 = (wxPyApp *) 0 ;
27049 void *argp1 = 0 ;
27050 int res1 = 0 ;
27051 PyObject *swig_obj[1] ;
27052
27053 if (!args) SWIG_fail;
27054 swig_obj[0] = args;
27055 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27056 if (!SWIG_IsOK(res1)) {
27057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27058 }
27059 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27060 {
27061 PyThreadState* __tstate = wxPyBeginAllowThreads();
27062 (arg1)->ProcessPendingEvents();
27063 wxPyEndAllowThreads(__tstate);
27064 if (PyErr_Occurred()) SWIG_fail;
27065 }
27066 resultobj = SWIG_Py_Void();
27067 return resultobj;
27068 fail:
27069 return NULL;
27070 }
27071
27072
27073 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27074 PyObject *resultobj = 0;
27075 wxPyApp *arg1 = (wxPyApp *) 0 ;
27076 bool arg2 = (bool) false ;
27077 bool result;
27078 void *argp1 = 0 ;
27079 int res1 = 0 ;
27080 bool val2 ;
27081 int ecode2 = 0 ;
27082 PyObject * obj0 = 0 ;
27083 PyObject * obj1 = 0 ;
27084 char * kwnames[] = {
27085 (char *) "self",(char *) "onlyIfNeeded", NULL
27086 };
27087
27088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27090 if (!SWIG_IsOK(res1)) {
27091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27092 }
27093 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27094 if (obj1) {
27095 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27096 if (!SWIG_IsOK(ecode2)) {
27097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27098 }
27099 arg2 = static_cast< bool >(val2);
27100 }
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 result = (bool)(arg1)->Yield(arg2);
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 {
27108 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27109 }
27110 return resultobj;
27111 fail:
27112 return NULL;
27113 }
27114
27115
27116 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27117 PyObject *resultobj = 0;
27118 wxPyApp *arg1 = (wxPyApp *) 0 ;
27119 void *argp1 = 0 ;
27120 int res1 = 0 ;
27121 PyObject *swig_obj[1] ;
27122
27123 if (!args) SWIG_fail;
27124 swig_obj[0] = args;
27125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27126 if (!SWIG_IsOK(res1)) {
27127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27128 }
27129 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27130 {
27131 PyThreadState* __tstate = wxPyBeginAllowThreads();
27132 (arg1)->WakeUpIdle();
27133 wxPyEndAllowThreads(__tstate);
27134 if (PyErr_Occurred()) SWIG_fail;
27135 }
27136 resultobj = SWIG_Py_Void();
27137 return resultobj;
27138 fail:
27139 return NULL;
27140 }
27141
27142
27143 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27144 PyObject *resultobj = 0;
27145 bool result;
27146
27147 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27148 {
27149 PyThreadState* __tstate = wxPyBeginAllowThreads();
27150 result = (bool)wxPyApp::IsMainLoopRunning();
27151 wxPyEndAllowThreads(__tstate);
27152 if (PyErr_Occurred()) SWIG_fail;
27153 }
27154 {
27155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27156 }
27157 return resultobj;
27158 fail:
27159 return NULL;
27160 }
27161
27162
27163 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27164 PyObject *resultobj = 0;
27165 wxPyApp *arg1 = (wxPyApp *) 0 ;
27166 int result;
27167 void *argp1 = 0 ;
27168 int res1 = 0 ;
27169 PyObject *swig_obj[1] ;
27170
27171 if (!args) SWIG_fail;
27172 swig_obj[0] = args;
27173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27174 if (!SWIG_IsOK(res1)) {
27175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27176 }
27177 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27178 {
27179 PyThreadState* __tstate = wxPyBeginAllowThreads();
27180 result = (int)(arg1)->MainLoop();
27181 wxPyEndAllowThreads(__tstate);
27182 if (PyErr_Occurred()) SWIG_fail;
27183 }
27184 resultobj = SWIG_From_int(static_cast< int >(result));
27185 return resultobj;
27186 fail:
27187 return NULL;
27188 }
27189
27190
27191 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27192 PyObject *resultobj = 0;
27193 wxPyApp *arg1 = (wxPyApp *) 0 ;
27194 void *argp1 = 0 ;
27195 int res1 = 0 ;
27196 PyObject *swig_obj[1] ;
27197
27198 if (!args) SWIG_fail;
27199 swig_obj[0] = args;
27200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27201 if (!SWIG_IsOK(res1)) {
27202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27203 }
27204 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27205 {
27206 PyThreadState* __tstate = wxPyBeginAllowThreads();
27207 (arg1)->Exit();
27208 wxPyEndAllowThreads(__tstate);
27209 if (PyErr_Occurred()) SWIG_fail;
27210 }
27211 resultobj = SWIG_Py_Void();
27212 return resultobj;
27213 fail:
27214 return NULL;
27215 }
27216
27217
27218 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27219 PyObject *resultobj = 0;
27220 wxPyApp *arg1 = (wxPyApp *) 0 ;
27221 void *argp1 = 0 ;
27222 int res1 = 0 ;
27223 PyObject *swig_obj[1] ;
27224
27225 if (!args) SWIG_fail;
27226 swig_obj[0] = args;
27227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27228 if (!SWIG_IsOK(res1)) {
27229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27230 }
27231 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27232 {
27233 PyThreadState* __tstate = wxPyBeginAllowThreads();
27234 (arg1)->ExitMainLoop();
27235 wxPyEndAllowThreads(__tstate);
27236 if (PyErr_Occurred()) SWIG_fail;
27237 }
27238 resultobj = SWIG_Py_Void();
27239 return resultobj;
27240 fail:
27241 return NULL;
27242 }
27243
27244
27245 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27246 PyObject *resultobj = 0;
27247 wxPyApp *arg1 = (wxPyApp *) 0 ;
27248 bool result;
27249 void *argp1 = 0 ;
27250 int res1 = 0 ;
27251 PyObject *swig_obj[1] ;
27252
27253 if (!args) SWIG_fail;
27254 swig_obj[0] = args;
27255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27256 if (!SWIG_IsOK(res1)) {
27257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27258 }
27259 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27260 {
27261 PyThreadState* __tstate = wxPyBeginAllowThreads();
27262 result = (bool)(arg1)->Pending();
27263 wxPyEndAllowThreads(__tstate);
27264 if (PyErr_Occurred()) SWIG_fail;
27265 }
27266 {
27267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27268 }
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27276 PyObject *resultobj = 0;
27277 wxPyApp *arg1 = (wxPyApp *) 0 ;
27278 bool result;
27279 void *argp1 = 0 ;
27280 int res1 = 0 ;
27281 PyObject *swig_obj[1] ;
27282
27283 if (!args) SWIG_fail;
27284 swig_obj[0] = args;
27285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27286 if (!SWIG_IsOK(res1)) {
27287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27288 }
27289 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27290 {
27291 PyThreadState* __tstate = wxPyBeginAllowThreads();
27292 result = (bool)(arg1)->Dispatch();
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27298 }
27299 return resultobj;
27300 fail:
27301 return NULL;
27302 }
27303
27304
27305 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27306 PyObject *resultobj = 0;
27307 wxPyApp *arg1 = (wxPyApp *) 0 ;
27308 bool result;
27309 void *argp1 = 0 ;
27310 int res1 = 0 ;
27311 PyObject *swig_obj[1] ;
27312
27313 if (!args) SWIG_fail;
27314 swig_obj[0] = args;
27315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27316 if (!SWIG_IsOK(res1)) {
27317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27318 }
27319 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27320 {
27321 PyThreadState* __tstate = wxPyBeginAllowThreads();
27322 result = (bool)(arg1)->ProcessIdle();
27323 wxPyEndAllowThreads(__tstate);
27324 if (PyErr_Occurred()) SWIG_fail;
27325 }
27326 {
27327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27328 }
27329 return resultobj;
27330 fail:
27331 return NULL;
27332 }
27333
27334
27335 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27336 PyObject *resultobj = 0;
27337 wxPyApp *arg1 = (wxPyApp *) 0 ;
27338 wxWindow *arg2 = (wxWindow *) 0 ;
27339 wxIdleEvent *arg3 = 0 ;
27340 bool result;
27341 void *argp1 = 0 ;
27342 int res1 = 0 ;
27343 void *argp2 = 0 ;
27344 int res2 = 0 ;
27345 void *argp3 = 0 ;
27346 int res3 = 0 ;
27347 PyObject * obj0 = 0 ;
27348 PyObject * obj1 = 0 ;
27349 PyObject * obj2 = 0 ;
27350 char * kwnames[] = {
27351 (char *) "self",(char *) "win",(char *) "event", NULL
27352 };
27353
27354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27356 if (!SWIG_IsOK(res1)) {
27357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27358 }
27359 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27361 if (!SWIG_IsOK(res2)) {
27362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27363 }
27364 arg2 = reinterpret_cast< wxWindow * >(argp2);
27365 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27366 if (!SWIG_IsOK(res3)) {
27367 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27368 }
27369 if (!argp3) {
27370 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27371 }
27372 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27373 {
27374 PyThreadState* __tstate = wxPyBeginAllowThreads();
27375 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27376 wxPyEndAllowThreads(__tstate);
27377 if (PyErr_Occurred()) SWIG_fail;
27378 }
27379 {
27380 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27381 }
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27389 PyObject *resultobj = 0;
27390 wxPyApp *arg1 = (wxPyApp *) 0 ;
27391 bool result;
27392 void *argp1 = 0 ;
27393 int res1 = 0 ;
27394 PyObject *swig_obj[1] ;
27395
27396 if (!args) SWIG_fail;
27397 swig_obj[0] = args;
27398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27399 if (!SWIG_IsOK(res1)) {
27400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27401 }
27402 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27403 {
27404 PyThreadState* __tstate = wxPyBeginAllowThreads();
27405 result = (bool)((wxPyApp const *)arg1)->IsActive();
27406 wxPyEndAllowThreads(__tstate);
27407 if (PyErr_Occurred()) SWIG_fail;
27408 }
27409 {
27410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27411 }
27412 return resultobj;
27413 fail:
27414 return NULL;
27415 }
27416
27417
27418 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27419 PyObject *resultobj = 0;
27420 wxPyApp *arg1 = (wxPyApp *) 0 ;
27421 wxWindow *arg2 = (wxWindow *) 0 ;
27422 void *argp1 = 0 ;
27423 int res1 = 0 ;
27424 void *argp2 = 0 ;
27425 int res2 = 0 ;
27426 PyObject * obj0 = 0 ;
27427 PyObject * obj1 = 0 ;
27428 char * kwnames[] = {
27429 (char *) "self",(char *) "win", NULL
27430 };
27431
27432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27434 if (!SWIG_IsOK(res1)) {
27435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27436 }
27437 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27438 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27439 if (!SWIG_IsOK(res2)) {
27440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27441 }
27442 arg2 = reinterpret_cast< wxWindow * >(argp2);
27443 {
27444 PyThreadState* __tstate = wxPyBeginAllowThreads();
27445 (arg1)->SetTopWindow(arg2);
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 resultobj = SWIG_Py_Void();
27450 return resultobj;
27451 fail:
27452 return NULL;
27453 }
27454
27455
27456 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27457 PyObject *resultobj = 0;
27458 wxPyApp *arg1 = (wxPyApp *) 0 ;
27459 wxWindow *result = 0 ;
27460 void *argp1 = 0 ;
27461 int res1 = 0 ;
27462 PyObject *swig_obj[1] ;
27463
27464 if (!args) SWIG_fail;
27465 swig_obj[0] = args;
27466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27467 if (!SWIG_IsOK(res1)) {
27468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27469 }
27470 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27471 {
27472 PyThreadState* __tstate = wxPyBeginAllowThreads();
27473 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27474 wxPyEndAllowThreads(__tstate);
27475 if (PyErr_Occurred()) SWIG_fail;
27476 }
27477 {
27478 resultobj = wxPyMake_wxObject(result, (bool)0);
27479 }
27480 return resultobj;
27481 fail:
27482 return NULL;
27483 }
27484
27485
27486 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27487 PyObject *resultobj = 0;
27488 wxPyApp *arg1 = (wxPyApp *) 0 ;
27489 bool arg2 ;
27490 void *argp1 = 0 ;
27491 int res1 = 0 ;
27492 bool val2 ;
27493 int ecode2 = 0 ;
27494 PyObject * obj0 = 0 ;
27495 PyObject * obj1 = 0 ;
27496 char * kwnames[] = {
27497 (char *) "self",(char *) "flag", NULL
27498 };
27499
27500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27502 if (!SWIG_IsOK(res1)) {
27503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27504 }
27505 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27507 if (!SWIG_IsOK(ecode2)) {
27508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27509 }
27510 arg2 = static_cast< bool >(val2);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 (arg1)->SetExitOnFrameDelete(arg2);
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 resultobj = SWIG_Py_Void();
27518 return resultobj;
27519 fail:
27520 return NULL;
27521 }
27522
27523
27524 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27525 PyObject *resultobj = 0;
27526 wxPyApp *arg1 = (wxPyApp *) 0 ;
27527 bool result;
27528 void *argp1 = 0 ;
27529 int res1 = 0 ;
27530 PyObject *swig_obj[1] ;
27531
27532 if (!args) SWIG_fail;
27533 swig_obj[0] = args;
27534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27535 if (!SWIG_IsOK(res1)) {
27536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27537 }
27538 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27539 {
27540 PyThreadState* __tstate = wxPyBeginAllowThreads();
27541 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27542 wxPyEndAllowThreads(__tstate);
27543 if (PyErr_Occurred()) SWIG_fail;
27544 }
27545 {
27546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27547 }
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj = 0;
27556 wxPyApp *arg1 = (wxPyApp *) 0 ;
27557 bool arg2 ;
27558 void *argp1 = 0 ;
27559 int res1 = 0 ;
27560 bool val2 ;
27561 int ecode2 = 0 ;
27562 PyObject * obj0 = 0 ;
27563 PyObject * obj1 = 0 ;
27564 char * kwnames[] = {
27565 (char *) "self",(char *) "flag", NULL
27566 };
27567
27568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27570 if (!SWIG_IsOK(res1)) {
27571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27572 }
27573 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27574 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27575 if (!SWIG_IsOK(ecode2)) {
27576 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27577 }
27578 arg2 = static_cast< bool >(val2);
27579 {
27580 PyThreadState* __tstate = wxPyBeginAllowThreads();
27581 (arg1)->SetUseBestVisual(arg2);
27582 wxPyEndAllowThreads(__tstate);
27583 if (PyErr_Occurred()) SWIG_fail;
27584 }
27585 resultobj = SWIG_Py_Void();
27586 return resultobj;
27587 fail:
27588 return NULL;
27589 }
27590
27591
27592 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27593 PyObject *resultobj = 0;
27594 wxPyApp *arg1 = (wxPyApp *) 0 ;
27595 bool result;
27596 void *argp1 = 0 ;
27597 int res1 = 0 ;
27598 PyObject *swig_obj[1] ;
27599
27600 if (!args) SWIG_fail;
27601 swig_obj[0] = args;
27602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27603 if (!SWIG_IsOK(res1)) {
27604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27605 }
27606 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 {
27614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27615 }
27616 return resultobj;
27617 fail:
27618 return NULL;
27619 }
27620
27621
27622 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27623 PyObject *resultobj = 0;
27624 wxPyApp *arg1 = (wxPyApp *) 0 ;
27625 int arg2 ;
27626 void *argp1 = 0 ;
27627 int res1 = 0 ;
27628 int val2 ;
27629 int ecode2 = 0 ;
27630 PyObject * obj0 = 0 ;
27631 PyObject * obj1 = 0 ;
27632 char * kwnames[] = {
27633 (char *) "self",(char *) "mode", NULL
27634 };
27635
27636 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27637 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27638 if (!SWIG_IsOK(res1)) {
27639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27640 }
27641 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27642 ecode2 = SWIG_AsVal_int(obj1, &val2);
27643 if (!SWIG_IsOK(ecode2)) {
27644 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27645 }
27646 arg2 = static_cast< int >(val2);
27647 {
27648 PyThreadState* __tstate = wxPyBeginAllowThreads();
27649 (arg1)->SetPrintMode(arg2);
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 resultobj = SWIG_Py_Void();
27654 return resultobj;
27655 fail:
27656 return NULL;
27657 }
27658
27659
27660 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27661 PyObject *resultobj = 0;
27662 wxPyApp *arg1 = (wxPyApp *) 0 ;
27663 int result;
27664 void *argp1 = 0 ;
27665 int res1 = 0 ;
27666 PyObject *swig_obj[1] ;
27667
27668 if (!args) SWIG_fail;
27669 swig_obj[0] = args;
27670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27671 if (!SWIG_IsOK(res1)) {
27672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27673 }
27674 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 resultobj = SWIG_From_int(static_cast< int >(result));
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27689 PyObject *resultobj = 0;
27690 wxPyApp *arg1 = (wxPyApp *) 0 ;
27691 int arg2 ;
27692 void *argp1 = 0 ;
27693 int res1 = 0 ;
27694 int val2 ;
27695 int ecode2 = 0 ;
27696 PyObject * obj0 = 0 ;
27697 PyObject * obj1 = 0 ;
27698 char * kwnames[] = {
27699 (char *) "self",(char *) "mode", NULL
27700 };
27701
27702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27704 if (!SWIG_IsOK(res1)) {
27705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27706 }
27707 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27708 ecode2 = SWIG_AsVal_int(obj1, &val2);
27709 if (!SWIG_IsOK(ecode2)) {
27710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27711 }
27712 arg2 = static_cast< int >(val2);
27713 {
27714 PyThreadState* __tstate = wxPyBeginAllowThreads();
27715 (arg1)->SetAssertMode(arg2);
27716 wxPyEndAllowThreads(__tstate);
27717 if (PyErr_Occurred()) SWIG_fail;
27718 }
27719 resultobj = SWIG_Py_Void();
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27727 PyObject *resultobj = 0;
27728 wxPyApp *arg1 = (wxPyApp *) 0 ;
27729 int result;
27730 void *argp1 = 0 ;
27731 int res1 = 0 ;
27732 PyObject *swig_obj[1] ;
27733
27734 if (!args) SWIG_fail;
27735 swig_obj[0] = args;
27736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27737 if (!SWIG_IsOK(res1)) {
27738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27739 }
27740 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27741 {
27742 PyThreadState* __tstate = wxPyBeginAllowThreads();
27743 result = (int)(arg1)->GetAssertMode();
27744 wxPyEndAllowThreads(__tstate);
27745 if (PyErr_Occurred()) SWIG_fail;
27746 }
27747 resultobj = SWIG_From_int(static_cast< int >(result));
27748 return resultobj;
27749 fail:
27750 return NULL;
27751 }
27752
27753
27754 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27755 PyObject *resultobj = 0;
27756 bool result;
27757
27758 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27759 {
27760 PyThreadState* __tstate = wxPyBeginAllowThreads();
27761 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27762 wxPyEndAllowThreads(__tstate);
27763 if (PyErr_Occurred()) SWIG_fail;
27764 }
27765 {
27766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27767 }
27768 return resultobj;
27769 fail:
27770 return NULL;
27771 }
27772
27773
27774 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27775 PyObject *resultobj = 0;
27776 long result;
27777
27778 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27779 {
27780 PyThreadState* __tstate = wxPyBeginAllowThreads();
27781 result = (long)wxPyApp::GetMacAboutMenuItemId();
27782 wxPyEndAllowThreads(__tstate);
27783 if (PyErr_Occurred()) SWIG_fail;
27784 }
27785 resultobj = SWIG_From_long(static_cast< long >(result));
27786 return resultobj;
27787 fail:
27788 return NULL;
27789 }
27790
27791
27792 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27793 PyObject *resultobj = 0;
27794 long result;
27795
27796 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27797 {
27798 PyThreadState* __tstate = wxPyBeginAllowThreads();
27799 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27800 wxPyEndAllowThreads(__tstate);
27801 if (PyErr_Occurred()) SWIG_fail;
27802 }
27803 resultobj = SWIG_From_long(static_cast< long >(result));
27804 return resultobj;
27805 fail:
27806 return NULL;
27807 }
27808
27809
27810 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27811 PyObject *resultobj = 0;
27812 long result;
27813
27814 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27815 {
27816 PyThreadState* __tstate = wxPyBeginAllowThreads();
27817 result = (long)wxPyApp::GetMacExitMenuItemId();
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 resultobj = SWIG_From_long(static_cast< long >(result));
27822 return resultobj;
27823 fail:
27824 return NULL;
27825 }
27826
27827
27828 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27829 PyObject *resultobj = 0;
27830 wxString result;
27831
27832 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27833 {
27834 PyThreadState* __tstate = wxPyBeginAllowThreads();
27835 result = wxPyApp::GetMacHelpMenuTitleName();
27836 wxPyEndAllowThreads(__tstate);
27837 if (PyErr_Occurred()) SWIG_fail;
27838 }
27839 {
27840 #if wxUSE_UNICODE
27841 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27842 #else
27843 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27844 #endif
27845 }
27846 return resultobj;
27847 fail:
27848 return NULL;
27849 }
27850
27851
27852 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27853 PyObject *resultobj = 0;
27854 bool arg1 ;
27855 bool val1 ;
27856 int ecode1 = 0 ;
27857 PyObject * obj0 = 0 ;
27858 char * kwnames[] = {
27859 (char *) "val", NULL
27860 };
27861
27862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
27863 ecode1 = SWIG_AsVal_bool(obj0, &val1);
27864 if (!SWIG_IsOK(ecode1)) {
27865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
27866 }
27867 arg1 = static_cast< bool >(val1);
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 resultobj = SWIG_Py_Void();
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27882 PyObject *resultobj = 0;
27883 long arg1 ;
27884 long val1 ;
27885 int ecode1 = 0 ;
27886 PyObject * obj0 = 0 ;
27887 char * kwnames[] = {
27888 (char *) "val", NULL
27889 };
27890
27891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
27892 ecode1 = SWIG_AsVal_long(obj0, &val1);
27893 if (!SWIG_IsOK(ecode1)) {
27894 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
27895 }
27896 arg1 = static_cast< long >(val1);
27897 {
27898 PyThreadState* __tstate = wxPyBeginAllowThreads();
27899 wxPyApp::SetMacAboutMenuItemId(arg1);
27900 wxPyEndAllowThreads(__tstate);
27901 if (PyErr_Occurred()) SWIG_fail;
27902 }
27903 resultobj = SWIG_Py_Void();
27904 return resultobj;
27905 fail:
27906 return NULL;
27907 }
27908
27909
27910 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27911 PyObject *resultobj = 0;
27912 long arg1 ;
27913 long val1 ;
27914 int ecode1 = 0 ;
27915 PyObject * obj0 = 0 ;
27916 char * kwnames[] = {
27917 (char *) "val", NULL
27918 };
27919
27920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
27921 ecode1 = SWIG_AsVal_long(obj0, &val1);
27922 if (!SWIG_IsOK(ecode1)) {
27923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
27924 }
27925 arg1 = static_cast< long >(val1);
27926 {
27927 PyThreadState* __tstate = wxPyBeginAllowThreads();
27928 wxPyApp::SetMacPreferencesMenuItemId(arg1);
27929 wxPyEndAllowThreads(__tstate);
27930 if (PyErr_Occurred()) SWIG_fail;
27931 }
27932 resultobj = SWIG_Py_Void();
27933 return resultobj;
27934 fail:
27935 return NULL;
27936 }
27937
27938
27939 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27940 PyObject *resultobj = 0;
27941 long arg1 ;
27942 long val1 ;
27943 int ecode1 = 0 ;
27944 PyObject * obj0 = 0 ;
27945 char * kwnames[] = {
27946 (char *) "val", NULL
27947 };
27948
27949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
27950 ecode1 = SWIG_AsVal_long(obj0, &val1);
27951 if (!SWIG_IsOK(ecode1)) {
27952 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
27953 }
27954 arg1 = static_cast< long >(val1);
27955 {
27956 PyThreadState* __tstate = wxPyBeginAllowThreads();
27957 wxPyApp::SetMacExitMenuItemId(arg1);
27958 wxPyEndAllowThreads(__tstate);
27959 if (PyErr_Occurred()) SWIG_fail;
27960 }
27961 resultobj = SWIG_Py_Void();
27962 return resultobj;
27963 fail:
27964 return NULL;
27965 }
27966
27967
27968 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27969 PyObject *resultobj = 0;
27970 wxString *arg1 = 0 ;
27971 bool temp1 = false ;
27972 PyObject * obj0 = 0 ;
27973 char * kwnames[] = {
27974 (char *) "val", NULL
27975 };
27976
27977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
27978 {
27979 arg1 = wxString_in_helper(obj0);
27980 if (arg1 == NULL) SWIG_fail;
27981 temp1 = true;
27982 }
27983 {
27984 PyThreadState* __tstate = wxPyBeginAllowThreads();
27985 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
27986 wxPyEndAllowThreads(__tstate);
27987 if (PyErr_Occurred()) SWIG_fail;
27988 }
27989 resultobj = SWIG_Py_Void();
27990 {
27991 if (temp1)
27992 delete arg1;
27993 }
27994 return resultobj;
27995 fail:
27996 {
27997 if (temp1)
27998 delete arg1;
27999 }
28000 return NULL;
28001 }
28002
28003
28004 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28005 PyObject *resultobj = 0;
28006 wxPyApp *arg1 = (wxPyApp *) 0 ;
28007 void *argp1 = 0 ;
28008 int res1 = 0 ;
28009 PyObject *swig_obj[1] ;
28010
28011 if (!args) SWIG_fail;
28012 swig_obj[0] = args;
28013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28014 if (!SWIG_IsOK(res1)) {
28015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28016 }
28017 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28018 {
28019 PyThreadState* __tstate = wxPyBeginAllowThreads();
28020 (arg1)->_BootstrapApp();
28021 wxPyEndAllowThreads(__tstate);
28022 if (PyErr_Occurred()) SWIG_fail;
28023 }
28024 resultobj = SWIG_Py_Void();
28025 return resultobj;
28026 fail:
28027 return NULL;
28028 }
28029
28030
28031 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28032 PyObject *resultobj = 0;
28033 int result;
28034
28035 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28036 {
28037 PyThreadState* __tstate = wxPyBeginAllowThreads();
28038 result = (int)wxPyApp::GetComCtl32Version();
28039 wxPyEndAllowThreads(__tstate);
28040 if (PyErr_Occurred()) SWIG_fail;
28041 }
28042 resultobj = SWIG_From_int(static_cast< int >(result));
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28050 PyObject *obj;
28051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28052 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28053 return SWIG_Py_Void();
28054 }
28055
28056 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28057 return SWIG_Python_InitShadowInstance(args);
28058 }
28059
28060 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28061 PyObject *resultobj = 0;
28062
28063 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28064 {
28065 PyThreadState* __tstate = wxPyBeginAllowThreads();
28066 wxExit();
28067 wxPyEndAllowThreads(__tstate);
28068 if (PyErr_Occurred()) SWIG_fail;
28069 }
28070 resultobj = SWIG_Py_Void();
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28078 PyObject *resultobj = 0;
28079 bool result;
28080
28081 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28082 {
28083 PyThreadState* __tstate = wxPyBeginAllowThreads();
28084 result = (bool)wxYield();
28085 wxPyEndAllowThreads(__tstate);
28086 if (PyErr_Occurred()) SWIG_fail;
28087 }
28088 {
28089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28090 }
28091 return resultobj;
28092 fail:
28093 return NULL;
28094 }
28095
28096
28097 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28098 PyObject *resultobj = 0;
28099 bool result;
28100
28101 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28102 {
28103 PyThreadState* __tstate = wxPyBeginAllowThreads();
28104 result = (bool)wxYieldIfNeeded();
28105 wxPyEndAllowThreads(__tstate);
28106 if (PyErr_Occurred()) SWIG_fail;
28107 }
28108 {
28109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28110 }
28111 return resultobj;
28112 fail:
28113 return NULL;
28114 }
28115
28116
28117 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28118 PyObject *resultobj = 0;
28119 wxWindow *arg1 = (wxWindow *) NULL ;
28120 bool arg2 = (bool) false ;
28121 bool result;
28122 void *argp1 = 0 ;
28123 int res1 = 0 ;
28124 bool val2 ;
28125 int ecode2 = 0 ;
28126 PyObject * obj0 = 0 ;
28127 PyObject * obj1 = 0 ;
28128 char * kwnames[] = {
28129 (char *) "win",(char *) "onlyIfNeeded", NULL
28130 };
28131
28132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28133 if (obj0) {
28134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28135 if (!SWIG_IsOK(res1)) {
28136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28137 }
28138 arg1 = reinterpret_cast< wxWindow * >(argp1);
28139 }
28140 if (obj1) {
28141 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28142 if (!SWIG_IsOK(ecode2)) {
28143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28144 }
28145 arg2 = static_cast< bool >(val2);
28146 }
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 result = (bool)wxSafeYield(arg1,arg2);
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 {
28154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28155 }
28156 return resultobj;
28157 fail:
28158 return NULL;
28159 }
28160
28161
28162 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28163 PyObject *resultobj = 0;
28164
28165 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28166 {
28167 PyThreadState* __tstate = wxPyBeginAllowThreads();
28168 wxWakeUpIdle();
28169 wxPyEndAllowThreads(__tstate);
28170 if (PyErr_Occurred()) SWIG_fail;
28171 }
28172 resultobj = SWIG_Py_Void();
28173 return resultobj;
28174 fail:
28175 return NULL;
28176 }
28177
28178
28179 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28180 PyObject *resultobj = 0;
28181 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28182 wxEvent *arg2 = 0 ;
28183 void *argp1 = 0 ;
28184 int res1 = 0 ;
28185 void *argp2 = 0 ;
28186 int res2 = 0 ;
28187 PyObject * obj0 = 0 ;
28188 PyObject * obj1 = 0 ;
28189 char * kwnames[] = {
28190 (char *) "dest",(char *) "event", NULL
28191 };
28192
28193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28195 if (!SWIG_IsOK(res1)) {
28196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28197 }
28198 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28199 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28200 if (!SWIG_IsOK(res2)) {
28201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28202 }
28203 if (!argp2) {
28204 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28205 }
28206 arg2 = reinterpret_cast< wxEvent * >(argp2);
28207 {
28208 PyThreadState* __tstate = wxPyBeginAllowThreads();
28209 wxPostEvent(arg1,*arg2);
28210 wxPyEndAllowThreads(__tstate);
28211 if (PyErr_Occurred()) SWIG_fail;
28212 }
28213 resultobj = SWIG_Py_Void();
28214 return resultobj;
28215 fail:
28216 return NULL;
28217 }
28218
28219
28220 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28221 PyObject *resultobj = 0;
28222
28223 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28224 {
28225 PyThreadState* __tstate = wxPyBeginAllowThreads();
28226 wxApp_CleanUp();
28227 wxPyEndAllowThreads(__tstate);
28228 if (PyErr_Occurred()) SWIG_fail;
28229 }
28230 resultobj = SWIG_Py_Void();
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28238 PyObject *resultobj = 0;
28239 wxPyApp *result = 0 ;
28240
28241 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28242 {
28243 PyThreadState* __tstate = wxPyBeginAllowThreads();
28244 result = (wxPyApp *)wxPyGetApp();
28245 wxPyEndAllowThreads(__tstate);
28246 if (PyErr_Occurred()) SWIG_fail;
28247 }
28248 {
28249 resultobj = wxPyMake_wxObject(result, 0);
28250 }
28251 return resultobj;
28252 fail:
28253 return NULL;
28254 }
28255
28256
28257 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28258 PyObject *resultobj = 0;
28259 char *arg1 = (char *) 0 ;
28260 int res1 ;
28261 char *buf1 = 0 ;
28262 int alloc1 = 0 ;
28263 PyObject * obj0 = 0 ;
28264 char * kwnames[] = {
28265 (char *) "encoding", NULL
28266 };
28267
28268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28269 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28270 if (!SWIG_IsOK(res1)) {
28271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28272 }
28273 arg1 = buf1;
28274 {
28275 PyThreadState* __tstate = wxPyBeginAllowThreads();
28276 wxSetDefaultPyEncoding((char const *)arg1);
28277 wxPyEndAllowThreads(__tstate);
28278 if (PyErr_Occurred()) SWIG_fail;
28279 }
28280 resultobj = SWIG_Py_Void();
28281 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28282 return resultobj;
28283 fail:
28284 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28285 return NULL;
28286 }
28287
28288
28289 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28290 PyObject *resultobj = 0;
28291 char *result = 0 ;
28292
28293 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28294 {
28295 PyThreadState* __tstate = wxPyBeginAllowThreads();
28296 result = (char *)wxGetDefaultPyEncoding();
28297 wxPyEndAllowThreads(__tstate);
28298 if (PyErr_Occurred()) SWIG_fail;
28299 }
28300 resultobj = SWIG_FromCharPtr(result);
28301 return resultobj;
28302 fail:
28303 return NULL;
28304 }
28305
28306
28307 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28308 PyObject *resultobj = 0;
28309 wxEventLoop *result = 0 ;
28310
28311 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 result = (wxEventLoop *)new wxEventLoop();
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28326 PyObject *resultobj = 0;
28327 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28328 void *argp1 = 0 ;
28329 int res1 = 0 ;
28330 PyObject *swig_obj[1] ;
28331
28332 if (!args) SWIG_fail;
28333 swig_obj[0] = args;
28334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28335 if (!SWIG_IsOK(res1)) {
28336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28337 }
28338 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28339 {
28340 PyThreadState* __tstate = wxPyBeginAllowThreads();
28341 delete arg1;
28342
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 resultobj = SWIG_Py_Void();
28347 return resultobj;
28348 fail:
28349 return NULL;
28350 }
28351
28352
28353 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28354 PyObject *resultobj = 0;
28355 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28356 int result;
28357 void *argp1 = 0 ;
28358 int res1 = 0 ;
28359 PyObject *swig_obj[1] ;
28360
28361 if (!args) SWIG_fail;
28362 swig_obj[0] = args;
28363 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28364 if (!SWIG_IsOK(res1)) {
28365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28366 }
28367 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28368 {
28369 PyThreadState* __tstate = wxPyBeginAllowThreads();
28370 result = (int)(arg1)->Run();
28371 wxPyEndAllowThreads(__tstate);
28372 if (PyErr_Occurred()) SWIG_fail;
28373 }
28374 resultobj = SWIG_From_int(static_cast< int >(result));
28375 return resultobj;
28376 fail:
28377 return NULL;
28378 }
28379
28380
28381 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28382 PyObject *resultobj = 0;
28383 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28384 int arg2 = (int) 0 ;
28385 void *argp1 = 0 ;
28386 int res1 = 0 ;
28387 int val2 ;
28388 int ecode2 = 0 ;
28389 PyObject * obj0 = 0 ;
28390 PyObject * obj1 = 0 ;
28391 char * kwnames[] = {
28392 (char *) "self",(char *) "rc", NULL
28393 };
28394
28395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28396 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28397 if (!SWIG_IsOK(res1)) {
28398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28399 }
28400 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28401 if (obj1) {
28402 ecode2 = SWIG_AsVal_int(obj1, &val2);
28403 if (!SWIG_IsOK(ecode2)) {
28404 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28405 }
28406 arg2 = static_cast< int >(val2);
28407 }
28408 {
28409 PyThreadState* __tstate = wxPyBeginAllowThreads();
28410 (arg1)->Exit(arg2);
28411 wxPyEndAllowThreads(__tstate);
28412 if (PyErr_Occurred()) SWIG_fail;
28413 }
28414 resultobj = SWIG_Py_Void();
28415 return resultobj;
28416 fail:
28417 return NULL;
28418 }
28419
28420
28421 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28422 PyObject *resultobj = 0;
28423 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28424 bool result;
28425 void *argp1 = 0 ;
28426 int res1 = 0 ;
28427 PyObject *swig_obj[1] ;
28428
28429 if (!args) SWIG_fail;
28430 swig_obj[0] = args;
28431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28432 if (!SWIG_IsOK(res1)) {
28433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28434 }
28435 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28436 {
28437 PyThreadState* __tstate = wxPyBeginAllowThreads();
28438 result = (bool)((wxEventLoop const *)arg1)->Pending();
28439 wxPyEndAllowThreads(__tstate);
28440 if (PyErr_Occurred()) SWIG_fail;
28441 }
28442 {
28443 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28444 }
28445 return resultobj;
28446 fail:
28447 return NULL;
28448 }
28449
28450
28451 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28452 PyObject *resultobj = 0;
28453 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28454 bool result;
28455 void *argp1 = 0 ;
28456 int res1 = 0 ;
28457 PyObject *swig_obj[1] ;
28458
28459 if (!args) SWIG_fail;
28460 swig_obj[0] = args;
28461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28462 if (!SWIG_IsOK(res1)) {
28463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28464 }
28465 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28466 {
28467 PyThreadState* __tstate = wxPyBeginAllowThreads();
28468 result = (bool)(arg1)->Dispatch();
28469 wxPyEndAllowThreads(__tstate);
28470 if (PyErr_Occurred()) SWIG_fail;
28471 }
28472 {
28473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28474 }
28475 return resultobj;
28476 fail:
28477 return NULL;
28478 }
28479
28480
28481 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28482 PyObject *resultobj = 0;
28483 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28484 bool result;
28485 void *argp1 = 0 ;
28486 int res1 = 0 ;
28487 PyObject *swig_obj[1] ;
28488
28489 if (!args) SWIG_fail;
28490 swig_obj[0] = args;
28491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28492 if (!SWIG_IsOK(res1)) {
28493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28494 }
28495 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28496 {
28497 PyThreadState* __tstate = wxPyBeginAllowThreads();
28498 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28499 wxPyEndAllowThreads(__tstate);
28500 if (PyErr_Occurred()) SWIG_fail;
28501 }
28502 {
28503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28504 }
28505 return resultobj;
28506 fail:
28507 return NULL;
28508 }
28509
28510
28511 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28512 PyObject *resultobj = 0;
28513 wxEventLoop *result = 0 ;
28514
28515 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 result = (wxEventLoop *)wxEventLoop::GetActive();
28519 wxPyEndAllowThreads(__tstate);
28520 if (PyErr_Occurred()) SWIG_fail;
28521 }
28522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28523 return resultobj;
28524 fail:
28525 return NULL;
28526 }
28527
28528
28529 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28530 PyObject *resultobj = 0;
28531 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28532 void *argp1 = 0 ;
28533 int res1 = 0 ;
28534 PyObject * obj0 = 0 ;
28535 char * kwnames[] = {
28536 (char *) "loop", NULL
28537 };
28538
28539 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28540 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28541 if (!SWIG_IsOK(res1)) {
28542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28543 }
28544 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28545 {
28546 PyThreadState* __tstate = wxPyBeginAllowThreads();
28547 wxEventLoop::SetActive(arg1);
28548 wxPyEndAllowThreads(__tstate);
28549 if (PyErr_Occurred()) SWIG_fail;
28550 }
28551 resultobj = SWIG_Py_Void();
28552 return resultobj;
28553 fail:
28554 return NULL;
28555 }
28556
28557
28558 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28559 PyObject *obj;
28560 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28561 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28562 return SWIG_Py_Void();
28563 }
28564
28565 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28566 return SWIG_Python_InitShadowInstance(args);
28567 }
28568
28569 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28570 PyObject *resultobj = 0;
28571 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28572 wxEventLoopActivator *result = 0 ;
28573 void *argp1 = 0 ;
28574 int res1 = 0 ;
28575 PyObject * obj0 = 0 ;
28576 char * kwnames[] = {
28577 (char *) "evtLoop", NULL
28578 };
28579
28580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28581 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28582 if (!SWIG_IsOK(res1)) {
28583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28584 }
28585 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28586 {
28587 PyThreadState* __tstate = wxPyBeginAllowThreads();
28588 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28589 wxPyEndAllowThreads(__tstate);
28590 if (PyErr_Occurred()) SWIG_fail;
28591 }
28592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28600 PyObject *resultobj = 0;
28601 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28602 void *argp1 = 0 ;
28603 int res1 = 0 ;
28604 PyObject *swig_obj[1] ;
28605
28606 if (!args) SWIG_fail;
28607 swig_obj[0] = args;
28608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28609 if (!SWIG_IsOK(res1)) {
28610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28611 }
28612 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28613 {
28614 PyThreadState* __tstate = wxPyBeginAllowThreads();
28615 delete arg1;
28616
28617 wxPyEndAllowThreads(__tstate);
28618 if (PyErr_Occurred()) SWIG_fail;
28619 }
28620 resultobj = SWIG_Py_Void();
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28628 PyObject *obj;
28629 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28630 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28631 return SWIG_Py_Void();
28632 }
28633
28634 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28635 return SWIG_Python_InitShadowInstance(args);
28636 }
28637
28638 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28639 PyObject *resultobj = 0;
28640 int arg1 = (int) 0 ;
28641 int arg2 = (int) 0 ;
28642 int arg3 = (int) 0 ;
28643 wxAcceleratorEntry *result = 0 ;
28644 int val1 ;
28645 int ecode1 = 0 ;
28646 int val2 ;
28647 int ecode2 = 0 ;
28648 int val3 ;
28649 int ecode3 = 0 ;
28650 PyObject * obj0 = 0 ;
28651 PyObject * obj1 = 0 ;
28652 PyObject * obj2 = 0 ;
28653 char * kwnames[] = {
28654 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28655 };
28656
28657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28658 if (obj0) {
28659 ecode1 = SWIG_AsVal_int(obj0, &val1);
28660 if (!SWIG_IsOK(ecode1)) {
28661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28662 }
28663 arg1 = static_cast< int >(val1);
28664 }
28665 if (obj1) {
28666 ecode2 = SWIG_AsVal_int(obj1, &val2);
28667 if (!SWIG_IsOK(ecode2)) {
28668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28669 }
28670 arg2 = static_cast< int >(val2);
28671 }
28672 if (obj2) {
28673 ecode3 = SWIG_AsVal_int(obj2, &val3);
28674 if (!SWIG_IsOK(ecode3)) {
28675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28676 }
28677 arg3 = static_cast< int >(val3);
28678 }
28679 {
28680 PyThreadState* __tstate = wxPyBeginAllowThreads();
28681 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28682 wxPyEndAllowThreads(__tstate);
28683 if (PyErr_Occurred()) SWIG_fail;
28684 }
28685 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28686 return resultobj;
28687 fail:
28688 return NULL;
28689 }
28690
28691
28692 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 PyObject *resultobj = 0;
28694 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28695 void *argp1 = 0 ;
28696 int res1 = 0 ;
28697 PyObject *swig_obj[1] ;
28698
28699 if (!args) SWIG_fail;
28700 swig_obj[0] = args;
28701 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28702 if (!SWIG_IsOK(res1)) {
28703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28704 }
28705 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28706 {
28707 PyThreadState* __tstate = wxPyBeginAllowThreads();
28708 delete arg1;
28709
28710 wxPyEndAllowThreads(__tstate);
28711 if (PyErr_Occurred()) SWIG_fail;
28712 }
28713 resultobj = SWIG_Py_Void();
28714 return resultobj;
28715 fail:
28716 return NULL;
28717 }
28718
28719
28720 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28721 PyObject *resultobj = 0;
28722 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28723 int arg2 ;
28724 int arg3 ;
28725 int arg4 ;
28726 void *argp1 = 0 ;
28727 int res1 = 0 ;
28728 int val2 ;
28729 int ecode2 = 0 ;
28730 int val3 ;
28731 int ecode3 = 0 ;
28732 int val4 ;
28733 int ecode4 = 0 ;
28734 PyObject * obj0 = 0 ;
28735 PyObject * obj1 = 0 ;
28736 PyObject * obj2 = 0 ;
28737 PyObject * obj3 = 0 ;
28738 char * kwnames[] = {
28739 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28740 };
28741
28742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28744 if (!SWIG_IsOK(res1)) {
28745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28746 }
28747 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28748 ecode2 = SWIG_AsVal_int(obj1, &val2);
28749 if (!SWIG_IsOK(ecode2)) {
28750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28751 }
28752 arg2 = static_cast< int >(val2);
28753 ecode3 = SWIG_AsVal_int(obj2, &val3);
28754 if (!SWIG_IsOK(ecode3)) {
28755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28756 }
28757 arg3 = static_cast< int >(val3);
28758 ecode4 = SWIG_AsVal_int(obj3, &val4);
28759 if (!SWIG_IsOK(ecode4)) {
28760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28761 }
28762 arg4 = static_cast< int >(val4);
28763 {
28764 PyThreadState* __tstate = wxPyBeginAllowThreads();
28765 (arg1)->Set(arg2,arg3,arg4);
28766 wxPyEndAllowThreads(__tstate);
28767 if (PyErr_Occurred()) SWIG_fail;
28768 }
28769 resultobj = SWIG_Py_Void();
28770 return resultobj;
28771 fail:
28772 return NULL;
28773 }
28774
28775
28776 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28777 PyObject *resultobj = 0;
28778 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28779 int result;
28780 void *argp1 = 0 ;
28781 int res1 = 0 ;
28782 PyObject *swig_obj[1] ;
28783
28784 if (!args) SWIG_fail;
28785 swig_obj[0] = args;
28786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28787 if (!SWIG_IsOK(res1)) {
28788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28789 }
28790 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28791 {
28792 PyThreadState* __tstate = wxPyBeginAllowThreads();
28793 result = (int)(arg1)->GetFlags();
28794 wxPyEndAllowThreads(__tstate);
28795 if (PyErr_Occurred()) SWIG_fail;
28796 }
28797 resultobj = SWIG_From_int(static_cast< int >(result));
28798 return resultobj;
28799 fail:
28800 return NULL;
28801 }
28802
28803
28804 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28805 PyObject *resultobj = 0;
28806 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28807 int result;
28808 void *argp1 = 0 ;
28809 int res1 = 0 ;
28810 PyObject *swig_obj[1] ;
28811
28812 if (!args) SWIG_fail;
28813 swig_obj[0] = args;
28814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28815 if (!SWIG_IsOK(res1)) {
28816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28817 }
28818 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28819 {
28820 PyThreadState* __tstate = wxPyBeginAllowThreads();
28821 result = (int)(arg1)->GetKeyCode();
28822 wxPyEndAllowThreads(__tstate);
28823 if (PyErr_Occurred()) SWIG_fail;
28824 }
28825 resultobj = SWIG_From_int(static_cast< int >(result));
28826 return resultobj;
28827 fail:
28828 return NULL;
28829 }
28830
28831
28832 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28833 PyObject *resultobj = 0;
28834 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28835 int result;
28836 void *argp1 = 0 ;
28837 int res1 = 0 ;
28838 PyObject *swig_obj[1] ;
28839
28840 if (!args) SWIG_fail;
28841 swig_obj[0] = args;
28842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28843 if (!SWIG_IsOK(res1)) {
28844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28845 }
28846 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28847 {
28848 PyThreadState* __tstate = wxPyBeginAllowThreads();
28849 result = (int)(arg1)->GetCommand();
28850 wxPyEndAllowThreads(__tstate);
28851 if (PyErr_Occurred()) SWIG_fail;
28852 }
28853 resultobj = SWIG_From_int(static_cast< int >(result));
28854 return resultobj;
28855 fail:
28856 return NULL;
28857 }
28858
28859
28860 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28861 PyObject *obj;
28862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28863 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
28864 return SWIG_Py_Void();
28865 }
28866
28867 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28868 return SWIG_Python_InitShadowInstance(args);
28869 }
28870
28871 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28872 PyObject *resultobj = 0;
28873 int arg1 ;
28874 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
28875 wxAcceleratorTable *result = 0 ;
28876 PyObject * obj0 = 0 ;
28877 char * kwnames[] = {
28878 (char *) "n", NULL
28879 };
28880
28881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
28882 {
28883 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
28884 if (arg2) arg1 = PyList_Size(obj0);
28885 else arg1 = 0;
28886 }
28887 {
28888 PyThreadState* __tstate = wxPyBeginAllowThreads();
28889 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
28890 wxPyEndAllowThreads(__tstate);
28891 if (PyErr_Occurred()) SWIG_fail;
28892 }
28893 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
28894 return resultobj;
28895 fail:
28896 return NULL;
28897 }
28898
28899
28900 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28901 PyObject *resultobj = 0;
28902 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28903 void *argp1 = 0 ;
28904 int res1 = 0 ;
28905 PyObject *swig_obj[1] ;
28906
28907 if (!args) SWIG_fail;
28908 swig_obj[0] = args;
28909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
28910 if (!SWIG_IsOK(res1)) {
28911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
28912 }
28913 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 delete arg1;
28917
28918 wxPyEndAllowThreads(__tstate);
28919 if (PyErr_Occurred()) SWIG_fail;
28920 }
28921 resultobj = SWIG_Py_Void();
28922 return resultobj;
28923 fail:
28924 return NULL;
28925 }
28926
28927
28928 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28929 PyObject *resultobj = 0;
28930 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
28931 bool result;
28932 void *argp1 = 0 ;
28933 int res1 = 0 ;
28934 PyObject *swig_obj[1] ;
28935
28936 if (!args) SWIG_fail;
28937 swig_obj[0] = args;
28938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
28939 if (!SWIG_IsOK(res1)) {
28940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
28941 }
28942 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 {
28950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28951 }
28952 return resultobj;
28953 fail:
28954 return NULL;
28955 }
28956
28957
28958 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28959 PyObject *obj;
28960 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28961 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
28962 return SWIG_Py_Void();
28963 }
28964
28965 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28966 return SWIG_Python_InitShadowInstance(args);
28967 }
28968
28969 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
28970 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
28971 return 1;
28972 }
28973
28974
28975 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
28976 PyObject *pyobj = 0;
28977
28978 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
28979 return pyobj;
28980 }
28981
28982
28983 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28984 PyObject *resultobj = 0;
28985 wxString *arg1 = 0 ;
28986 wxAcceleratorEntry *result = 0 ;
28987 bool temp1 = false ;
28988 PyObject * obj0 = 0 ;
28989 char * kwnames[] = {
28990 (char *) "label", NULL
28991 };
28992
28993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
28994 {
28995 arg1 = wxString_in_helper(obj0);
28996 if (arg1 == NULL) SWIG_fail;
28997 temp1 = true;
28998 }
28999 {
29000 PyThreadState* __tstate = wxPyBeginAllowThreads();
29001 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29002 wxPyEndAllowThreads(__tstate);
29003 if (PyErr_Occurred()) SWIG_fail;
29004 }
29005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29006 {
29007 if (temp1)
29008 delete arg1;
29009 }
29010 return resultobj;
29011 fail:
29012 {
29013 if (temp1)
29014 delete arg1;
29015 }
29016 return NULL;
29017 }
29018
29019
29020 SWIGINTERN int PanelNameStr_set(PyObject *) {
29021 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29022 return 1;
29023 }
29024
29025
29026 SWIGINTERN PyObject *PanelNameStr_get(void) {
29027 PyObject *pyobj = 0;
29028
29029 {
29030 #if wxUSE_UNICODE
29031 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29032 #else
29033 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29034 #endif
29035 }
29036 return pyobj;
29037 }
29038
29039
29040 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29041 PyObject *resultobj = 0;
29042 wxVisualAttributes *result = 0 ;
29043
29044 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29045 {
29046 PyThreadState* __tstate = wxPyBeginAllowThreads();
29047 result = (wxVisualAttributes *)new_wxVisualAttributes();
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29052 return resultobj;
29053 fail:
29054 return NULL;
29055 }
29056
29057
29058 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29059 PyObject *resultobj = 0;
29060 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29061 void *argp1 = 0 ;
29062 int res1 = 0 ;
29063 PyObject *swig_obj[1] ;
29064
29065 if (!args) SWIG_fail;
29066 swig_obj[0] = args;
29067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29068 if (!SWIG_IsOK(res1)) {
29069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29070 }
29071 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29072 {
29073 PyThreadState* __tstate = wxPyBeginAllowThreads();
29074 delete_wxVisualAttributes(arg1);
29075
29076 wxPyEndAllowThreads(__tstate);
29077 if (PyErr_Occurred()) SWIG_fail;
29078 }
29079 resultobj = SWIG_Py_Void();
29080 return resultobj;
29081 fail:
29082 return NULL;
29083 }
29084
29085
29086 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29087 PyObject *resultobj = 0;
29088 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29089 wxFont *arg2 = (wxFont *) 0 ;
29090 void *argp1 = 0 ;
29091 int res1 = 0 ;
29092 void *argp2 = 0 ;
29093 int res2 = 0 ;
29094 PyObject *swig_obj[2] ;
29095
29096 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29098 if (!SWIG_IsOK(res1)) {
29099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29100 }
29101 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29102 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29103 if (!SWIG_IsOK(res2)) {
29104 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29105 }
29106 arg2 = reinterpret_cast< wxFont * >(argp2);
29107 if (arg1) (arg1)->font = *arg2;
29108
29109 resultobj = SWIG_Py_Void();
29110 return resultobj;
29111 fail:
29112 return NULL;
29113 }
29114
29115
29116 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29117 PyObject *resultobj = 0;
29118 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29119 wxFont *result = 0 ;
29120 void *argp1 = 0 ;
29121 int res1 = 0 ;
29122 PyObject *swig_obj[1] ;
29123
29124 if (!args) SWIG_fail;
29125 swig_obj[0] = args;
29126 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29127 if (!SWIG_IsOK(res1)) {
29128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29129 }
29130 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29131 result = (wxFont *)& ((arg1)->font);
29132 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29133 return resultobj;
29134 fail:
29135 return NULL;
29136 }
29137
29138
29139 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29140 PyObject *resultobj = 0;
29141 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29142 wxColour *arg2 = (wxColour *) 0 ;
29143 void *argp1 = 0 ;
29144 int res1 = 0 ;
29145 void *argp2 = 0 ;
29146 int res2 = 0 ;
29147 PyObject *swig_obj[2] ;
29148
29149 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29150 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29151 if (!SWIG_IsOK(res1)) {
29152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29153 }
29154 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29155 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29156 if (!SWIG_IsOK(res2)) {
29157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29158 }
29159 arg2 = reinterpret_cast< wxColour * >(argp2);
29160 if (arg1) (arg1)->colFg = *arg2;
29161
29162 resultobj = SWIG_Py_Void();
29163 return resultobj;
29164 fail:
29165 return NULL;
29166 }
29167
29168
29169 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29170 PyObject *resultobj = 0;
29171 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29172 wxColour *result = 0 ;
29173 void *argp1 = 0 ;
29174 int res1 = 0 ;
29175 PyObject *swig_obj[1] ;
29176
29177 if (!args) SWIG_fail;
29178 swig_obj[0] = args;
29179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29180 if (!SWIG_IsOK(res1)) {
29181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29182 }
29183 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29184 result = (wxColour *)& ((arg1)->colFg);
29185 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29186 return resultobj;
29187 fail:
29188 return NULL;
29189 }
29190
29191
29192 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29193 PyObject *resultobj = 0;
29194 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29195 wxColour *arg2 = (wxColour *) 0 ;
29196 void *argp1 = 0 ;
29197 int res1 = 0 ;
29198 void *argp2 = 0 ;
29199 int res2 = 0 ;
29200 PyObject *swig_obj[2] ;
29201
29202 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29203 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29204 if (!SWIG_IsOK(res1)) {
29205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29206 }
29207 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29208 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29209 if (!SWIG_IsOK(res2)) {
29210 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29211 }
29212 arg2 = reinterpret_cast< wxColour * >(argp2);
29213 if (arg1) (arg1)->colBg = *arg2;
29214
29215 resultobj = SWIG_Py_Void();
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 PyObject *resultobj = 0;
29224 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29225 wxColour *result = 0 ;
29226 void *argp1 = 0 ;
29227 int res1 = 0 ;
29228 PyObject *swig_obj[1] ;
29229
29230 if (!args) SWIG_fail;
29231 swig_obj[0] = args;
29232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29233 if (!SWIG_IsOK(res1)) {
29234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29235 }
29236 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29237 result = (wxColour *)& ((arg1)->colBg);
29238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29239 return resultobj;
29240 fail:
29241 return NULL;
29242 }
29243
29244
29245 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29246 PyObject *obj;
29247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29248 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29249 return SWIG_Py_Void();
29250 }
29251
29252 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29253 return SWIG_Python_InitShadowInstance(args);
29254 }
29255
29256 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29257 PyObject *resultobj = 0;
29258 wxWindow *arg1 = (wxWindow *) 0 ;
29259 int arg2 = (int) (int)-1 ;
29260 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29261 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29262 wxSize const &arg4_defvalue = wxDefaultSize ;
29263 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29264 long arg5 = (long) 0 ;
29265 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29266 wxString *arg6 = (wxString *) &arg6_defvalue ;
29267 wxWindow *result = 0 ;
29268 void *argp1 = 0 ;
29269 int res1 = 0 ;
29270 int val2 ;
29271 int ecode2 = 0 ;
29272 wxPoint temp3 ;
29273 wxSize temp4 ;
29274 long val5 ;
29275 int ecode5 = 0 ;
29276 bool temp6 = false ;
29277 PyObject * obj0 = 0 ;
29278 PyObject * obj1 = 0 ;
29279 PyObject * obj2 = 0 ;
29280 PyObject * obj3 = 0 ;
29281 PyObject * obj4 = 0 ;
29282 PyObject * obj5 = 0 ;
29283 char * kwnames[] = {
29284 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29285 };
29286
29287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29289 if (!SWIG_IsOK(res1)) {
29290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29291 }
29292 arg1 = reinterpret_cast< wxWindow * >(argp1);
29293 if (obj1) {
29294 ecode2 = SWIG_AsVal_int(obj1, &val2);
29295 if (!SWIG_IsOK(ecode2)) {
29296 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29297 }
29298 arg2 = static_cast< int >(val2);
29299 }
29300 if (obj2) {
29301 {
29302 arg3 = &temp3;
29303 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29304 }
29305 }
29306 if (obj3) {
29307 {
29308 arg4 = &temp4;
29309 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29310 }
29311 }
29312 if (obj4) {
29313 ecode5 = SWIG_AsVal_long(obj4, &val5);
29314 if (!SWIG_IsOK(ecode5)) {
29315 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29316 }
29317 arg5 = static_cast< long >(val5);
29318 }
29319 if (obj5) {
29320 {
29321 arg6 = wxString_in_helper(obj5);
29322 if (arg6 == NULL) SWIG_fail;
29323 temp6 = true;
29324 }
29325 }
29326 {
29327 if (!wxPyCheckForApp()) SWIG_fail;
29328 PyThreadState* __tstate = wxPyBeginAllowThreads();
29329 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29330 wxPyEndAllowThreads(__tstate);
29331 if (PyErr_Occurred()) SWIG_fail;
29332 }
29333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29334 {
29335 if (temp6)
29336 delete arg6;
29337 }
29338 return resultobj;
29339 fail:
29340 {
29341 if (temp6)
29342 delete arg6;
29343 }
29344 return NULL;
29345 }
29346
29347
29348 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29349 PyObject *resultobj = 0;
29350 wxWindow *result = 0 ;
29351
29352 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29353 {
29354 if (!wxPyCheckForApp()) SWIG_fail;
29355 PyThreadState* __tstate = wxPyBeginAllowThreads();
29356 result = (wxWindow *)new wxWindow();
29357 wxPyEndAllowThreads(__tstate);
29358 if (PyErr_Occurred()) SWIG_fail;
29359 }
29360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29361 return resultobj;
29362 fail:
29363 return NULL;
29364 }
29365
29366
29367 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29368 PyObject *resultobj = 0;
29369 wxWindow *arg1 = (wxWindow *) 0 ;
29370 wxWindow *arg2 = (wxWindow *) 0 ;
29371 int arg3 = (int) (int)-1 ;
29372 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29373 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29374 wxSize const &arg5_defvalue = wxDefaultSize ;
29375 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29376 long arg6 = (long) 0 ;
29377 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29378 wxString *arg7 = (wxString *) &arg7_defvalue ;
29379 bool result;
29380 void *argp1 = 0 ;
29381 int res1 = 0 ;
29382 void *argp2 = 0 ;
29383 int res2 = 0 ;
29384 int val3 ;
29385 int ecode3 = 0 ;
29386 wxPoint temp4 ;
29387 wxSize temp5 ;
29388 long val6 ;
29389 int ecode6 = 0 ;
29390 bool temp7 = false ;
29391 PyObject * obj0 = 0 ;
29392 PyObject * obj1 = 0 ;
29393 PyObject * obj2 = 0 ;
29394 PyObject * obj3 = 0 ;
29395 PyObject * obj4 = 0 ;
29396 PyObject * obj5 = 0 ;
29397 PyObject * obj6 = 0 ;
29398 char * kwnames[] = {
29399 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29400 };
29401
29402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29404 if (!SWIG_IsOK(res1)) {
29405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29406 }
29407 arg1 = reinterpret_cast< wxWindow * >(argp1);
29408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29409 if (!SWIG_IsOK(res2)) {
29410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29411 }
29412 arg2 = reinterpret_cast< wxWindow * >(argp2);
29413 if (obj2) {
29414 ecode3 = SWIG_AsVal_int(obj2, &val3);
29415 if (!SWIG_IsOK(ecode3)) {
29416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29417 }
29418 arg3 = static_cast< int >(val3);
29419 }
29420 if (obj3) {
29421 {
29422 arg4 = &temp4;
29423 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29424 }
29425 }
29426 if (obj4) {
29427 {
29428 arg5 = &temp5;
29429 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29430 }
29431 }
29432 if (obj5) {
29433 ecode6 = SWIG_AsVal_long(obj5, &val6);
29434 if (!SWIG_IsOK(ecode6)) {
29435 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29436 }
29437 arg6 = static_cast< long >(val6);
29438 }
29439 if (obj6) {
29440 {
29441 arg7 = wxString_in_helper(obj6);
29442 if (arg7 == NULL) SWIG_fail;
29443 temp7 = true;
29444 }
29445 }
29446 {
29447 PyThreadState* __tstate = wxPyBeginAllowThreads();
29448 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29449 wxPyEndAllowThreads(__tstate);
29450 if (PyErr_Occurred()) SWIG_fail;
29451 }
29452 {
29453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29454 }
29455 {
29456 if (temp7)
29457 delete arg7;
29458 }
29459 return resultobj;
29460 fail:
29461 {
29462 if (temp7)
29463 delete arg7;
29464 }
29465 return NULL;
29466 }
29467
29468
29469 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29470 PyObject *resultobj = 0;
29471 wxWindow *arg1 = (wxWindow *) 0 ;
29472 bool arg2 = (bool) false ;
29473 bool result;
29474 void *argp1 = 0 ;
29475 int res1 = 0 ;
29476 bool val2 ;
29477 int ecode2 = 0 ;
29478 PyObject * obj0 = 0 ;
29479 PyObject * obj1 = 0 ;
29480 char * kwnames[] = {
29481 (char *) "self",(char *) "force", NULL
29482 };
29483
29484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29486 if (!SWIG_IsOK(res1)) {
29487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29488 }
29489 arg1 = reinterpret_cast< wxWindow * >(argp1);
29490 if (obj1) {
29491 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29492 if (!SWIG_IsOK(ecode2)) {
29493 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29494 }
29495 arg2 = static_cast< bool >(val2);
29496 }
29497 {
29498 PyThreadState* __tstate = wxPyBeginAllowThreads();
29499 result = (bool)(arg1)->Close(arg2);
29500 wxPyEndAllowThreads(__tstate);
29501 if (PyErr_Occurred()) SWIG_fail;
29502 }
29503 {
29504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29505 }
29506 return resultobj;
29507 fail:
29508 return NULL;
29509 }
29510
29511
29512 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29513 PyObject *resultobj = 0;
29514 wxWindow *arg1 = (wxWindow *) 0 ;
29515 bool result;
29516 void *argp1 = 0 ;
29517 int res1 = 0 ;
29518 PyObject *swig_obj[1] ;
29519
29520 if (!args) SWIG_fail;
29521 swig_obj[0] = args;
29522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29523 if (!SWIG_IsOK(res1)) {
29524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29525 }
29526 arg1 = reinterpret_cast< wxWindow * >(argp1);
29527 {
29528 PyThreadState* __tstate = wxPyBeginAllowThreads();
29529 result = (bool)(arg1)->Destroy();
29530 wxPyEndAllowThreads(__tstate);
29531 if (PyErr_Occurred()) SWIG_fail;
29532 }
29533 {
29534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29535 }
29536 return resultobj;
29537 fail:
29538 return NULL;
29539 }
29540
29541
29542 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29543 PyObject *resultobj = 0;
29544 wxWindow *arg1 = (wxWindow *) 0 ;
29545 bool result;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 PyObject *swig_obj[1] ;
29549
29550 if (!args) SWIG_fail;
29551 swig_obj[0] = args;
29552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29553 if (!SWIG_IsOK(res1)) {
29554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29555 }
29556 arg1 = reinterpret_cast< wxWindow * >(argp1);
29557 {
29558 PyThreadState* __tstate = wxPyBeginAllowThreads();
29559 result = (bool)(arg1)->DestroyChildren();
29560 wxPyEndAllowThreads(__tstate);
29561 if (PyErr_Occurred()) SWIG_fail;
29562 }
29563 {
29564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29565 }
29566 return resultobj;
29567 fail:
29568 return NULL;
29569 }
29570
29571
29572 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29573 PyObject *resultobj = 0;
29574 wxWindow *arg1 = (wxWindow *) 0 ;
29575 bool result;
29576 void *argp1 = 0 ;
29577 int res1 = 0 ;
29578 PyObject *swig_obj[1] ;
29579
29580 if (!args) SWIG_fail;
29581 swig_obj[0] = args;
29582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29583 if (!SWIG_IsOK(res1)) {
29584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29585 }
29586 arg1 = reinterpret_cast< wxWindow * >(argp1);
29587 {
29588 PyThreadState* __tstate = wxPyBeginAllowThreads();
29589 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29590 wxPyEndAllowThreads(__tstate);
29591 if (PyErr_Occurred()) SWIG_fail;
29592 }
29593 {
29594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29595 }
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29603 PyObject *resultobj = 0;
29604 wxWindow *arg1 = (wxWindow *) 0 ;
29605 wxString *arg2 = 0 ;
29606 void *argp1 = 0 ;
29607 int res1 = 0 ;
29608 bool temp2 = false ;
29609 PyObject * obj0 = 0 ;
29610 PyObject * obj1 = 0 ;
29611 char * kwnames[] = {
29612 (char *) "self",(char *) "label", NULL
29613 };
29614
29615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29617 if (!SWIG_IsOK(res1)) {
29618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29619 }
29620 arg1 = reinterpret_cast< wxWindow * >(argp1);
29621 {
29622 arg2 = wxString_in_helper(obj1);
29623 if (arg2 == NULL) SWIG_fail;
29624 temp2 = true;
29625 }
29626 {
29627 PyThreadState* __tstate = wxPyBeginAllowThreads();
29628 (arg1)->SetLabel((wxString const &)*arg2);
29629 wxPyEndAllowThreads(__tstate);
29630 if (PyErr_Occurred()) SWIG_fail;
29631 }
29632 resultobj = SWIG_Py_Void();
29633 {
29634 if (temp2)
29635 delete arg2;
29636 }
29637 return resultobj;
29638 fail:
29639 {
29640 if (temp2)
29641 delete arg2;
29642 }
29643 return NULL;
29644 }
29645
29646
29647 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29648 PyObject *resultobj = 0;
29649 wxWindow *arg1 = (wxWindow *) 0 ;
29650 wxString result;
29651 void *argp1 = 0 ;
29652 int res1 = 0 ;
29653 PyObject *swig_obj[1] ;
29654
29655 if (!args) SWIG_fail;
29656 swig_obj[0] = args;
29657 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29658 if (!SWIG_IsOK(res1)) {
29659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29660 }
29661 arg1 = reinterpret_cast< wxWindow * >(argp1);
29662 {
29663 PyThreadState* __tstate = wxPyBeginAllowThreads();
29664 result = ((wxWindow const *)arg1)->GetLabel();
29665 wxPyEndAllowThreads(__tstate);
29666 if (PyErr_Occurred()) SWIG_fail;
29667 }
29668 {
29669 #if wxUSE_UNICODE
29670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29671 #else
29672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29673 #endif
29674 }
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj = 0;
29683 wxWindow *arg1 = (wxWindow *) 0 ;
29684 wxString *arg2 = 0 ;
29685 void *argp1 = 0 ;
29686 int res1 = 0 ;
29687 bool temp2 = false ;
29688 PyObject * obj0 = 0 ;
29689 PyObject * obj1 = 0 ;
29690 char * kwnames[] = {
29691 (char *) "self",(char *) "name", NULL
29692 };
29693
29694 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29695 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29696 if (!SWIG_IsOK(res1)) {
29697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29698 }
29699 arg1 = reinterpret_cast< wxWindow * >(argp1);
29700 {
29701 arg2 = wxString_in_helper(obj1);
29702 if (arg2 == NULL) SWIG_fail;
29703 temp2 = true;
29704 }
29705 {
29706 PyThreadState* __tstate = wxPyBeginAllowThreads();
29707 (arg1)->SetName((wxString const &)*arg2);
29708 wxPyEndAllowThreads(__tstate);
29709 if (PyErr_Occurred()) SWIG_fail;
29710 }
29711 resultobj = SWIG_Py_Void();
29712 {
29713 if (temp2)
29714 delete arg2;
29715 }
29716 return resultobj;
29717 fail:
29718 {
29719 if (temp2)
29720 delete arg2;
29721 }
29722 return NULL;
29723 }
29724
29725
29726 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29727 PyObject *resultobj = 0;
29728 wxWindow *arg1 = (wxWindow *) 0 ;
29729 wxString result;
29730 void *argp1 = 0 ;
29731 int res1 = 0 ;
29732 PyObject *swig_obj[1] ;
29733
29734 if (!args) SWIG_fail;
29735 swig_obj[0] = args;
29736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29737 if (!SWIG_IsOK(res1)) {
29738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29739 }
29740 arg1 = reinterpret_cast< wxWindow * >(argp1);
29741 {
29742 PyThreadState* __tstate = wxPyBeginAllowThreads();
29743 result = ((wxWindow const *)arg1)->GetName();
29744 wxPyEndAllowThreads(__tstate);
29745 if (PyErr_Occurred()) SWIG_fail;
29746 }
29747 {
29748 #if wxUSE_UNICODE
29749 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29750 #else
29751 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29752 #endif
29753 }
29754 return resultobj;
29755 fail:
29756 return NULL;
29757 }
29758
29759
29760 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29761 PyObject *resultobj = 0;
29762 wxWindow *arg1 = (wxWindow *) 0 ;
29763 wxWindowVariant arg2 ;
29764 void *argp1 = 0 ;
29765 int res1 = 0 ;
29766 int val2 ;
29767 int ecode2 = 0 ;
29768 PyObject * obj0 = 0 ;
29769 PyObject * obj1 = 0 ;
29770 char * kwnames[] = {
29771 (char *) "self",(char *) "variant", NULL
29772 };
29773
29774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29776 if (!SWIG_IsOK(res1)) {
29777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29778 }
29779 arg1 = reinterpret_cast< wxWindow * >(argp1);
29780 ecode2 = SWIG_AsVal_int(obj1, &val2);
29781 if (!SWIG_IsOK(ecode2)) {
29782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29783 }
29784 arg2 = static_cast< wxWindowVariant >(val2);
29785 {
29786 PyThreadState* __tstate = wxPyBeginAllowThreads();
29787 (arg1)->SetWindowVariant(arg2);
29788 wxPyEndAllowThreads(__tstate);
29789 if (PyErr_Occurred()) SWIG_fail;
29790 }
29791 resultobj = SWIG_Py_Void();
29792 return resultobj;
29793 fail:
29794 return NULL;
29795 }
29796
29797
29798 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29799 PyObject *resultobj = 0;
29800 wxWindow *arg1 = (wxWindow *) 0 ;
29801 wxWindowVariant result;
29802 void *argp1 = 0 ;
29803 int res1 = 0 ;
29804 PyObject *swig_obj[1] ;
29805
29806 if (!args) SWIG_fail;
29807 swig_obj[0] = args;
29808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29809 if (!SWIG_IsOK(res1)) {
29810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29811 }
29812 arg1 = reinterpret_cast< wxWindow * >(argp1);
29813 {
29814 PyThreadState* __tstate = wxPyBeginAllowThreads();
29815 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29816 wxPyEndAllowThreads(__tstate);
29817 if (PyErr_Occurred()) SWIG_fail;
29818 }
29819 resultobj = SWIG_From_int(static_cast< int >(result));
29820 return resultobj;
29821 fail:
29822 return NULL;
29823 }
29824
29825
29826 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = 0;
29828 wxWindow *arg1 = (wxWindow *) 0 ;
29829 int arg2 ;
29830 void *argp1 = 0 ;
29831 int res1 = 0 ;
29832 int val2 ;
29833 int ecode2 = 0 ;
29834 PyObject * obj0 = 0 ;
29835 PyObject * obj1 = 0 ;
29836 char * kwnames[] = {
29837 (char *) "self",(char *) "winid", NULL
29838 };
29839
29840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
29841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29842 if (!SWIG_IsOK(res1)) {
29843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
29844 }
29845 arg1 = reinterpret_cast< wxWindow * >(argp1);
29846 ecode2 = SWIG_AsVal_int(obj1, &val2);
29847 if (!SWIG_IsOK(ecode2)) {
29848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
29849 }
29850 arg2 = static_cast< int >(val2);
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 (arg1)->SetId(arg2);
29854 wxPyEndAllowThreads(__tstate);
29855 if (PyErr_Occurred()) SWIG_fail;
29856 }
29857 resultobj = SWIG_Py_Void();
29858 return resultobj;
29859 fail:
29860 return NULL;
29861 }
29862
29863
29864 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29865 PyObject *resultobj = 0;
29866 wxWindow *arg1 = (wxWindow *) 0 ;
29867 int result;
29868 void *argp1 = 0 ;
29869 int res1 = 0 ;
29870 PyObject *swig_obj[1] ;
29871
29872 if (!args) SWIG_fail;
29873 swig_obj[0] = args;
29874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29875 if (!SWIG_IsOK(res1)) {
29876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
29877 }
29878 arg1 = reinterpret_cast< wxWindow * >(argp1);
29879 {
29880 PyThreadState* __tstate = wxPyBeginAllowThreads();
29881 result = (int)((wxWindow const *)arg1)->GetId();
29882 wxPyEndAllowThreads(__tstate);
29883 if (PyErr_Occurred()) SWIG_fail;
29884 }
29885 resultobj = SWIG_From_int(static_cast< int >(result));
29886 return resultobj;
29887 fail:
29888 return NULL;
29889 }
29890
29891
29892 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 PyObject *resultobj = 0;
29894 int result;
29895
29896 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 result = (int)wxWindow::NewControlId();
29900 wxPyEndAllowThreads(__tstate);
29901 if (PyErr_Occurred()) SWIG_fail;
29902 }
29903 resultobj = SWIG_From_int(static_cast< int >(result));
29904 return resultobj;
29905 fail:
29906 return NULL;
29907 }
29908
29909
29910 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29911 PyObject *resultobj = 0;
29912 int arg1 ;
29913 int result;
29914 int val1 ;
29915 int ecode1 = 0 ;
29916 PyObject * obj0 = 0 ;
29917 char * kwnames[] = {
29918 (char *) "winid", NULL
29919 };
29920
29921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
29922 ecode1 = SWIG_AsVal_int(obj0, &val1);
29923 if (!SWIG_IsOK(ecode1)) {
29924 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
29925 }
29926 arg1 = static_cast< int >(val1);
29927 {
29928 PyThreadState* __tstate = wxPyBeginAllowThreads();
29929 result = (int)wxWindow::NextControlId(arg1);
29930 wxPyEndAllowThreads(__tstate);
29931 if (PyErr_Occurred()) SWIG_fail;
29932 }
29933 resultobj = SWIG_From_int(static_cast< int >(result));
29934 return resultobj;
29935 fail:
29936 return NULL;
29937 }
29938
29939
29940 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29941 PyObject *resultobj = 0;
29942 int arg1 ;
29943 int result;
29944 int val1 ;
29945 int ecode1 = 0 ;
29946 PyObject * obj0 = 0 ;
29947 char * kwnames[] = {
29948 (char *) "winid", NULL
29949 };
29950
29951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
29952 ecode1 = SWIG_AsVal_int(obj0, &val1);
29953 if (!SWIG_IsOK(ecode1)) {
29954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
29955 }
29956 arg1 = static_cast< int >(val1);
29957 {
29958 PyThreadState* __tstate = wxPyBeginAllowThreads();
29959 result = (int)wxWindow::PrevControlId(arg1);
29960 wxPyEndAllowThreads(__tstate);
29961 if (PyErr_Occurred()) SWIG_fail;
29962 }
29963 resultobj = SWIG_From_int(static_cast< int >(result));
29964 return resultobj;
29965 fail:
29966 return NULL;
29967 }
29968
29969
29970 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29971 PyObject *resultobj = 0;
29972 wxWindow *arg1 = (wxWindow *) 0 ;
29973 wxSize *arg2 = 0 ;
29974 void *argp1 = 0 ;
29975 int res1 = 0 ;
29976 wxSize temp2 ;
29977 PyObject * obj0 = 0 ;
29978 PyObject * obj1 = 0 ;
29979 char * kwnames[] = {
29980 (char *) "self",(char *) "size", NULL
29981 };
29982
29983 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
29984 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29985 if (!SWIG_IsOK(res1)) {
29986 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
29987 }
29988 arg1 = reinterpret_cast< wxWindow * >(argp1);
29989 {
29990 arg2 = &temp2;
29991 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29992 }
29993 {
29994 PyThreadState* __tstate = wxPyBeginAllowThreads();
29995 (arg1)->SetSize((wxSize const &)*arg2);
29996 wxPyEndAllowThreads(__tstate);
29997 if (PyErr_Occurred()) SWIG_fail;
29998 }
29999 resultobj = SWIG_Py_Void();
30000 return resultobj;
30001 fail:
30002 return NULL;
30003 }
30004
30005
30006 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30007 PyObject *resultobj = 0;
30008 wxWindow *arg1 = (wxWindow *) 0 ;
30009 int arg2 ;
30010 int arg3 ;
30011 int arg4 ;
30012 int arg5 ;
30013 int arg6 = (int) wxSIZE_AUTO ;
30014 void *argp1 = 0 ;
30015 int res1 = 0 ;
30016 int val2 ;
30017 int ecode2 = 0 ;
30018 int val3 ;
30019 int ecode3 = 0 ;
30020 int val4 ;
30021 int ecode4 = 0 ;
30022 int val5 ;
30023 int ecode5 = 0 ;
30024 int val6 ;
30025 int ecode6 = 0 ;
30026 PyObject * obj0 = 0 ;
30027 PyObject * obj1 = 0 ;
30028 PyObject * obj2 = 0 ;
30029 PyObject * obj3 = 0 ;
30030 PyObject * obj4 = 0 ;
30031 PyObject * obj5 = 0 ;
30032 char * kwnames[] = {
30033 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30034 };
30035
30036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30038 if (!SWIG_IsOK(res1)) {
30039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30040 }
30041 arg1 = reinterpret_cast< wxWindow * >(argp1);
30042 ecode2 = SWIG_AsVal_int(obj1, &val2);
30043 if (!SWIG_IsOK(ecode2)) {
30044 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30045 }
30046 arg2 = static_cast< int >(val2);
30047 ecode3 = SWIG_AsVal_int(obj2, &val3);
30048 if (!SWIG_IsOK(ecode3)) {
30049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30050 }
30051 arg3 = static_cast< int >(val3);
30052 ecode4 = SWIG_AsVal_int(obj3, &val4);
30053 if (!SWIG_IsOK(ecode4)) {
30054 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30055 }
30056 arg4 = static_cast< int >(val4);
30057 ecode5 = SWIG_AsVal_int(obj4, &val5);
30058 if (!SWIG_IsOK(ecode5)) {
30059 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30060 }
30061 arg5 = static_cast< int >(val5);
30062 if (obj5) {
30063 ecode6 = SWIG_AsVal_int(obj5, &val6);
30064 if (!SWIG_IsOK(ecode6)) {
30065 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30066 }
30067 arg6 = static_cast< int >(val6);
30068 }
30069 {
30070 PyThreadState* __tstate = wxPyBeginAllowThreads();
30071 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 resultobj = SWIG_Py_Void();
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj = 0;
30084 wxWindow *arg1 = (wxWindow *) 0 ;
30085 wxRect *arg2 = 0 ;
30086 int arg3 = (int) wxSIZE_AUTO ;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 wxRect temp2 ;
30090 int val3 ;
30091 int ecode3 = 0 ;
30092 PyObject * obj0 = 0 ;
30093 PyObject * obj1 = 0 ;
30094 PyObject * obj2 = 0 ;
30095 char * kwnames[] = {
30096 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30097 };
30098
30099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30101 if (!SWIG_IsOK(res1)) {
30102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30103 }
30104 arg1 = reinterpret_cast< wxWindow * >(argp1);
30105 {
30106 arg2 = &temp2;
30107 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30108 }
30109 if (obj2) {
30110 ecode3 = SWIG_AsVal_int(obj2, &val3);
30111 if (!SWIG_IsOK(ecode3)) {
30112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30113 }
30114 arg3 = static_cast< int >(val3);
30115 }
30116 {
30117 PyThreadState* __tstate = wxPyBeginAllowThreads();
30118 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30119 wxPyEndAllowThreads(__tstate);
30120 if (PyErr_Occurred()) SWIG_fail;
30121 }
30122 resultobj = SWIG_Py_Void();
30123 return resultobj;
30124 fail:
30125 return NULL;
30126 }
30127
30128
30129 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30130 PyObject *resultobj = 0;
30131 wxWindow *arg1 = (wxWindow *) 0 ;
30132 int arg2 ;
30133 int arg3 ;
30134 void *argp1 = 0 ;
30135 int res1 = 0 ;
30136 int val2 ;
30137 int ecode2 = 0 ;
30138 int val3 ;
30139 int ecode3 = 0 ;
30140 PyObject * obj0 = 0 ;
30141 PyObject * obj1 = 0 ;
30142 PyObject * obj2 = 0 ;
30143 char * kwnames[] = {
30144 (char *) "self",(char *) "width",(char *) "height", NULL
30145 };
30146
30147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30149 if (!SWIG_IsOK(res1)) {
30150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30151 }
30152 arg1 = reinterpret_cast< wxWindow * >(argp1);
30153 ecode2 = SWIG_AsVal_int(obj1, &val2);
30154 if (!SWIG_IsOK(ecode2)) {
30155 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30156 }
30157 arg2 = static_cast< int >(val2);
30158 ecode3 = SWIG_AsVal_int(obj2, &val3);
30159 if (!SWIG_IsOK(ecode3)) {
30160 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30161 }
30162 arg3 = static_cast< int >(val3);
30163 {
30164 PyThreadState* __tstate = wxPyBeginAllowThreads();
30165 (arg1)->SetSize(arg2,arg3);
30166 wxPyEndAllowThreads(__tstate);
30167 if (PyErr_Occurred()) SWIG_fail;
30168 }
30169 resultobj = SWIG_Py_Void();
30170 return resultobj;
30171 fail:
30172 return NULL;
30173 }
30174
30175
30176 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30177 PyObject *resultobj = 0;
30178 wxWindow *arg1 = (wxWindow *) 0 ;
30179 wxPoint *arg2 = 0 ;
30180 int arg3 = (int) wxSIZE_USE_EXISTING ;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 wxPoint temp2 ;
30184 int val3 ;
30185 int ecode3 = 0 ;
30186 PyObject * obj0 = 0 ;
30187 PyObject * obj1 = 0 ;
30188 PyObject * obj2 = 0 ;
30189 char * kwnames[] = {
30190 (char *) "self",(char *) "pt",(char *) "flags", NULL
30191 };
30192
30193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30195 if (!SWIG_IsOK(res1)) {
30196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30197 }
30198 arg1 = reinterpret_cast< wxWindow * >(argp1);
30199 {
30200 arg2 = &temp2;
30201 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30202 }
30203 if (obj2) {
30204 ecode3 = SWIG_AsVal_int(obj2, &val3);
30205 if (!SWIG_IsOK(ecode3)) {
30206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30207 }
30208 arg3 = static_cast< int >(val3);
30209 }
30210 {
30211 PyThreadState* __tstate = wxPyBeginAllowThreads();
30212 (arg1)->Move((wxPoint const &)*arg2,arg3);
30213 wxPyEndAllowThreads(__tstate);
30214 if (PyErr_Occurred()) SWIG_fail;
30215 }
30216 resultobj = SWIG_Py_Void();
30217 return resultobj;
30218 fail:
30219 return NULL;
30220 }
30221
30222
30223 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30224 PyObject *resultobj = 0;
30225 wxWindow *arg1 = (wxWindow *) 0 ;
30226 int arg2 ;
30227 int arg3 ;
30228 int arg4 = (int) wxSIZE_USE_EXISTING ;
30229 void *argp1 = 0 ;
30230 int res1 = 0 ;
30231 int val2 ;
30232 int ecode2 = 0 ;
30233 int val3 ;
30234 int ecode3 = 0 ;
30235 int val4 ;
30236 int ecode4 = 0 ;
30237 PyObject * obj0 = 0 ;
30238 PyObject * obj1 = 0 ;
30239 PyObject * obj2 = 0 ;
30240 PyObject * obj3 = 0 ;
30241 char * kwnames[] = {
30242 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30243 };
30244
30245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30247 if (!SWIG_IsOK(res1)) {
30248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30249 }
30250 arg1 = reinterpret_cast< wxWindow * >(argp1);
30251 ecode2 = SWIG_AsVal_int(obj1, &val2);
30252 if (!SWIG_IsOK(ecode2)) {
30253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30254 }
30255 arg2 = static_cast< int >(val2);
30256 ecode3 = SWIG_AsVal_int(obj2, &val3);
30257 if (!SWIG_IsOK(ecode3)) {
30258 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30259 }
30260 arg3 = static_cast< int >(val3);
30261 if (obj3) {
30262 ecode4 = SWIG_AsVal_int(obj3, &val4);
30263 if (!SWIG_IsOK(ecode4)) {
30264 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30265 }
30266 arg4 = static_cast< int >(val4);
30267 }
30268 {
30269 PyThreadState* __tstate = wxPyBeginAllowThreads();
30270 (arg1)->Move(arg2,arg3,arg4);
30271 wxPyEndAllowThreads(__tstate);
30272 if (PyErr_Occurred()) SWIG_fail;
30273 }
30274 resultobj = SWIG_Py_Void();
30275 return resultobj;
30276 fail:
30277 return NULL;
30278 }
30279
30280
30281 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30282 PyObject *resultobj = 0;
30283 wxWindow *arg1 = (wxWindow *) 0 ;
30284 wxSize const &arg2_defvalue = wxDefaultSize ;
30285 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30286 void *argp1 = 0 ;
30287 int res1 = 0 ;
30288 wxSize temp2 ;
30289 PyObject * obj0 = 0 ;
30290 PyObject * obj1 = 0 ;
30291 char * kwnames[] = {
30292 (char *) "self",(char *) "size", NULL
30293 };
30294
30295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30297 if (!SWIG_IsOK(res1)) {
30298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30299 }
30300 arg1 = reinterpret_cast< wxWindow * >(argp1);
30301 if (obj1) {
30302 {
30303 arg2 = &temp2;
30304 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30305 }
30306 }
30307 {
30308 PyThreadState* __tstate = wxPyBeginAllowThreads();
30309 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30310 wxPyEndAllowThreads(__tstate);
30311 if (PyErr_Occurred()) SWIG_fail;
30312 }
30313 resultobj = SWIG_Py_Void();
30314 return resultobj;
30315 fail:
30316 return NULL;
30317 }
30318
30319
30320 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30321 PyObject *resultobj = 0;
30322 wxWindow *arg1 = (wxWindow *) 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_wxWindow, 0 | 0 );
30330 if (!SWIG_IsOK(res1)) {
30331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30332 }
30333 arg1 = reinterpret_cast< wxWindow * >(argp1);
30334 {
30335 PyThreadState* __tstate = wxPyBeginAllowThreads();
30336 (arg1)->Raise();
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_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30348 PyObject *resultobj = 0;
30349 wxWindow *arg1 = (wxWindow *) 0 ;
30350 void *argp1 = 0 ;
30351 int res1 = 0 ;
30352 PyObject *swig_obj[1] ;
30353
30354 if (!args) SWIG_fail;
30355 swig_obj[0] = args;
30356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30357 if (!SWIG_IsOK(res1)) {
30358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30359 }
30360 arg1 = reinterpret_cast< wxWindow * >(argp1);
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 (arg1)->Lower();
30364 wxPyEndAllowThreads(__tstate);
30365 if (PyErr_Occurred()) SWIG_fail;
30366 }
30367 resultobj = SWIG_Py_Void();
30368 return resultobj;
30369 fail:
30370 return NULL;
30371 }
30372
30373
30374 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30375 PyObject *resultobj = 0;
30376 wxWindow *arg1 = (wxWindow *) 0 ;
30377 wxSize *arg2 = 0 ;
30378 void *argp1 = 0 ;
30379 int res1 = 0 ;
30380 wxSize temp2 ;
30381 PyObject * obj0 = 0 ;
30382 PyObject * obj1 = 0 ;
30383 char * kwnames[] = {
30384 (char *) "self",(char *) "size", NULL
30385 };
30386
30387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30389 if (!SWIG_IsOK(res1)) {
30390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30391 }
30392 arg1 = reinterpret_cast< wxWindow * >(argp1);
30393 {
30394 arg2 = &temp2;
30395 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30396 }
30397 {
30398 PyThreadState* __tstate = wxPyBeginAllowThreads();
30399 (arg1)->SetClientSize((wxSize const &)*arg2);
30400 wxPyEndAllowThreads(__tstate);
30401 if (PyErr_Occurred()) SWIG_fail;
30402 }
30403 resultobj = SWIG_Py_Void();
30404 return resultobj;
30405 fail:
30406 return NULL;
30407 }
30408
30409
30410 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30411 PyObject *resultobj = 0;
30412 wxWindow *arg1 = (wxWindow *) 0 ;
30413 int arg2 ;
30414 int arg3 ;
30415 void *argp1 = 0 ;
30416 int res1 = 0 ;
30417 int val2 ;
30418 int ecode2 = 0 ;
30419 int val3 ;
30420 int ecode3 = 0 ;
30421 PyObject * obj0 = 0 ;
30422 PyObject * obj1 = 0 ;
30423 PyObject * obj2 = 0 ;
30424 char * kwnames[] = {
30425 (char *) "self",(char *) "width",(char *) "height", NULL
30426 };
30427
30428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30430 if (!SWIG_IsOK(res1)) {
30431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30432 }
30433 arg1 = reinterpret_cast< wxWindow * >(argp1);
30434 ecode2 = SWIG_AsVal_int(obj1, &val2);
30435 if (!SWIG_IsOK(ecode2)) {
30436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30437 }
30438 arg2 = static_cast< int >(val2);
30439 ecode3 = SWIG_AsVal_int(obj2, &val3);
30440 if (!SWIG_IsOK(ecode3)) {
30441 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30442 }
30443 arg3 = static_cast< int >(val3);
30444 {
30445 PyThreadState* __tstate = wxPyBeginAllowThreads();
30446 (arg1)->SetClientSize(arg2,arg3);
30447 wxPyEndAllowThreads(__tstate);
30448 if (PyErr_Occurred()) SWIG_fail;
30449 }
30450 resultobj = SWIG_Py_Void();
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj = 0;
30459 wxWindow *arg1 = (wxWindow *) 0 ;
30460 wxRect *arg2 = 0 ;
30461 void *argp1 = 0 ;
30462 int res1 = 0 ;
30463 wxRect temp2 ;
30464 PyObject * obj0 = 0 ;
30465 PyObject * obj1 = 0 ;
30466 char * kwnames[] = {
30467 (char *) "self",(char *) "rect", NULL
30468 };
30469
30470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30472 if (!SWIG_IsOK(res1)) {
30473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30474 }
30475 arg1 = reinterpret_cast< wxWindow * >(argp1);
30476 {
30477 arg2 = &temp2;
30478 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30479 }
30480 {
30481 PyThreadState* __tstate = wxPyBeginAllowThreads();
30482 (arg1)->SetClientSize((wxRect const &)*arg2);
30483 wxPyEndAllowThreads(__tstate);
30484 if (PyErr_Occurred()) SWIG_fail;
30485 }
30486 resultobj = SWIG_Py_Void();
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30494 PyObject *resultobj = 0;
30495 wxWindow *arg1 = (wxWindow *) 0 ;
30496 wxPoint result;
30497 void *argp1 = 0 ;
30498 int res1 = 0 ;
30499 PyObject *swig_obj[1] ;
30500
30501 if (!args) SWIG_fail;
30502 swig_obj[0] = args;
30503 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30504 if (!SWIG_IsOK(res1)) {
30505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30506 }
30507 arg1 = reinterpret_cast< wxWindow * >(argp1);
30508 {
30509 PyThreadState* __tstate = wxPyBeginAllowThreads();
30510 result = ((wxWindow const *)arg1)->GetPosition();
30511 wxPyEndAllowThreads(__tstate);
30512 if (PyErr_Occurred()) SWIG_fail;
30513 }
30514 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30515 return resultobj;
30516 fail:
30517 return NULL;
30518 }
30519
30520
30521 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30522 PyObject *resultobj = 0;
30523 wxWindow *arg1 = (wxWindow *) 0 ;
30524 int *arg2 = (int *) 0 ;
30525 int *arg3 = (int *) 0 ;
30526 void *argp1 = 0 ;
30527 int res1 = 0 ;
30528 int temp2 ;
30529 int res2 = SWIG_TMPOBJ ;
30530 int temp3 ;
30531 int res3 = SWIG_TMPOBJ ;
30532 PyObject *swig_obj[1] ;
30533
30534 arg2 = &temp2;
30535 arg3 = &temp3;
30536 if (!args) SWIG_fail;
30537 swig_obj[0] = args;
30538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30541 }
30542 arg1 = reinterpret_cast< wxWindow * >(argp1);
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_Py_Void();
30550 if (SWIG_IsTmpObj(res2)) {
30551 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30552 } else {
30553 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30554 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30555 }
30556 if (SWIG_IsTmpObj(res3)) {
30557 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30558 } else {
30559 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30560 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30561 }
30562 return resultobj;
30563 fail:
30564 return NULL;
30565 }
30566
30567
30568 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30569 PyObject *resultobj = 0;
30570 wxWindow *arg1 = (wxWindow *) 0 ;
30571 wxPoint result;
30572 void *argp1 = 0 ;
30573 int res1 = 0 ;
30574 PyObject *swig_obj[1] ;
30575
30576 if (!args) SWIG_fail;
30577 swig_obj[0] = args;
30578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30581 }
30582 arg1 = reinterpret_cast< wxWindow * >(argp1);
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 result = ((wxWindow const *)arg1)->GetScreenPosition();
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30597 PyObject *resultobj = 0;
30598 wxWindow *arg1 = (wxWindow *) 0 ;
30599 int *arg2 = (int *) 0 ;
30600 int *arg3 = (int *) 0 ;
30601 void *argp1 = 0 ;
30602 int res1 = 0 ;
30603 int temp2 ;
30604 int res2 = SWIG_TMPOBJ ;
30605 int temp3 ;
30606 int res3 = SWIG_TMPOBJ ;
30607 PyObject *swig_obj[1] ;
30608
30609 arg2 = &temp2;
30610 arg3 = &temp3;
30611 if (!args) SWIG_fail;
30612 swig_obj[0] = args;
30613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30614 if (!SWIG_IsOK(res1)) {
30615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30616 }
30617 arg1 = reinterpret_cast< wxWindow * >(argp1);
30618 {
30619 PyThreadState* __tstate = wxPyBeginAllowThreads();
30620 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30621 wxPyEndAllowThreads(__tstate);
30622 if (PyErr_Occurred()) SWIG_fail;
30623 }
30624 resultobj = SWIG_Py_Void();
30625 if (SWIG_IsTmpObj(res2)) {
30626 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30627 } else {
30628 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30630 }
30631 if (SWIG_IsTmpObj(res3)) {
30632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30633 } else {
30634 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30636 }
30637 return resultobj;
30638 fail:
30639 return NULL;
30640 }
30641
30642
30643 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30644 PyObject *resultobj = 0;
30645 wxWindow *arg1 = (wxWindow *) 0 ;
30646 wxRect result;
30647 void *argp1 = 0 ;
30648 int res1 = 0 ;
30649 PyObject *swig_obj[1] ;
30650
30651 if (!args) SWIG_fail;
30652 swig_obj[0] = args;
30653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30654 if (!SWIG_IsOK(res1)) {
30655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30656 }
30657 arg1 = reinterpret_cast< wxWindow * >(argp1);
30658 {
30659 PyThreadState* __tstate = wxPyBeginAllowThreads();
30660 result = ((wxWindow const *)arg1)->GetScreenRect();
30661 wxPyEndAllowThreads(__tstate);
30662 if (PyErr_Occurred()) SWIG_fail;
30663 }
30664 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30665 return resultobj;
30666 fail:
30667 return NULL;
30668 }
30669
30670
30671 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30672 PyObject *resultobj = 0;
30673 wxWindow *arg1 = (wxWindow *) 0 ;
30674 wxSize result;
30675 void *argp1 = 0 ;
30676 int res1 = 0 ;
30677 PyObject *swig_obj[1] ;
30678
30679 if (!args) SWIG_fail;
30680 swig_obj[0] = args;
30681 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30682 if (!SWIG_IsOK(res1)) {
30683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30684 }
30685 arg1 = reinterpret_cast< wxWindow * >(argp1);
30686 {
30687 PyThreadState* __tstate = wxPyBeginAllowThreads();
30688 result = ((wxWindow const *)arg1)->GetSize();
30689 wxPyEndAllowThreads(__tstate);
30690 if (PyErr_Occurred()) SWIG_fail;
30691 }
30692 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30693 return resultobj;
30694 fail:
30695 return NULL;
30696 }
30697
30698
30699 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30700 PyObject *resultobj = 0;
30701 wxWindow *arg1 = (wxWindow *) 0 ;
30702 int *arg2 = (int *) 0 ;
30703 int *arg3 = (int *) 0 ;
30704 void *argp1 = 0 ;
30705 int res1 = 0 ;
30706 int temp2 ;
30707 int res2 = SWIG_TMPOBJ ;
30708 int temp3 ;
30709 int res3 = SWIG_TMPOBJ ;
30710 PyObject *swig_obj[1] ;
30711
30712 arg2 = &temp2;
30713 arg3 = &temp3;
30714 if (!args) SWIG_fail;
30715 swig_obj[0] = args;
30716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30717 if (!SWIG_IsOK(res1)) {
30718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30719 }
30720 arg1 = reinterpret_cast< wxWindow * >(argp1);
30721 {
30722 PyThreadState* __tstate = wxPyBeginAllowThreads();
30723 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30724 wxPyEndAllowThreads(__tstate);
30725 if (PyErr_Occurred()) SWIG_fail;
30726 }
30727 resultobj = SWIG_Py_Void();
30728 if (SWIG_IsTmpObj(res2)) {
30729 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30730 } else {
30731 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30733 }
30734 if (SWIG_IsTmpObj(res3)) {
30735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30736 } else {
30737 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30739 }
30740 return resultobj;
30741 fail:
30742 return NULL;
30743 }
30744
30745
30746 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30747 PyObject *resultobj = 0;
30748 wxWindow *arg1 = (wxWindow *) 0 ;
30749 wxRect result;
30750 void *argp1 = 0 ;
30751 int res1 = 0 ;
30752 PyObject *swig_obj[1] ;
30753
30754 if (!args) SWIG_fail;
30755 swig_obj[0] = args;
30756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30757 if (!SWIG_IsOK(res1)) {
30758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30759 }
30760 arg1 = reinterpret_cast< wxWindow * >(argp1);
30761 {
30762 PyThreadState* __tstate = wxPyBeginAllowThreads();
30763 result = ((wxWindow const *)arg1)->GetRect();
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30768 return resultobj;
30769 fail:
30770 return NULL;
30771 }
30772
30773
30774 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30775 PyObject *resultobj = 0;
30776 wxWindow *arg1 = (wxWindow *) 0 ;
30777 wxSize result;
30778 void *argp1 = 0 ;
30779 int res1 = 0 ;
30780 PyObject *swig_obj[1] ;
30781
30782 if (!args) SWIG_fail;
30783 swig_obj[0] = args;
30784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30785 if (!SWIG_IsOK(res1)) {
30786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30787 }
30788 arg1 = reinterpret_cast< wxWindow * >(argp1);
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 result = ((wxWindow const *)arg1)->GetClientSize();
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30796 return resultobj;
30797 fail:
30798 return NULL;
30799 }
30800
30801
30802 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30803 PyObject *resultobj = 0;
30804 wxWindow *arg1 = (wxWindow *) 0 ;
30805 int *arg2 = (int *) 0 ;
30806 int *arg3 = (int *) 0 ;
30807 void *argp1 = 0 ;
30808 int res1 = 0 ;
30809 int temp2 ;
30810 int res2 = SWIG_TMPOBJ ;
30811 int temp3 ;
30812 int res3 = SWIG_TMPOBJ ;
30813 PyObject *swig_obj[1] ;
30814
30815 arg2 = &temp2;
30816 arg3 = &temp3;
30817 if (!args) SWIG_fail;
30818 swig_obj[0] = args;
30819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30820 if (!SWIG_IsOK(res1)) {
30821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30822 }
30823 arg1 = reinterpret_cast< wxWindow * >(argp1);
30824 {
30825 PyThreadState* __tstate = wxPyBeginAllowThreads();
30826 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 resultobj = SWIG_Py_Void();
30831 if (SWIG_IsTmpObj(res2)) {
30832 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30833 } else {
30834 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30835 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30836 }
30837 if (SWIG_IsTmpObj(res3)) {
30838 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30839 } else {
30840 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30841 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30842 }
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30850 PyObject *resultobj = 0;
30851 wxWindow *arg1 = (wxWindow *) 0 ;
30852 wxPoint result;
30853 void *argp1 = 0 ;
30854 int res1 = 0 ;
30855 PyObject *swig_obj[1] ;
30856
30857 if (!args) SWIG_fail;
30858 swig_obj[0] = args;
30859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30860 if (!SWIG_IsOK(res1)) {
30861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
30862 }
30863 arg1 = reinterpret_cast< wxWindow * >(argp1);
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30871 return resultobj;
30872 fail:
30873 return NULL;
30874 }
30875
30876
30877 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30878 PyObject *resultobj = 0;
30879 wxWindow *arg1 = (wxWindow *) 0 ;
30880 wxRect result;
30881 void *argp1 = 0 ;
30882 int res1 = 0 ;
30883 PyObject *swig_obj[1] ;
30884
30885 if (!args) SWIG_fail;
30886 swig_obj[0] = args;
30887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30888 if (!SWIG_IsOK(res1)) {
30889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30890 }
30891 arg1 = reinterpret_cast< wxWindow * >(argp1);
30892 {
30893 PyThreadState* __tstate = wxPyBeginAllowThreads();
30894 result = ((wxWindow const *)arg1)->GetClientRect();
30895 wxPyEndAllowThreads(__tstate);
30896 if (PyErr_Occurred()) SWIG_fail;
30897 }
30898 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30899 return resultobj;
30900 fail:
30901 return NULL;
30902 }
30903
30904
30905 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30906 PyObject *resultobj = 0;
30907 wxWindow *arg1 = (wxWindow *) 0 ;
30908 wxSize result;
30909 void *argp1 = 0 ;
30910 int res1 = 0 ;
30911 PyObject *swig_obj[1] ;
30912
30913 if (!args) SWIG_fail;
30914 swig_obj[0] = args;
30915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30916 if (!SWIG_IsOK(res1)) {
30917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30918 }
30919 arg1 = reinterpret_cast< wxWindow * >(argp1);
30920 {
30921 PyThreadState* __tstate = wxPyBeginAllowThreads();
30922 result = ((wxWindow const *)arg1)->GetBestSize();
30923 wxPyEndAllowThreads(__tstate);
30924 if (PyErr_Occurred()) SWIG_fail;
30925 }
30926 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30927 return resultobj;
30928 fail:
30929 return NULL;
30930 }
30931
30932
30933 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30934 PyObject *resultobj = 0;
30935 wxWindow *arg1 = (wxWindow *) 0 ;
30936 int *arg2 = (int *) 0 ;
30937 int *arg3 = (int *) 0 ;
30938 void *argp1 = 0 ;
30939 int res1 = 0 ;
30940 int temp2 ;
30941 int res2 = SWIG_TMPOBJ ;
30942 int temp3 ;
30943 int res3 = SWIG_TMPOBJ ;
30944 PyObject *swig_obj[1] ;
30945
30946 arg2 = &temp2;
30947 arg3 = &temp3;
30948 if (!args) SWIG_fail;
30949 swig_obj[0] = args;
30950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30951 if (!SWIG_IsOK(res1)) {
30952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30953 }
30954 arg1 = reinterpret_cast< wxWindow * >(argp1);
30955 {
30956 PyThreadState* __tstate = wxPyBeginAllowThreads();
30957 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
30958 wxPyEndAllowThreads(__tstate);
30959 if (PyErr_Occurred()) SWIG_fail;
30960 }
30961 resultobj = SWIG_Py_Void();
30962 if (SWIG_IsTmpObj(res2)) {
30963 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30964 } else {
30965 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30966 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30967 }
30968 if (SWIG_IsTmpObj(res3)) {
30969 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30970 } else {
30971 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30972 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30973 }
30974 return resultobj;
30975 fail:
30976 return NULL;
30977 }
30978
30979
30980 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30981 PyObject *resultobj = 0;
30982 wxWindow *arg1 = (wxWindow *) 0 ;
30983 void *argp1 = 0 ;
30984 int res1 = 0 ;
30985 PyObject *swig_obj[1] ;
30986
30987 if (!args) SWIG_fail;
30988 swig_obj[0] = args;
30989 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30990 if (!SWIG_IsOK(res1)) {
30991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30992 }
30993 arg1 = reinterpret_cast< wxWindow * >(argp1);
30994 {
30995 PyThreadState* __tstate = wxPyBeginAllowThreads();
30996 (arg1)->InvalidateBestSize();
30997 wxPyEndAllowThreads(__tstate);
30998 if (PyErr_Occurred()) SWIG_fail;
30999 }
31000 resultobj = SWIG_Py_Void();
31001 return resultobj;
31002 fail:
31003 return NULL;
31004 }
31005
31006
31007 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31008 PyObject *resultobj = 0;
31009 wxWindow *arg1 = (wxWindow *) 0 ;
31010 wxSize *arg2 = 0 ;
31011 void *argp1 = 0 ;
31012 int res1 = 0 ;
31013 wxSize temp2 ;
31014 PyObject * obj0 = 0 ;
31015 PyObject * obj1 = 0 ;
31016 char * kwnames[] = {
31017 (char *) "self",(char *) "size", NULL
31018 };
31019
31020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31022 if (!SWIG_IsOK(res1)) {
31023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31024 }
31025 arg1 = reinterpret_cast< wxWindow * >(argp1);
31026 {
31027 arg2 = &temp2;
31028 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31029 }
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31033 wxPyEndAllowThreads(__tstate);
31034 if (PyErr_Occurred()) SWIG_fail;
31035 }
31036 resultobj = SWIG_Py_Void();
31037 return resultobj;
31038 fail:
31039 return NULL;
31040 }
31041
31042
31043 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31044 PyObject *resultobj = 0;
31045 wxWindow *arg1 = (wxWindow *) 0 ;
31046 wxSize result;
31047 void *argp1 = 0 ;
31048 int res1 = 0 ;
31049 PyObject *swig_obj[1] ;
31050
31051 if (!args) SWIG_fail;
31052 swig_obj[0] = args;
31053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31054 if (!SWIG_IsOK(res1)) {
31055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31056 }
31057 arg1 = reinterpret_cast< wxWindow * >(argp1);
31058 {
31059 PyThreadState* __tstate = wxPyBeginAllowThreads();
31060 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31061 wxPyEndAllowThreads(__tstate);
31062 if (PyErr_Occurred()) SWIG_fail;
31063 }
31064 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31065 return resultobj;
31066 fail:
31067 return NULL;
31068 }
31069
31070
31071 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31072 PyObject *resultobj = 0;
31073 wxWindow *arg1 = (wxWindow *) 0 ;
31074 wxSize result;
31075 void *argp1 = 0 ;
31076 int res1 = 0 ;
31077 PyObject *swig_obj[1] ;
31078
31079 if (!args) SWIG_fail;
31080 swig_obj[0] = args;
31081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31082 if (!SWIG_IsOK(res1)) {
31083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31084 }
31085 arg1 = reinterpret_cast< wxWindow * >(argp1);
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31089 wxPyEndAllowThreads(__tstate);
31090 if (PyErr_Occurred()) SWIG_fail;
31091 }
31092 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31093 return resultobj;
31094 fail:
31095 return NULL;
31096 }
31097
31098
31099 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31100 PyObject *resultobj = 0;
31101 wxWindow *arg1 = (wxWindow *) 0 ;
31102 int arg2 = (int) wxBOTH ;
31103 void *argp1 = 0 ;
31104 int res1 = 0 ;
31105 int val2 ;
31106 int ecode2 = 0 ;
31107 PyObject * obj0 = 0 ;
31108 PyObject * obj1 = 0 ;
31109 char * kwnames[] = {
31110 (char *) "self",(char *) "direction", NULL
31111 };
31112
31113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31117 }
31118 arg1 = reinterpret_cast< wxWindow * >(argp1);
31119 if (obj1) {
31120 ecode2 = SWIG_AsVal_int(obj1, &val2);
31121 if (!SWIG_IsOK(ecode2)) {
31122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31123 }
31124 arg2 = static_cast< int >(val2);
31125 }
31126 {
31127 PyThreadState* __tstate = wxPyBeginAllowThreads();
31128 (arg1)->Center(arg2);
31129 wxPyEndAllowThreads(__tstate);
31130 if (PyErr_Occurred()) SWIG_fail;
31131 }
31132 resultobj = SWIG_Py_Void();
31133 return resultobj;
31134 fail:
31135 return NULL;
31136 }
31137
31138
31139 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31140 PyObject *resultobj = 0;
31141 wxWindow *arg1 = (wxWindow *) 0 ;
31142 int arg2 = (int) wxBOTH ;
31143 void *argp1 = 0 ;
31144 int res1 = 0 ;
31145 int val2 ;
31146 int ecode2 = 0 ;
31147 PyObject * obj0 = 0 ;
31148 PyObject * obj1 = 0 ;
31149 char * kwnames[] = {
31150 (char *) "self",(char *) "dir", NULL
31151 };
31152
31153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31155 if (!SWIG_IsOK(res1)) {
31156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31157 }
31158 arg1 = reinterpret_cast< wxWindow * >(argp1);
31159 if (obj1) {
31160 ecode2 = SWIG_AsVal_int(obj1, &val2);
31161 if (!SWIG_IsOK(ecode2)) {
31162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31163 }
31164 arg2 = static_cast< int >(val2);
31165 }
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 (arg1)->CenterOnParent(arg2);
31169 wxPyEndAllowThreads(__tstate);
31170 if (PyErr_Occurred()) SWIG_fail;
31171 }
31172 resultobj = SWIG_Py_Void();
31173 return resultobj;
31174 fail:
31175 return NULL;
31176 }
31177
31178
31179 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31180 PyObject *resultobj = 0;
31181 wxWindow *arg1 = (wxWindow *) 0 ;
31182 void *argp1 = 0 ;
31183 int res1 = 0 ;
31184 PyObject *swig_obj[1] ;
31185
31186 if (!args) SWIG_fail;
31187 swig_obj[0] = args;
31188 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31189 if (!SWIG_IsOK(res1)) {
31190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31191 }
31192 arg1 = reinterpret_cast< wxWindow * >(argp1);
31193 {
31194 PyThreadState* __tstate = wxPyBeginAllowThreads();
31195 (arg1)->Fit();
31196 wxPyEndAllowThreads(__tstate);
31197 if (PyErr_Occurred()) SWIG_fail;
31198 }
31199 resultobj = SWIG_Py_Void();
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207 PyObject *resultobj = 0;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 void *argp1 = 0 ;
31210 int res1 = 0 ;
31211 PyObject *swig_obj[1] ;
31212
31213 if (!args) SWIG_fail;
31214 swig_obj[0] = args;
31215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31216 if (!SWIG_IsOK(res1)) {
31217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31218 }
31219 arg1 = reinterpret_cast< wxWindow * >(argp1);
31220 {
31221 PyThreadState* __tstate = wxPyBeginAllowThreads();
31222 (arg1)->FitInside();
31223 wxPyEndAllowThreads(__tstate);
31224 if (PyErr_Occurred()) SWIG_fail;
31225 }
31226 resultobj = SWIG_Py_Void();
31227 return resultobj;
31228 fail:
31229 return NULL;
31230 }
31231
31232
31233 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31234 PyObject *resultobj = 0;
31235 wxWindow *arg1 = (wxWindow *) 0 ;
31236 int arg2 ;
31237 int arg3 ;
31238 int arg4 = (int) -1 ;
31239 int arg5 = (int) -1 ;
31240 int arg6 = (int) -1 ;
31241 int arg7 = (int) -1 ;
31242 void *argp1 = 0 ;
31243 int res1 = 0 ;
31244 int val2 ;
31245 int ecode2 = 0 ;
31246 int val3 ;
31247 int ecode3 = 0 ;
31248 int val4 ;
31249 int ecode4 = 0 ;
31250 int val5 ;
31251 int ecode5 = 0 ;
31252 int val6 ;
31253 int ecode6 = 0 ;
31254 int val7 ;
31255 int ecode7 = 0 ;
31256 PyObject * obj0 = 0 ;
31257 PyObject * obj1 = 0 ;
31258 PyObject * obj2 = 0 ;
31259 PyObject * obj3 = 0 ;
31260 PyObject * obj4 = 0 ;
31261 PyObject * obj5 = 0 ;
31262 PyObject * obj6 = 0 ;
31263 char * kwnames[] = {
31264 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31265 };
31266
31267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31269 if (!SWIG_IsOK(res1)) {
31270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31271 }
31272 arg1 = reinterpret_cast< wxWindow * >(argp1);
31273 ecode2 = SWIG_AsVal_int(obj1, &val2);
31274 if (!SWIG_IsOK(ecode2)) {
31275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31276 }
31277 arg2 = static_cast< int >(val2);
31278 ecode3 = SWIG_AsVal_int(obj2, &val3);
31279 if (!SWIG_IsOK(ecode3)) {
31280 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31281 }
31282 arg3 = static_cast< int >(val3);
31283 if (obj3) {
31284 ecode4 = SWIG_AsVal_int(obj3, &val4);
31285 if (!SWIG_IsOK(ecode4)) {
31286 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31287 }
31288 arg4 = static_cast< int >(val4);
31289 }
31290 if (obj4) {
31291 ecode5 = SWIG_AsVal_int(obj4, &val5);
31292 if (!SWIG_IsOK(ecode5)) {
31293 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31294 }
31295 arg5 = static_cast< int >(val5);
31296 }
31297 if (obj5) {
31298 ecode6 = SWIG_AsVal_int(obj5, &val6);
31299 if (!SWIG_IsOK(ecode6)) {
31300 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31301 }
31302 arg6 = static_cast< int >(val6);
31303 }
31304 if (obj6) {
31305 ecode7 = SWIG_AsVal_int(obj6, &val7);
31306 if (!SWIG_IsOK(ecode7)) {
31307 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31308 }
31309 arg7 = static_cast< int >(val7);
31310 }
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31314 wxPyEndAllowThreads(__tstate);
31315 if (PyErr_Occurred()) SWIG_fail;
31316 }
31317 resultobj = SWIG_Py_Void();
31318 return resultobj;
31319 fail:
31320 return NULL;
31321 }
31322
31323
31324 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31325 PyObject *resultobj = 0;
31326 wxWindow *arg1 = (wxWindow *) 0 ;
31327 wxSize *arg2 = 0 ;
31328 wxSize const &arg3_defvalue = wxDefaultSize ;
31329 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31330 wxSize const &arg4_defvalue = wxDefaultSize ;
31331 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31332 void *argp1 = 0 ;
31333 int res1 = 0 ;
31334 wxSize temp2 ;
31335 wxSize temp3 ;
31336 wxSize temp4 ;
31337 PyObject * obj0 = 0 ;
31338 PyObject * obj1 = 0 ;
31339 PyObject * obj2 = 0 ;
31340 PyObject * obj3 = 0 ;
31341 char * kwnames[] = {
31342 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31343 };
31344
31345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31347 if (!SWIG_IsOK(res1)) {
31348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31349 }
31350 arg1 = reinterpret_cast< wxWindow * >(argp1);
31351 {
31352 arg2 = &temp2;
31353 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31354 }
31355 if (obj2) {
31356 {
31357 arg3 = &temp3;
31358 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31359 }
31360 }
31361 if (obj3) {
31362 {
31363 arg4 = &temp4;
31364 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31365 }
31366 }
31367 {
31368 PyThreadState* __tstate = wxPyBeginAllowThreads();
31369 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31370 wxPyEndAllowThreads(__tstate);
31371 if (PyErr_Occurred()) SWIG_fail;
31372 }
31373 resultobj = SWIG_Py_Void();
31374 return resultobj;
31375 fail:
31376 return NULL;
31377 }
31378
31379
31380 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31381 PyObject *resultobj = 0;
31382 wxWindow *arg1 = (wxWindow *) 0 ;
31383 int arg2 ;
31384 int arg3 ;
31385 int arg4 = (int) -1 ;
31386 int arg5 = (int) -1 ;
31387 void *argp1 = 0 ;
31388 int res1 = 0 ;
31389 int val2 ;
31390 int ecode2 = 0 ;
31391 int val3 ;
31392 int ecode3 = 0 ;
31393 int val4 ;
31394 int ecode4 = 0 ;
31395 int val5 ;
31396 int ecode5 = 0 ;
31397 PyObject * obj0 = 0 ;
31398 PyObject * obj1 = 0 ;
31399 PyObject * obj2 = 0 ;
31400 PyObject * obj3 = 0 ;
31401 PyObject * obj4 = 0 ;
31402 char * kwnames[] = {
31403 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31404 };
31405
31406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31408 if (!SWIG_IsOK(res1)) {
31409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31410 }
31411 arg1 = reinterpret_cast< wxWindow * >(argp1);
31412 ecode2 = SWIG_AsVal_int(obj1, &val2);
31413 if (!SWIG_IsOK(ecode2)) {
31414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31415 }
31416 arg2 = static_cast< int >(val2);
31417 ecode3 = SWIG_AsVal_int(obj2, &val3);
31418 if (!SWIG_IsOK(ecode3)) {
31419 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31420 }
31421 arg3 = static_cast< int >(val3);
31422 if (obj3) {
31423 ecode4 = SWIG_AsVal_int(obj3, &val4);
31424 if (!SWIG_IsOK(ecode4)) {
31425 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31426 }
31427 arg4 = static_cast< int >(val4);
31428 }
31429 if (obj4) {
31430 ecode5 = SWIG_AsVal_int(obj4, &val5);
31431 if (!SWIG_IsOK(ecode5)) {
31432 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31433 }
31434 arg5 = static_cast< int >(val5);
31435 }
31436 {
31437 PyThreadState* __tstate = wxPyBeginAllowThreads();
31438 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31439 wxPyEndAllowThreads(__tstate);
31440 if (PyErr_Occurred()) SWIG_fail;
31441 }
31442 resultobj = SWIG_Py_Void();
31443 return resultobj;
31444 fail:
31445 return NULL;
31446 }
31447
31448
31449 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31450 PyObject *resultobj = 0;
31451 wxWindow *arg1 = (wxWindow *) 0 ;
31452 wxSize *arg2 = 0 ;
31453 wxSize const &arg3_defvalue = wxDefaultSize ;
31454 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31455 void *argp1 = 0 ;
31456 int res1 = 0 ;
31457 wxSize temp2 ;
31458 wxSize temp3 ;
31459 PyObject * obj0 = 0 ;
31460 PyObject * obj1 = 0 ;
31461 PyObject * obj2 = 0 ;
31462 char * kwnames[] = {
31463 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31464 };
31465
31466 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31467 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31468 if (!SWIG_IsOK(res1)) {
31469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31470 }
31471 arg1 = reinterpret_cast< wxWindow * >(argp1);
31472 {
31473 arg2 = &temp2;
31474 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31475 }
31476 if (obj2) {
31477 {
31478 arg3 = &temp3;
31479 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31480 }
31481 }
31482 {
31483 PyThreadState* __tstate = wxPyBeginAllowThreads();
31484 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31485 wxPyEndAllowThreads(__tstate);
31486 if (PyErr_Occurred()) SWIG_fail;
31487 }
31488 resultobj = SWIG_Py_Void();
31489 return resultobj;
31490 fail:
31491 return NULL;
31492 }
31493
31494
31495 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31496 PyObject *resultobj = 0;
31497 wxWindow *arg1 = (wxWindow *) 0 ;
31498 wxSize result;
31499 void *argp1 = 0 ;
31500 int res1 = 0 ;
31501 PyObject *swig_obj[1] ;
31502
31503 if (!args) SWIG_fail;
31504 swig_obj[0] = args;
31505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31506 if (!SWIG_IsOK(res1)) {
31507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31508 }
31509 arg1 = reinterpret_cast< wxWindow * >(argp1);
31510 {
31511 PyThreadState* __tstate = wxPyBeginAllowThreads();
31512 result = ((wxWindow const *)arg1)->GetMaxSize();
31513 wxPyEndAllowThreads(__tstate);
31514 if (PyErr_Occurred()) SWIG_fail;
31515 }
31516 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31517 return resultobj;
31518 fail:
31519 return NULL;
31520 }
31521
31522
31523 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31524 PyObject *resultobj = 0;
31525 wxWindow *arg1 = (wxWindow *) 0 ;
31526 wxSize result;
31527 void *argp1 = 0 ;
31528 int res1 = 0 ;
31529 PyObject *swig_obj[1] ;
31530
31531 if (!args) SWIG_fail;
31532 swig_obj[0] = args;
31533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31534 if (!SWIG_IsOK(res1)) {
31535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31536 }
31537 arg1 = reinterpret_cast< wxWindow * >(argp1);
31538 {
31539 PyThreadState* __tstate = wxPyBeginAllowThreads();
31540 result = ((wxWindow const *)arg1)->GetMinSize();
31541 wxPyEndAllowThreads(__tstate);
31542 if (PyErr_Occurred()) SWIG_fail;
31543 }
31544 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31545 return resultobj;
31546 fail:
31547 return NULL;
31548 }
31549
31550
31551 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31552 PyObject *resultobj = 0;
31553 wxWindow *arg1 = (wxWindow *) 0 ;
31554 wxSize *arg2 = 0 ;
31555 void *argp1 = 0 ;
31556 int res1 = 0 ;
31557 wxSize temp2 ;
31558 PyObject * obj0 = 0 ;
31559 PyObject * obj1 = 0 ;
31560 char * kwnames[] = {
31561 (char *) "self",(char *) "minSize", NULL
31562 };
31563
31564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31566 if (!SWIG_IsOK(res1)) {
31567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31568 }
31569 arg1 = reinterpret_cast< wxWindow * >(argp1);
31570 {
31571 arg2 = &temp2;
31572 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31573 }
31574 {
31575 PyThreadState* __tstate = wxPyBeginAllowThreads();
31576 (arg1)->SetMinSize((wxSize const &)*arg2);
31577 wxPyEndAllowThreads(__tstate);
31578 if (PyErr_Occurred()) SWIG_fail;
31579 }
31580 resultobj = SWIG_Py_Void();
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31588 PyObject *resultobj = 0;
31589 wxWindow *arg1 = (wxWindow *) 0 ;
31590 wxSize *arg2 = 0 ;
31591 void *argp1 = 0 ;
31592 int res1 = 0 ;
31593 wxSize temp2 ;
31594 PyObject * obj0 = 0 ;
31595 PyObject * obj1 = 0 ;
31596 char * kwnames[] = {
31597 (char *) "self",(char *) "maxSize", NULL
31598 };
31599
31600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31602 if (!SWIG_IsOK(res1)) {
31603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31604 }
31605 arg1 = reinterpret_cast< wxWindow * >(argp1);
31606 {
31607 arg2 = &temp2;
31608 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31609 }
31610 {
31611 PyThreadState* __tstate = wxPyBeginAllowThreads();
31612 (arg1)->SetMaxSize((wxSize const &)*arg2);
31613 wxPyEndAllowThreads(__tstate);
31614 if (PyErr_Occurred()) SWIG_fail;
31615 }
31616 resultobj = SWIG_Py_Void();
31617 return resultobj;
31618 fail:
31619 return NULL;
31620 }
31621
31622
31623 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31624 PyObject *resultobj = 0;
31625 wxWindow *arg1 = (wxWindow *) 0 ;
31626 int result;
31627 void *argp1 = 0 ;
31628 int res1 = 0 ;
31629 PyObject *swig_obj[1] ;
31630
31631 if (!args) SWIG_fail;
31632 swig_obj[0] = args;
31633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31634 if (!SWIG_IsOK(res1)) {
31635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31636 }
31637 arg1 = reinterpret_cast< wxWindow * >(argp1);
31638 {
31639 PyThreadState* __tstate = wxPyBeginAllowThreads();
31640 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31641 wxPyEndAllowThreads(__tstate);
31642 if (PyErr_Occurred()) SWIG_fail;
31643 }
31644 resultobj = SWIG_From_int(static_cast< int >(result));
31645 return resultobj;
31646 fail:
31647 return NULL;
31648 }
31649
31650
31651 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31652 PyObject *resultobj = 0;
31653 wxWindow *arg1 = (wxWindow *) 0 ;
31654 int result;
31655 void *argp1 = 0 ;
31656 int res1 = 0 ;
31657 PyObject *swig_obj[1] ;
31658
31659 if (!args) SWIG_fail;
31660 swig_obj[0] = args;
31661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31662 if (!SWIG_IsOK(res1)) {
31663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31664 }
31665 arg1 = reinterpret_cast< wxWindow * >(argp1);
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 resultobj = SWIG_From_int(static_cast< int >(result));
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31680 PyObject *resultobj = 0;
31681 wxWindow *arg1 = (wxWindow *) 0 ;
31682 int result;
31683 void *argp1 = 0 ;
31684 int res1 = 0 ;
31685 PyObject *swig_obj[1] ;
31686
31687 if (!args) SWIG_fail;
31688 swig_obj[0] = args;
31689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31690 if (!SWIG_IsOK(res1)) {
31691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31692 }
31693 arg1 = reinterpret_cast< wxWindow * >(argp1);
31694 {
31695 PyThreadState* __tstate = wxPyBeginAllowThreads();
31696 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31697 wxPyEndAllowThreads(__tstate);
31698 if (PyErr_Occurred()) SWIG_fail;
31699 }
31700 resultobj = SWIG_From_int(static_cast< int >(result));
31701 return resultobj;
31702 fail:
31703 return NULL;
31704 }
31705
31706
31707 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31708 PyObject *resultobj = 0;
31709 wxWindow *arg1 = (wxWindow *) 0 ;
31710 int result;
31711 void *argp1 = 0 ;
31712 int res1 = 0 ;
31713 PyObject *swig_obj[1] ;
31714
31715 if (!args) SWIG_fail;
31716 swig_obj[0] = args;
31717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31718 if (!SWIG_IsOK(res1)) {
31719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31720 }
31721 arg1 = reinterpret_cast< wxWindow * >(argp1);
31722 {
31723 PyThreadState* __tstate = wxPyBeginAllowThreads();
31724 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31725 wxPyEndAllowThreads(__tstate);
31726 if (PyErr_Occurred()) SWIG_fail;
31727 }
31728 resultobj = SWIG_From_int(static_cast< int >(result));
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31736 PyObject *resultobj = 0;
31737 wxWindow *arg1 = (wxWindow *) 0 ;
31738 wxSize *arg2 = 0 ;
31739 void *argp1 = 0 ;
31740 int res1 = 0 ;
31741 wxSize temp2 ;
31742 PyObject * obj0 = 0 ;
31743 PyObject * obj1 = 0 ;
31744 char * kwnames[] = {
31745 (char *) "self",(char *) "size", NULL
31746 };
31747
31748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31750 if (!SWIG_IsOK(res1)) {
31751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31752 }
31753 arg1 = reinterpret_cast< wxWindow * >(argp1);
31754 {
31755 arg2 = &temp2;
31756 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31757 }
31758 {
31759 PyThreadState* __tstate = wxPyBeginAllowThreads();
31760 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 resultobj = SWIG_Py_Void();
31765 return resultobj;
31766 fail:
31767 return NULL;
31768 }
31769
31770
31771 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31772 PyObject *resultobj = 0;
31773 wxWindow *arg1 = (wxWindow *) 0 ;
31774 int arg2 ;
31775 int arg3 ;
31776 void *argp1 = 0 ;
31777 int res1 = 0 ;
31778 int val2 ;
31779 int ecode2 = 0 ;
31780 int val3 ;
31781 int ecode3 = 0 ;
31782 PyObject * obj0 = 0 ;
31783 PyObject * obj1 = 0 ;
31784 PyObject * obj2 = 0 ;
31785 char * kwnames[] = {
31786 (char *) "self",(char *) "w",(char *) "h", NULL
31787 };
31788
31789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31791 if (!SWIG_IsOK(res1)) {
31792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31793 }
31794 arg1 = reinterpret_cast< wxWindow * >(argp1);
31795 ecode2 = SWIG_AsVal_int(obj1, &val2);
31796 if (!SWIG_IsOK(ecode2)) {
31797 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31798 }
31799 arg2 = static_cast< int >(val2);
31800 ecode3 = SWIG_AsVal_int(obj2, &val3);
31801 if (!SWIG_IsOK(ecode3)) {
31802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31803 }
31804 arg3 = static_cast< int >(val3);
31805 {
31806 PyThreadState* __tstate = wxPyBeginAllowThreads();
31807 (arg1)->SetVirtualSize(arg2,arg3);
31808 wxPyEndAllowThreads(__tstate);
31809 if (PyErr_Occurred()) SWIG_fail;
31810 }
31811 resultobj = SWIG_Py_Void();
31812 return resultobj;
31813 fail:
31814 return NULL;
31815 }
31816
31817
31818 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31819 PyObject *resultobj = 0;
31820 wxWindow *arg1 = (wxWindow *) 0 ;
31821 wxSize result;
31822 void *argp1 = 0 ;
31823 int res1 = 0 ;
31824 PyObject *swig_obj[1] ;
31825
31826 if (!args) SWIG_fail;
31827 swig_obj[0] = args;
31828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31829 if (!SWIG_IsOK(res1)) {
31830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31831 }
31832 arg1 = reinterpret_cast< wxWindow * >(argp1);
31833 {
31834 PyThreadState* __tstate = wxPyBeginAllowThreads();
31835 result = ((wxWindow const *)arg1)->GetVirtualSize();
31836 wxPyEndAllowThreads(__tstate);
31837 if (PyErr_Occurred()) SWIG_fail;
31838 }
31839 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31840 return resultobj;
31841 fail:
31842 return NULL;
31843 }
31844
31845
31846 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31847 PyObject *resultobj = 0;
31848 wxWindow *arg1 = (wxWindow *) 0 ;
31849 int *arg2 = (int *) 0 ;
31850 int *arg3 = (int *) 0 ;
31851 void *argp1 = 0 ;
31852 int res1 = 0 ;
31853 int temp2 ;
31854 int res2 = SWIG_TMPOBJ ;
31855 int temp3 ;
31856 int res3 = SWIG_TMPOBJ ;
31857 PyObject *swig_obj[1] ;
31858
31859 arg2 = &temp2;
31860 arg3 = &temp3;
31861 if (!args) SWIG_fail;
31862 swig_obj[0] = args;
31863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31864 if (!SWIG_IsOK(res1)) {
31865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31866 }
31867 arg1 = reinterpret_cast< wxWindow * >(argp1);
31868 {
31869 PyThreadState* __tstate = wxPyBeginAllowThreads();
31870 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
31871 wxPyEndAllowThreads(__tstate);
31872 if (PyErr_Occurred()) SWIG_fail;
31873 }
31874 resultobj = SWIG_Py_Void();
31875 if (SWIG_IsTmpObj(res2)) {
31876 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31877 } else {
31878 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31879 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31880 }
31881 if (SWIG_IsTmpObj(res3)) {
31882 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31883 } else {
31884 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31885 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31886 }
31887 return resultobj;
31888 fail:
31889 return NULL;
31890 }
31891
31892
31893 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31894 PyObject *resultobj = 0;
31895 wxWindow *arg1 = (wxWindow *) 0 ;
31896 wxSize result;
31897 void *argp1 = 0 ;
31898 int res1 = 0 ;
31899 PyObject *swig_obj[1] ;
31900
31901 if (!args) SWIG_fail;
31902 swig_obj[0] = args;
31903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31904 if (!SWIG_IsOK(res1)) {
31905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31906 }
31907 arg1 = reinterpret_cast< wxWindow * >(argp1);
31908 {
31909 PyThreadState* __tstate = wxPyBeginAllowThreads();
31910 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
31911 wxPyEndAllowThreads(__tstate);
31912 if (PyErr_Occurred()) SWIG_fail;
31913 }
31914 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31915 return resultobj;
31916 fail:
31917 return NULL;
31918 }
31919
31920
31921 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31922 PyObject *resultobj = 0;
31923 wxWindow *arg1 = (wxWindow *) 0 ;
31924 bool arg2 = (bool) true ;
31925 bool result;
31926 void *argp1 = 0 ;
31927 int res1 = 0 ;
31928 bool val2 ;
31929 int ecode2 = 0 ;
31930 PyObject * obj0 = 0 ;
31931 PyObject * obj1 = 0 ;
31932 char * kwnames[] = {
31933 (char *) "self",(char *) "show", NULL
31934 };
31935
31936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
31937 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31938 if (!SWIG_IsOK(res1)) {
31939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
31940 }
31941 arg1 = reinterpret_cast< wxWindow * >(argp1);
31942 if (obj1) {
31943 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31944 if (!SWIG_IsOK(ecode2)) {
31945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
31946 }
31947 arg2 = static_cast< bool >(val2);
31948 }
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 result = (bool)(arg1)->Show(arg2);
31952 wxPyEndAllowThreads(__tstate);
31953 if (PyErr_Occurred()) SWIG_fail;
31954 }
31955 {
31956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31957 }
31958 return resultobj;
31959 fail:
31960 return NULL;
31961 }
31962
31963
31964 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31965 PyObject *resultobj = 0;
31966 wxWindow *arg1 = (wxWindow *) 0 ;
31967 bool result;
31968 void *argp1 = 0 ;
31969 int res1 = 0 ;
31970 PyObject *swig_obj[1] ;
31971
31972 if (!args) SWIG_fail;
31973 swig_obj[0] = args;
31974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31975 if (!SWIG_IsOK(res1)) {
31976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
31977 }
31978 arg1 = reinterpret_cast< wxWindow * >(argp1);
31979 {
31980 PyThreadState* __tstate = wxPyBeginAllowThreads();
31981 result = (bool)(arg1)->Hide();
31982 wxPyEndAllowThreads(__tstate);
31983 if (PyErr_Occurred()) SWIG_fail;
31984 }
31985 {
31986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31987 }
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31995 PyObject *resultobj = 0;
31996 wxWindow *arg1 = (wxWindow *) 0 ;
31997 bool arg2 = (bool) true ;
31998 bool result;
31999 void *argp1 = 0 ;
32000 int res1 = 0 ;
32001 bool val2 ;
32002 int ecode2 = 0 ;
32003 PyObject * obj0 = 0 ;
32004 PyObject * obj1 = 0 ;
32005 char * kwnames[] = {
32006 (char *) "self",(char *) "enable", NULL
32007 };
32008
32009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32011 if (!SWIG_IsOK(res1)) {
32012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32013 }
32014 arg1 = reinterpret_cast< wxWindow * >(argp1);
32015 if (obj1) {
32016 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32017 if (!SWIG_IsOK(ecode2)) {
32018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32019 }
32020 arg2 = static_cast< bool >(val2);
32021 }
32022 {
32023 PyThreadState* __tstate = wxPyBeginAllowThreads();
32024 result = (bool)(arg1)->Enable(arg2);
32025 wxPyEndAllowThreads(__tstate);
32026 if (PyErr_Occurred()) SWIG_fail;
32027 }
32028 {
32029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32030 }
32031 return resultobj;
32032 fail:
32033 return NULL;
32034 }
32035
32036
32037 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32038 PyObject *resultobj = 0;
32039 wxWindow *arg1 = (wxWindow *) 0 ;
32040 bool result;
32041 void *argp1 = 0 ;
32042 int res1 = 0 ;
32043 PyObject *swig_obj[1] ;
32044
32045 if (!args) SWIG_fail;
32046 swig_obj[0] = args;
32047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32048 if (!SWIG_IsOK(res1)) {
32049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32050 }
32051 arg1 = reinterpret_cast< wxWindow * >(argp1);
32052 {
32053 PyThreadState* __tstate = wxPyBeginAllowThreads();
32054 result = (bool)(arg1)->Disable();
32055 wxPyEndAllowThreads(__tstate);
32056 if (PyErr_Occurred()) SWIG_fail;
32057 }
32058 {
32059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32060 }
32061 return resultobj;
32062 fail:
32063 return NULL;
32064 }
32065
32066
32067 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32068 PyObject *resultobj = 0;
32069 wxWindow *arg1 = (wxWindow *) 0 ;
32070 bool result;
32071 void *argp1 = 0 ;
32072 int res1 = 0 ;
32073 PyObject *swig_obj[1] ;
32074
32075 if (!args) SWIG_fail;
32076 swig_obj[0] = args;
32077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32078 if (!SWIG_IsOK(res1)) {
32079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32080 }
32081 arg1 = reinterpret_cast< wxWindow * >(argp1);
32082 {
32083 PyThreadState* __tstate = wxPyBeginAllowThreads();
32084 result = (bool)((wxWindow const *)arg1)->IsShown();
32085 wxPyEndAllowThreads(__tstate);
32086 if (PyErr_Occurred()) SWIG_fail;
32087 }
32088 {
32089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32090 }
32091 return resultobj;
32092 fail:
32093 return NULL;
32094 }
32095
32096
32097 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32098 PyObject *resultobj = 0;
32099 wxWindow *arg1 = (wxWindow *) 0 ;
32100 bool result;
32101 void *argp1 = 0 ;
32102 int res1 = 0 ;
32103 PyObject *swig_obj[1] ;
32104
32105 if (!args) SWIG_fail;
32106 swig_obj[0] = args;
32107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32108 if (!SWIG_IsOK(res1)) {
32109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32110 }
32111 arg1 = reinterpret_cast< wxWindow * >(argp1);
32112 {
32113 PyThreadState* __tstate = wxPyBeginAllowThreads();
32114 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32115 wxPyEndAllowThreads(__tstate);
32116 if (PyErr_Occurred()) SWIG_fail;
32117 }
32118 {
32119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32120 }
32121 return resultobj;
32122 fail:
32123 return NULL;
32124 }
32125
32126
32127 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32128 PyObject *resultobj = 0;
32129 wxWindow *arg1 = (wxWindow *) 0 ;
32130 long arg2 ;
32131 void *argp1 = 0 ;
32132 int res1 = 0 ;
32133 long val2 ;
32134 int ecode2 = 0 ;
32135 PyObject * obj0 = 0 ;
32136 PyObject * obj1 = 0 ;
32137 char * kwnames[] = {
32138 (char *) "self",(char *) "style", NULL
32139 };
32140
32141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32142 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32143 if (!SWIG_IsOK(res1)) {
32144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32145 }
32146 arg1 = reinterpret_cast< wxWindow * >(argp1);
32147 ecode2 = SWIG_AsVal_long(obj1, &val2);
32148 if (!SWIG_IsOK(ecode2)) {
32149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32150 }
32151 arg2 = static_cast< long >(val2);
32152 {
32153 PyThreadState* __tstate = wxPyBeginAllowThreads();
32154 (arg1)->SetWindowStyleFlag(arg2);
32155 wxPyEndAllowThreads(__tstate);
32156 if (PyErr_Occurred()) SWIG_fail;
32157 }
32158 resultobj = SWIG_Py_Void();
32159 return resultobj;
32160 fail:
32161 return NULL;
32162 }
32163
32164
32165 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32166 PyObject *resultobj = 0;
32167 wxWindow *arg1 = (wxWindow *) 0 ;
32168 long result;
32169 void *argp1 = 0 ;
32170 int res1 = 0 ;
32171 PyObject *swig_obj[1] ;
32172
32173 if (!args) SWIG_fail;
32174 swig_obj[0] = args;
32175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32176 if (!SWIG_IsOK(res1)) {
32177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32178 }
32179 arg1 = reinterpret_cast< wxWindow * >(argp1);
32180 {
32181 PyThreadState* __tstate = wxPyBeginAllowThreads();
32182 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32183 wxPyEndAllowThreads(__tstate);
32184 if (PyErr_Occurred()) SWIG_fail;
32185 }
32186 resultobj = SWIG_From_long(static_cast< long >(result));
32187 return resultobj;
32188 fail:
32189 return NULL;
32190 }
32191
32192
32193 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32194 PyObject *resultobj = 0;
32195 wxWindow *arg1 = (wxWindow *) 0 ;
32196 int arg2 ;
32197 bool result;
32198 void *argp1 = 0 ;
32199 int res1 = 0 ;
32200 int val2 ;
32201 int ecode2 = 0 ;
32202 PyObject * obj0 = 0 ;
32203 PyObject * obj1 = 0 ;
32204 char * kwnames[] = {
32205 (char *) "self",(char *) "flag", NULL
32206 };
32207
32208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32210 if (!SWIG_IsOK(res1)) {
32211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32212 }
32213 arg1 = reinterpret_cast< wxWindow * >(argp1);
32214 ecode2 = SWIG_AsVal_int(obj1, &val2);
32215 if (!SWIG_IsOK(ecode2)) {
32216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32217 }
32218 arg2 = static_cast< int >(val2);
32219 {
32220 PyThreadState* __tstate = wxPyBeginAllowThreads();
32221 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32222 wxPyEndAllowThreads(__tstate);
32223 if (PyErr_Occurred()) SWIG_fail;
32224 }
32225 {
32226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32227 }
32228 return resultobj;
32229 fail:
32230 return NULL;
32231 }
32232
32233
32234 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32235 PyObject *resultobj = 0;
32236 wxWindow *arg1 = (wxWindow *) 0 ;
32237 bool result;
32238 void *argp1 = 0 ;
32239 int res1 = 0 ;
32240 PyObject *swig_obj[1] ;
32241
32242 if (!args) SWIG_fail;
32243 swig_obj[0] = args;
32244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32245 if (!SWIG_IsOK(res1)) {
32246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32247 }
32248 arg1 = reinterpret_cast< wxWindow * >(argp1);
32249 {
32250 PyThreadState* __tstate = wxPyBeginAllowThreads();
32251 result = (bool)((wxWindow const *)arg1)->IsRetained();
32252 wxPyEndAllowThreads(__tstate);
32253 if (PyErr_Occurred()) SWIG_fail;
32254 }
32255 {
32256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32257 }
32258 return resultobj;
32259 fail:
32260 return NULL;
32261 }
32262
32263
32264 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32265 PyObject *resultobj = 0;
32266 wxWindow *arg1 = (wxWindow *) 0 ;
32267 long arg2 ;
32268 void *argp1 = 0 ;
32269 int res1 = 0 ;
32270 long val2 ;
32271 int ecode2 = 0 ;
32272 PyObject * obj0 = 0 ;
32273 PyObject * obj1 = 0 ;
32274 char * kwnames[] = {
32275 (char *) "self",(char *) "exStyle", NULL
32276 };
32277
32278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32280 if (!SWIG_IsOK(res1)) {
32281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32282 }
32283 arg1 = reinterpret_cast< wxWindow * >(argp1);
32284 ecode2 = SWIG_AsVal_long(obj1, &val2);
32285 if (!SWIG_IsOK(ecode2)) {
32286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32287 }
32288 arg2 = static_cast< long >(val2);
32289 {
32290 PyThreadState* __tstate = wxPyBeginAllowThreads();
32291 (arg1)->SetExtraStyle(arg2);
32292 wxPyEndAllowThreads(__tstate);
32293 if (PyErr_Occurred()) SWIG_fail;
32294 }
32295 resultobj = SWIG_Py_Void();
32296 return resultobj;
32297 fail:
32298 return NULL;
32299 }
32300
32301
32302 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32303 PyObject *resultobj = 0;
32304 wxWindow *arg1 = (wxWindow *) 0 ;
32305 long result;
32306 void *argp1 = 0 ;
32307 int res1 = 0 ;
32308 PyObject *swig_obj[1] ;
32309
32310 if (!args) SWIG_fail;
32311 swig_obj[0] = args;
32312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32313 if (!SWIG_IsOK(res1)) {
32314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32315 }
32316 arg1 = reinterpret_cast< wxWindow * >(argp1);
32317 {
32318 PyThreadState* __tstate = wxPyBeginAllowThreads();
32319 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 resultobj = SWIG_From_long(static_cast< long >(result));
32324 return resultobj;
32325 fail:
32326 return NULL;
32327 }
32328
32329
32330 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32331 PyObject *resultobj = 0;
32332 wxWindow *arg1 = (wxWindow *) 0 ;
32333 bool arg2 = (bool) true ;
32334 void *argp1 = 0 ;
32335 int res1 = 0 ;
32336 bool val2 ;
32337 int ecode2 = 0 ;
32338 PyObject * obj0 = 0 ;
32339 PyObject * obj1 = 0 ;
32340 char * kwnames[] = {
32341 (char *) "self",(char *) "modal", NULL
32342 };
32343
32344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32346 if (!SWIG_IsOK(res1)) {
32347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32348 }
32349 arg1 = reinterpret_cast< wxWindow * >(argp1);
32350 if (obj1) {
32351 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32352 if (!SWIG_IsOK(ecode2)) {
32353 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32354 }
32355 arg2 = static_cast< bool >(val2);
32356 }
32357 {
32358 PyThreadState* __tstate = wxPyBeginAllowThreads();
32359 (arg1)->MakeModal(arg2);
32360 wxPyEndAllowThreads(__tstate);
32361 if (PyErr_Occurred()) SWIG_fail;
32362 }
32363 resultobj = SWIG_Py_Void();
32364 return resultobj;
32365 fail:
32366 return NULL;
32367 }
32368
32369
32370 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32371 PyObject *resultobj = 0;
32372 wxWindow *arg1 = (wxWindow *) 0 ;
32373 bool arg2 ;
32374 void *argp1 = 0 ;
32375 int res1 = 0 ;
32376 bool val2 ;
32377 int ecode2 = 0 ;
32378 PyObject * obj0 = 0 ;
32379 PyObject * obj1 = 0 ;
32380 char * kwnames[] = {
32381 (char *) "self",(char *) "enableTheme", NULL
32382 };
32383
32384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32386 if (!SWIG_IsOK(res1)) {
32387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32388 }
32389 arg1 = reinterpret_cast< wxWindow * >(argp1);
32390 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32391 if (!SWIG_IsOK(ecode2)) {
32392 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32393 }
32394 arg2 = static_cast< bool >(val2);
32395 {
32396 PyThreadState* __tstate = wxPyBeginAllowThreads();
32397 (arg1)->SetThemeEnabled(arg2);
32398 wxPyEndAllowThreads(__tstate);
32399 if (PyErr_Occurred()) SWIG_fail;
32400 }
32401 resultobj = SWIG_Py_Void();
32402 return resultobj;
32403 fail:
32404 return NULL;
32405 }
32406
32407
32408 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32409 PyObject *resultobj = 0;
32410 wxWindow *arg1 = (wxWindow *) 0 ;
32411 bool result;
32412 void *argp1 = 0 ;
32413 int res1 = 0 ;
32414 PyObject *swig_obj[1] ;
32415
32416 if (!args) SWIG_fail;
32417 swig_obj[0] = args;
32418 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32419 if (!SWIG_IsOK(res1)) {
32420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32421 }
32422 arg1 = reinterpret_cast< wxWindow * >(argp1);
32423 {
32424 PyThreadState* __tstate = wxPyBeginAllowThreads();
32425 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32426 wxPyEndAllowThreads(__tstate);
32427 if (PyErr_Occurred()) SWIG_fail;
32428 }
32429 {
32430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32431 }
32432 return resultobj;
32433 fail:
32434 return NULL;
32435 }
32436
32437
32438 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32439 PyObject *resultobj = 0;
32440 wxWindow *arg1 = (wxWindow *) 0 ;
32441 void *argp1 = 0 ;
32442 int res1 = 0 ;
32443 PyObject *swig_obj[1] ;
32444
32445 if (!args) SWIG_fail;
32446 swig_obj[0] = args;
32447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32448 if (!SWIG_IsOK(res1)) {
32449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32450 }
32451 arg1 = reinterpret_cast< wxWindow * >(argp1);
32452 {
32453 PyThreadState* __tstate = wxPyBeginAllowThreads();
32454 (arg1)->SetFocus();
32455 wxPyEndAllowThreads(__tstate);
32456 if (PyErr_Occurred()) SWIG_fail;
32457 }
32458 resultobj = SWIG_Py_Void();
32459 return resultobj;
32460 fail:
32461 return NULL;
32462 }
32463
32464
32465 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 PyObject *resultobj = 0;
32467 wxWindow *arg1 = (wxWindow *) 0 ;
32468 void *argp1 = 0 ;
32469 int res1 = 0 ;
32470 PyObject *swig_obj[1] ;
32471
32472 if (!args) SWIG_fail;
32473 swig_obj[0] = args;
32474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32475 if (!SWIG_IsOK(res1)) {
32476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32477 }
32478 arg1 = reinterpret_cast< wxWindow * >(argp1);
32479 {
32480 PyThreadState* __tstate = wxPyBeginAllowThreads();
32481 (arg1)->SetFocusFromKbd();
32482 wxPyEndAllowThreads(__tstate);
32483 if (PyErr_Occurred()) SWIG_fail;
32484 }
32485 resultobj = SWIG_Py_Void();
32486 return resultobj;
32487 fail:
32488 return NULL;
32489 }
32490
32491
32492 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32493 PyObject *resultobj = 0;
32494 wxWindow *result = 0 ;
32495
32496 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32497 {
32498 if (!wxPyCheckForApp()) SWIG_fail;
32499 PyThreadState* __tstate = wxPyBeginAllowThreads();
32500 result = (wxWindow *)wxWindow::FindFocus();
32501 wxPyEndAllowThreads(__tstate);
32502 if (PyErr_Occurred()) SWIG_fail;
32503 }
32504 {
32505 resultobj = wxPyMake_wxObject(result, 0);
32506 }
32507 return resultobj;
32508 fail:
32509 return NULL;
32510 }
32511
32512
32513 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32514 PyObject *resultobj = 0;
32515 wxWindow *arg1 = (wxWindow *) 0 ;
32516 bool result;
32517 void *argp1 = 0 ;
32518 int res1 = 0 ;
32519 PyObject *swig_obj[1] ;
32520
32521 if (!args) SWIG_fail;
32522 swig_obj[0] = args;
32523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32524 if (!SWIG_IsOK(res1)) {
32525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32526 }
32527 arg1 = reinterpret_cast< wxWindow * >(argp1);
32528 {
32529 PyThreadState* __tstate = wxPyBeginAllowThreads();
32530 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32531 wxPyEndAllowThreads(__tstate);
32532 if (PyErr_Occurred()) SWIG_fail;
32533 }
32534 {
32535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32536 }
32537 return resultobj;
32538 fail:
32539 return NULL;
32540 }
32541
32542
32543 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32544 PyObject *resultobj = 0;
32545 wxWindow *arg1 = (wxWindow *) 0 ;
32546 bool result;
32547 void *argp1 = 0 ;
32548 int res1 = 0 ;
32549 PyObject *swig_obj[1] ;
32550
32551 if (!args) SWIG_fail;
32552 swig_obj[0] = args;
32553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32554 if (!SWIG_IsOK(res1)) {
32555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32556 }
32557 arg1 = reinterpret_cast< wxWindow * >(argp1);
32558 {
32559 PyThreadState* __tstate = wxPyBeginAllowThreads();
32560 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32561 wxPyEndAllowThreads(__tstate);
32562 if (PyErr_Occurred()) SWIG_fail;
32563 }
32564 {
32565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32566 }
32567 return resultobj;
32568 fail:
32569 return NULL;
32570 }
32571
32572
32573 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32574 PyObject *resultobj = 0;
32575 wxWindow *arg1 = (wxWindow *) 0 ;
32576 wxWindow *result = 0 ;
32577 void *argp1 = 0 ;
32578 int res1 = 0 ;
32579 PyObject *swig_obj[1] ;
32580
32581 if (!args) SWIG_fail;
32582 swig_obj[0] = args;
32583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32584 if (!SWIG_IsOK(res1)) {
32585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32586 }
32587 arg1 = reinterpret_cast< wxWindow * >(argp1);
32588 {
32589 PyThreadState* __tstate = wxPyBeginAllowThreads();
32590 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32591 wxPyEndAllowThreads(__tstate);
32592 if (PyErr_Occurred()) SWIG_fail;
32593 }
32594 {
32595 resultobj = wxPyMake_wxObject(result, 0);
32596 }
32597 return resultobj;
32598 fail:
32599 return NULL;
32600 }
32601
32602
32603 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32604 PyObject *resultobj = 0;
32605 wxWindow *arg1 = (wxWindow *) 0 ;
32606 wxWindow *arg2 = (wxWindow *) 0 ;
32607 wxWindow *result = 0 ;
32608 void *argp1 = 0 ;
32609 int res1 = 0 ;
32610 void *argp2 = 0 ;
32611 int res2 = 0 ;
32612 PyObject * obj0 = 0 ;
32613 PyObject * obj1 = 0 ;
32614 char * kwnames[] = {
32615 (char *) "self",(char *) "child", NULL
32616 };
32617
32618 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32619 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32620 if (!SWIG_IsOK(res1)) {
32621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32622 }
32623 arg1 = reinterpret_cast< wxWindow * >(argp1);
32624 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32625 if (!SWIG_IsOK(res2)) {
32626 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32627 }
32628 arg2 = reinterpret_cast< wxWindow * >(argp2);
32629 {
32630 PyThreadState* __tstate = wxPyBeginAllowThreads();
32631 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32632 wxPyEndAllowThreads(__tstate);
32633 if (PyErr_Occurred()) SWIG_fail;
32634 }
32635 {
32636 resultobj = wxPyMake_wxObject(result, 0);
32637 }
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32645 PyObject *resultobj = 0;
32646 wxWindow *arg1 = (wxWindow *) 0 ;
32647 wxWindow *arg2 = (wxWindow *) 0 ;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 void *argp2 = 0 ;
32651 int res2 = 0 ;
32652 PyObject * obj0 = 0 ;
32653 PyObject * obj1 = 0 ;
32654 char * kwnames[] = {
32655 (char *) "self",(char *) "win", NULL
32656 };
32657
32658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32660 if (!SWIG_IsOK(res1)) {
32661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32662 }
32663 arg1 = reinterpret_cast< wxWindow * >(argp1);
32664 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32665 if (!SWIG_IsOK(res2)) {
32666 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32667 }
32668 arg2 = reinterpret_cast< wxWindow * >(argp2);
32669 {
32670 PyThreadState* __tstate = wxPyBeginAllowThreads();
32671 (arg1)->SetTmpDefaultItem(arg2);
32672 wxPyEndAllowThreads(__tstate);
32673 if (PyErr_Occurred()) SWIG_fail;
32674 }
32675 resultobj = SWIG_Py_Void();
32676 return resultobj;
32677 fail:
32678 return NULL;
32679 }
32680
32681
32682 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32683 PyObject *resultobj = 0;
32684 wxWindow *arg1 = (wxWindow *) 0 ;
32685 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32686 bool result;
32687 void *argp1 = 0 ;
32688 int res1 = 0 ;
32689 int val2 ;
32690 int ecode2 = 0 ;
32691 PyObject * obj0 = 0 ;
32692 PyObject * obj1 = 0 ;
32693 char * kwnames[] = {
32694 (char *) "self",(char *) "flags", NULL
32695 };
32696
32697 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32698 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32699 if (!SWIG_IsOK(res1)) {
32700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32701 }
32702 arg1 = reinterpret_cast< wxWindow * >(argp1);
32703 if (obj1) {
32704 ecode2 = SWIG_AsVal_int(obj1, &val2);
32705 if (!SWIG_IsOK(ecode2)) {
32706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32707 }
32708 arg2 = static_cast< int >(val2);
32709 }
32710 {
32711 PyThreadState* __tstate = wxPyBeginAllowThreads();
32712 result = (bool)(arg1)->Navigate(arg2);
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 {
32717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32718 }
32719 return resultobj;
32720 fail:
32721 return NULL;
32722 }
32723
32724
32725 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32726 PyObject *resultobj = 0;
32727 wxWindow *arg1 = (wxWindow *) 0 ;
32728 wxWindow *arg2 = (wxWindow *) 0 ;
32729 void *argp1 = 0 ;
32730 int res1 = 0 ;
32731 void *argp2 = 0 ;
32732 int res2 = 0 ;
32733 PyObject * obj0 = 0 ;
32734 PyObject * obj1 = 0 ;
32735 char * kwnames[] = {
32736 (char *) "self",(char *) "win", NULL
32737 };
32738
32739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32741 if (!SWIG_IsOK(res1)) {
32742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32743 }
32744 arg1 = reinterpret_cast< wxWindow * >(argp1);
32745 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32746 if (!SWIG_IsOK(res2)) {
32747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32748 }
32749 arg2 = reinterpret_cast< wxWindow * >(argp2);
32750 {
32751 PyThreadState* __tstate = wxPyBeginAllowThreads();
32752 (arg1)->MoveAfterInTabOrder(arg2);
32753 wxPyEndAllowThreads(__tstate);
32754 if (PyErr_Occurred()) SWIG_fail;
32755 }
32756 resultobj = SWIG_Py_Void();
32757 return resultobj;
32758 fail:
32759 return NULL;
32760 }
32761
32762
32763 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32764 PyObject *resultobj = 0;
32765 wxWindow *arg1 = (wxWindow *) 0 ;
32766 wxWindow *arg2 = (wxWindow *) 0 ;
32767 void *argp1 = 0 ;
32768 int res1 = 0 ;
32769 void *argp2 = 0 ;
32770 int res2 = 0 ;
32771 PyObject * obj0 = 0 ;
32772 PyObject * obj1 = 0 ;
32773 char * kwnames[] = {
32774 (char *) "self",(char *) "win", NULL
32775 };
32776
32777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32778 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32779 if (!SWIG_IsOK(res1)) {
32780 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32781 }
32782 arg1 = reinterpret_cast< wxWindow * >(argp1);
32783 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32784 if (!SWIG_IsOK(res2)) {
32785 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32786 }
32787 arg2 = reinterpret_cast< wxWindow * >(argp2);
32788 {
32789 PyThreadState* __tstate = wxPyBeginAllowThreads();
32790 (arg1)->MoveBeforeInTabOrder(arg2);
32791 wxPyEndAllowThreads(__tstate);
32792 if (PyErr_Occurred()) SWIG_fail;
32793 }
32794 resultobj = SWIG_Py_Void();
32795 return resultobj;
32796 fail:
32797 return NULL;
32798 }
32799
32800
32801 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32802 PyObject *resultobj = 0;
32803 wxWindow *arg1 = (wxWindow *) 0 ;
32804 PyObject *result = 0 ;
32805 void *argp1 = 0 ;
32806 int res1 = 0 ;
32807 PyObject *swig_obj[1] ;
32808
32809 if (!args) SWIG_fail;
32810 swig_obj[0] = args;
32811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32812 if (!SWIG_IsOK(res1)) {
32813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32814 }
32815 arg1 = reinterpret_cast< wxWindow * >(argp1);
32816 {
32817 PyThreadState* __tstate = wxPyBeginAllowThreads();
32818 result = (PyObject *)wxWindow_GetChildren(arg1);
32819 wxPyEndAllowThreads(__tstate);
32820 if (PyErr_Occurred()) SWIG_fail;
32821 }
32822 resultobj = result;
32823 return resultobj;
32824 fail:
32825 return NULL;
32826 }
32827
32828
32829 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32830 PyObject *resultobj = 0;
32831 wxWindow *arg1 = (wxWindow *) 0 ;
32832 wxWindow *result = 0 ;
32833 void *argp1 = 0 ;
32834 int res1 = 0 ;
32835 PyObject *swig_obj[1] ;
32836
32837 if (!args) SWIG_fail;
32838 swig_obj[0] = args;
32839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32840 if (!SWIG_IsOK(res1)) {
32841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32842 }
32843 arg1 = reinterpret_cast< wxWindow * >(argp1);
32844 {
32845 PyThreadState* __tstate = wxPyBeginAllowThreads();
32846 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
32847 wxPyEndAllowThreads(__tstate);
32848 if (PyErr_Occurred()) SWIG_fail;
32849 }
32850 {
32851 resultobj = wxPyMake_wxObject(result, 0);
32852 }
32853 return resultobj;
32854 fail:
32855 return NULL;
32856 }
32857
32858
32859 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32860 PyObject *resultobj = 0;
32861 wxWindow *arg1 = (wxWindow *) 0 ;
32862 wxWindow *result = 0 ;
32863 void *argp1 = 0 ;
32864 int res1 = 0 ;
32865 PyObject *swig_obj[1] ;
32866
32867 if (!args) SWIG_fail;
32868 swig_obj[0] = args;
32869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32870 if (!SWIG_IsOK(res1)) {
32871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
32872 }
32873 arg1 = reinterpret_cast< wxWindow * >(argp1);
32874 {
32875 PyThreadState* __tstate = wxPyBeginAllowThreads();
32876 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
32877 wxPyEndAllowThreads(__tstate);
32878 if (PyErr_Occurred()) SWIG_fail;
32879 }
32880 {
32881 resultobj = wxPyMake_wxObject(result, 0);
32882 }
32883 return resultobj;
32884 fail:
32885 return NULL;
32886 }
32887
32888
32889 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32890 PyObject *resultobj = 0;
32891 wxWindow *arg1 = (wxWindow *) 0 ;
32892 bool result;
32893 void *argp1 = 0 ;
32894 int res1 = 0 ;
32895 PyObject *swig_obj[1] ;
32896
32897 if (!args) SWIG_fail;
32898 swig_obj[0] = args;
32899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32900 if (!SWIG_IsOK(res1)) {
32901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
32902 }
32903 arg1 = reinterpret_cast< wxWindow * >(argp1);
32904 {
32905 PyThreadState* __tstate = wxPyBeginAllowThreads();
32906 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
32907 wxPyEndAllowThreads(__tstate);
32908 if (PyErr_Occurred()) SWIG_fail;
32909 }
32910 {
32911 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32912 }
32913 return resultobj;
32914 fail:
32915 return NULL;
32916 }
32917
32918
32919 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32920 PyObject *resultobj = 0;
32921 wxWindow *arg1 = (wxWindow *) 0 ;
32922 wxWindow *arg2 = (wxWindow *) 0 ;
32923 bool result;
32924 void *argp1 = 0 ;
32925 int res1 = 0 ;
32926 void *argp2 = 0 ;
32927 int res2 = 0 ;
32928 PyObject * obj0 = 0 ;
32929 PyObject * obj1 = 0 ;
32930 char * kwnames[] = {
32931 (char *) "self",(char *) "newParent", NULL
32932 };
32933
32934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
32935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32936 if (!SWIG_IsOK(res1)) {
32937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
32938 }
32939 arg1 = reinterpret_cast< wxWindow * >(argp1);
32940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32941 if (!SWIG_IsOK(res2)) {
32942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
32943 }
32944 arg2 = reinterpret_cast< wxWindow * >(argp2);
32945 {
32946 PyThreadState* __tstate = wxPyBeginAllowThreads();
32947 result = (bool)(arg1)->Reparent(arg2);
32948 wxPyEndAllowThreads(__tstate);
32949 if (PyErr_Occurred()) SWIG_fail;
32950 }
32951 {
32952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32953 }
32954 return resultobj;
32955 fail:
32956 return NULL;
32957 }
32958
32959
32960 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32961 PyObject *resultobj = 0;
32962 wxWindow *arg1 = (wxWindow *) 0 ;
32963 wxWindow *arg2 = (wxWindow *) 0 ;
32964 void *argp1 = 0 ;
32965 int res1 = 0 ;
32966 void *argp2 = 0 ;
32967 int res2 = 0 ;
32968 PyObject * obj0 = 0 ;
32969 PyObject * obj1 = 0 ;
32970 char * kwnames[] = {
32971 (char *) "self",(char *) "child", NULL
32972 };
32973
32974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
32975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
32978 }
32979 arg1 = reinterpret_cast< wxWindow * >(argp1);
32980 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32981 if (!SWIG_IsOK(res2)) {
32982 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
32983 }
32984 arg2 = reinterpret_cast< wxWindow * >(argp2);
32985 {
32986 PyThreadState* __tstate = wxPyBeginAllowThreads();
32987 (arg1)->AddChild(arg2);
32988 wxPyEndAllowThreads(__tstate);
32989 if (PyErr_Occurred()) SWIG_fail;
32990 }
32991 resultobj = SWIG_Py_Void();
32992 return resultobj;
32993 fail:
32994 return NULL;
32995 }
32996
32997
32998 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32999 PyObject *resultobj = 0;
33000 wxWindow *arg1 = (wxWindow *) 0 ;
33001 wxWindow *arg2 = (wxWindow *) 0 ;
33002 void *argp1 = 0 ;
33003 int res1 = 0 ;
33004 void *argp2 = 0 ;
33005 int res2 = 0 ;
33006 PyObject * obj0 = 0 ;
33007 PyObject * obj1 = 0 ;
33008 char * kwnames[] = {
33009 (char *) "self",(char *) "child", NULL
33010 };
33011
33012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33014 if (!SWIG_IsOK(res1)) {
33015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33016 }
33017 arg1 = reinterpret_cast< wxWindow * >(argp1);
33018 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33019 if (!SWIG_IsOK(res2)) {
33020 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33021 }
33022 arg2 = reinterpret_cast< wxWindow * >(argp2);
33023 {
33024 PyThreadState* __tstate = wxPyBeginAllowThreads();
33025 (arg1)->RemoveChild(arg2);
33026 wxPyEndAllowThreads(__tstate);
33027 if (PyErr_Occurred()) SWIG_fail;
33028 }
33029 resultobj = SWIG_Py_Void();
33030 return resultobj;
33031 fail:
33032 return NULL;
33033 }
33034
33035
33036 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33037 PyObject *resultobj = 0;
33038 wxWindow *arg1 = (wxWindow *) 0 ;
33039 long arg2 ;
33040 wxWindow *result = 0 ;
33041 void *argp1 = 0 ;
33042 int res1 = 0 ;
33043 long val2 ;
33044 int ecode2 = 0 ;
33045 PyObject * obj0 = 0 ;
33046 PyObject * obj1 = 0 ;
33047 char * kwnames[] = {
33048 (char *) "self",(char *) "winid", NULL
33049 };
33050
33051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33053 if (!SWIG_IsOK(res1)) {
33054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33055 }
33056 arg1 = reinterpret_cast< wxWindow * >(argp1);
33057 ecode2 = SWIG_AsVal_long(obj1, &val2);
33058 if (!SWIG_IsOK(ecode2)) {
33059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33060 }
33061 arg2 = static_cast< long >(val2);
33062 {
33063 PyThreadState* __tstate = wxPyBeginAllowThreads();
33064 result = (wxWindow *)(arg1)->FindWindow(arg2);
33065 wxPyEndAllowThreads(__tstate);
33066 if (PyErr_Occurred()) SWIG_fail;
33067 }
33068 {
33069 resultobj = wxPyMake_wxObject(result, 0);
33070 }
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33078 PyObject *resultobj = 0;
33079 wxWindow *arg1 = (wxWindow *) 0 ;
33080 wxString *arg2 = 0 ;
33081 wxWindow *result = 0 ;
33082 void *argp1 = 0 ;
33083 int res1 = 0 ;
33084 bool temp2 = false ;
33085 PyObject * obj0 = 0 ;
33086 PyObject * obj1 = 0 ;
33087 char * kwnames[] = {
33088 (char *) "self",(char *) "name", NULL
33089 };
33090
33091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33093 if (!SWIG_IsOK(res1)) {
33094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33095 }
33096 arg1 = reinterpret_cast< wxWindow * >(argp1);
33097 {
33098 arg2 = wxString_in_helper(obj1);
33099 if (arg2 == NULL) SWIG_fail;
33100 temp2 = true;
33101 }
33102 {
33103 PyThreadState* __tstate = wxPyBeginAllowThreads();
33104 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33105 wxPyEndAllowThreads(__tstate);
33106 if (PyErr_Occurred()) SWIG_fail;
33107 }
33108 {
33109 resultobj = wxPyMake_wxObject(result, 0);
33110 }
33111 {
33112 if (temp2)
33113 delete arg2;
33114 }
33115 return resultobj;
33116 fail:
33117 {
33118 if (temp2)
33119 delete arg2;
33120 }
33121 return NULL;
33122 }
33123
33124
33125 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33126 PyObject *resultobj = 0;
33127 wxWindow *arg1 = (wxWindow *) 0 ;
33128 wxEvtHandler *result = 0 ;
33129 void *argp1 = 0 ;
33130 int res1 = 0 ;
33131 PyObject *swig_obj[1] ;
33132
33133 if (!args) SWIG_fail;
33134 swig_obj[0] = args;
33135 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33136 if (!SWIG_IsOK(res1)) {
33137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33138 }
33139 arg1 = reinterpret_cast< wxWindow * >(argp1);
33140 {
33141 PyThreadState* __tstate = wxPyBeginAllowThreads();
33142 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33143 wxPyEndAllowThreads(__tstate);
33144 if (PyErr_Occurred()) SWIG_fail;
33145 }
33146 {
33147 resultobj = wxPyMake_wxObject(result, 0);
33148 }
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33156 PyObject *resultobj = 0;
33157 wxWindow *arg1 = (wxWindow *) 0 ;
33158 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33159 void *argp1 = 0 ;
33160 int res1 = 0 ;
33161 void *argp2 = 0 ;
33162 int res2 = 0 ;
33163 PyObject * obj0 = 0 ;
33164 PyObject * obj1 = 0 ;
33165 char * kwnames[] = {
33166 (char *) "self",(char *) "handler", NULL
33167 };
33168
33169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33171 if (!SWIG_IsOK(res1)) {
33172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33173 }
33174 arg1 = reinterpret_cast< wxWindow * >(argp1);
33175 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33176 if (!SWIG_IsOK(res2)) {
33177 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33178 }
33179 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33180 {
33181 PyThreadState* __tstate = wxPyBeginAllowThreads();
33182 (arg1)->SetEventHandler(arg2);
33183 wxPyEndAllowThreads(__tstate);
33184 if (PyErr_Occurred()) SWIG_fail;
33185 }
33186 resultobj = SWIG_Py_Void();
33187 return resultobj;
33188 fail:
33189 return NULL;
33190 }
33191
33192
33193 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33194 PyObject *resultobj = 0;
33195 wxWindow *arg1 = (wxWindow *) 0 ;
33196 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33197 void *argp1 = 0 ;
33198 int res1 = 0 ;
33199 void *argp2 = 0 ;
33200 int res2 = 0 ;
33201 PyObject * obj0 = 0 ;
33202 PyObject * obj1 = 0 ;
33203 char * kwnames[] = {
33204 (char *) "self",(char *) "handler", NULL
33205 };
33206
33207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33209 if (!SWIG_IsOK(res1)) {
33210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33211 }
33212 arg1 = reinterpret_cast< wxWindow * >(argp1);
33213 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33214 if (!SWIG_IsOK(res2)) {
33215 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33216 }
33217 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33218 {
33219 PyThreadState* __tstate = wxPyBeginAllowThreads();
33220 (arg1)->PushEventHandler(arg2);
33221 wxPyEndAllowThreads(__tstate);
33222 if (PyErr_Occurred()) SWIG_fail;
33223 }
33224 resultobj = SWIG_Py_Void();
33225 return resultobj;
33226 fail:
33227 return NULL;
33228 }
33229
33230
33231 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33232 PyObject *resultobj = 0;
33233 wxWindow *arg1 = (wxWindow *) 0 ;
33234 bool arg2 = (bool) false ;
33235 wxEvtHandler *result = 0 ;
33236 void *argp1 = 0 ;
33237 int res1 = 0 ;
33238 bool val2 ;
33239 int ecode2 = 0 ;
33240 PyObject * obj0 = 0 ;
33241 PyObject * obj1 = 0 ;
33242 char * kwnames[] = {
33243 (char *) "self",(char *) "deleteHandler", NULL
33244 };
33245
33246 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33247 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33248 if (!SWIG_IsOK(res1)) {
33249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33250 }
33251 arg1 = reinterpret_cast< wxWindow * >(argp1);
33252 if (obj1) {
33253 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33254 if (!SWIG_IsOK(ecode2)) {
33255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33256 }
33257 arg2 = static_cast< bool >(val2);
33258 }
33259 {
33260 PyThreadState* __tstate = wxPyBeginAllowThreads();
33261 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33262 wxPyEndAllowThreads(__tstate);
33263 if (PyErr_Occurred()) SWIG_fail;
33264 }
33265 {
33266 resultobj = wxPyMake_wxObject(result, 0);
33267 }
33268 return resultobj;
33269 fail:
33270 return NULL;
33271 }
33272
33273
33274 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33275 PyObject *resultobj = 0;
33276 wxWindow *arg1 = (wxWindow *) 0 ;
33277 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33278 bool result;
33279 void *argp1 = 0 ;
33280 int res1 = 0 ;
33281 void *argp2 = 0 ;
33282 int res2 = 0 ;
33283 PyObject * obj0 = 0 ;
33284 PyObject * obj1 = 0 ;
33285 char * kwnames[] = {
33286 (char *) "self",(char *) "handler", NULL
33287 };
33288
33289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33291 if (!SWIG_IsOK(res1)) {
33292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33293 }
33294 arg1 = reinterpret_cast< wxWindow * >(argp1);
33295 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33296 if (!SWIG_IsOK(res2)) {
33297 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33298 }
33299 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33300 {
33301 PyThreadState* __tstate = wxPyBeginAllowThreads();
33302 result = (bool)(arg1)->RemoveEventHandler(arg2);
33303 wxPyEndAllowThreads(__tstate);
33304 if (PyErr_Occurred()) SWIG_fail;
33305 }
33306 {
33307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33308 }
33309 return resultobj;
33310 fail:
33311 return NULL;
33312 }
33313
33314
33315 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33316 PyObject *resultobj = 0;
33317 wxWindow *arg1 = (wxWindow *) 0 ;
33318 wxValidator *arg2 = 0 ;
33319 void *argp1 = 0 ;
33320 int res1 = 0 ;
33321 void *argp2 = 0 ;
33322 int res2 = 0 ;
33323 PyObject * obj0 = 0 ;
33324 PyObject * obj1 = 0 ;
33325 char * kwnames[] = {
33326 (char *) "self",(char *) "validator", NULL
33327 };
33328
33329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33330 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33331 if (!SWIG_IsOK(res1)) {
33332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33333 }
33334 arg1 = reinterpret_cast< wxWindow * >(argp1);
33335 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33336 if (!SWIG_IsOK(res2)) {
33337 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33338 }
33339 if (!argp2) {
33340 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33341 }
33342 arg2 = reinterpret_cast< wxValidator * >(argp2);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 (arg1)->SetValidator((wxValidator const &)*arg2);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 resultobj = SWIG_Py_Void();
33350 return resultobj;
33351 fail:
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33357 PyObject *resultobj = 0;
33358 wxWindow *arg1 = (wxWindow *) 0 ;
33359 wxValidator *result = 0 ;
33360 void *argp1 = 0 ;
33361 int res1 = 0 ;
33362 PyObject *swig_obj[1] ;
33363
33364 if (!args) SWIG_fail;
33365 swig_obj[0] = args;
33366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33367 if (!SWIG_IsOK(res1)) {
33368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33369 }
33370 arg1 = reinterpret_cast< wxWindow * >(argp1);
33371 {
33372 PyThreadState* __tstate = wxPyBeginAllowThreads();
33373 result = (wxValidator *)(arg1)->GetValidator();
33374 wxPyEndAllowThreads(__tstate);
33375 if (PyErr_Occurred()) SWIG_fail;
33376 }
33377 {
33378 resultobj = wxPyMake_wxObject(result, (bool)0);
33379 }
33380 return resultobj;
33381 fail:
33382 return NULL;
33383 }
33384
33385
33386 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33387 PyObject *resultobj = 0;
33388 wxWindow *arg1 = (wxWindow *) 0 ;
33389 bool result;
33390 void *argp1 = 0 ;
33391 int res1 = 0 ;
33392 PyObject *swig_obj[1] ;
33393
33394 if (!args) SWIG_fail;
33395 swig_obj[0] = args;
33396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33397 if (!SWIG_IsOK(res1)) {
33398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33399 }
33400 arg1 = reinterpret_cast< wxWindow * >(argp1);
33401 {
33402 PyThreadState* __tstate = wxPyBeginAllowThreads();
33403 result = (bool)(arg1)->Validate();
33404 wxPyEndAllowThreads(__tstate);
33405 if (PyErr_Occurred()) SWIG_fail;
33406 }
33407 {
33408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33409 }
33410 return resultobj;
33411 fail:
33412 return NULL;
33413 }
33414
33415
33416 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33417 PyObject *resultobj = 0;
33418 wxWindow *arg1 = (wxWindow *) 0 ;
33419 bool result;
33420 void *argp1 = 0 ;
33421 int res1 = 0 ;
33422 PyObject *swig_obj[1] ;
33423
33424 if (!args) SWIG_fail;
33425 swig_obj[0] = args;
33426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33427 if (!SWIG_IsOK(res1)) {
33428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33429 }
33430 arg1 = reinterpret_cast< wxWindow * >(argp1);
33431 {
33432 PyThreadState* __tstate = wxPyBeginAllowThreads();
33433 result = (bool)(arg1)->TransferDataToWindow();
33434 wxPyEndAllowThreads(__tstate);
33435 if (PyErr_Occurred()) SWIG_fail;
33436 }
33437 {
33438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33439 }
33440 return resultobj;
33441 fail:
33442 return NULL;
33443 }
33444
33445
33446 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33447 PyObject *resultobj = 0;
33448 wxWindow *arg1 = (wxWindow *) 0 ;
33449 bool result;
33450 void *argp1 = 0 ;
33451 int res1 = 0 ;
33452 PyObject *swig_obj[1] ;
33453
33454 if (!args) SWIG_fail;
33455 swig_obj[0] = args;
33456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33459 }
33460 arg1 = reinterpret_cast< wxWindow * >(argp1);
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (bool)(arg1)->TransferDataFromWindow();
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 {
33468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33469 }
33470 return resultobj;
33471 fail:
33472 return NULL;
33473 }
33474
33475
33476 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33477 PyObject *resultobj = 0;
33478 wxWindow *arg1 = (wxWindow *) 0 ;
33479 void *argp1 = 0 ;
33480 int res1 = 0 ;
33481 PyObject *swig_obj[1] ;
33482
33483 if (!args) SWIG_fail;
33484 swig_obj[0] = args;
33485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33486 if (!SWIG_IsOK(res1)) {
33487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33488 }
33489 arg1 = reinterpret_cast< wxWindow * >(argp1);
33490 {
33491 PyThreadState* __tstate = wxPyBeginAllowThreads();
33492 (arg1)->InitDialog();
33493 wxPyEndAllowThreads(__tstate);
33494 if (PyErr_Occurred()) SWIG_fail;
33495 }
33496 resultobj = SWIG_Py_Void();
33497 return resultobj;
33498 fail:
33499 return NULL;
33500 }
33501
33502
33503 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33504 PyObject *resultobj = 0;
33505 wxWindow *arg1 = (wxWindow *) 0 ;
33506 wxAcceleratorTable *arg2 = 0 ;
33507 void *argp1 = 0 ;
33508 int res1 = 0 ;
33509 void *argp2 = 0 ;
33510 int res2 = 0 ;
33511 PyObject * obj0 = 0 ;
33512 PyObject * obj1 = 0 ;
33513 char * kwnames[] = {
33514 (char *) "self",(char *) "accel", NULL
33515 };
33516
33517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33519 if (!SWIG_IsOK(res1)) {
33520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33521 }
33522 arg1 = reinterpret_cast< wxWindow * >(argp1);
33523 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33524 if (!SWIG_IsOK(res2)) {
33525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33526 }
33527 if (!argp2) {
33528 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33529 }
33530 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33531 {
33532 PyThreadState* __tstate = wxPyBeginAllowThreads();
33533 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33534 wxPyEndAllowThreads(__tstate);
33535 if (PyErr_Occurred()) SWIG_fail;
33536 }
33537 resultobj = SWIG_Py_Void();
33538 return resultobj;
33539 fail:
33540 return NULL;
33541 }
33542
33543
33544 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33545 PyObject *resultobj = 0;
33546 wxWindow *arg1 = (wxWindow *) 0 ;
33547 wxAcceleratorTable *result = 0 ;
33548 void *argp1 = 0 ;
33549 int res1 = 0 ;
33550 PyObject *swig_obj[1] ;
33551
33552 if (!args) SWIG_fail;
33553 swig_obj[0] = args;
33554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33555 if (!SWIG_IsOK(res1)) {
33556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33557 }
33558 arg1 = reinterpret_cast< wxWindow * >(argp1);
33559 {
33560 PyThreadState* __tstate = wxPyBeginAllowThreads();
33561 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33562 wxPyEndAllowThreads(__tstate);
33563 if (PyErr_Occurred()) SWIG_fail;
33564 }
33565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33566 return resultobj;
33567 fail:
33568 return NULL;
33569 }
33570
33571
33572 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33573 PyObject *resultobj = 0;
33574 wxWindow *arg1 = (wxWindow *) 0 ;
33575 int arg2 ;
33576 int arg3 ;
33577 int arg4 ;
33578 bool result;
33579 void *argp1 = 0 ;
33580 int res1 = 0 ;
33581 int val2 ;
33582 int ecode2 = 0 ;
33583 int val3 ;
33584 int ecode3 = 0 ;
33585 int val4 ;
33586 int ecode4 = 0 ;
33587 PyObject * obj0 = 0 ;
33588 PyObject * obj1 = 0 ;
33589 PyObject * obj2 = 0 ;
33590 PyObject * obj3 = 0 ;
33591 char * kwnames[] = {
33592 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33593 };
33594
33595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33597 if (!SWIG_IsOK(res1)) {
33598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33599 }
33600 arg1 = reinterpret_cast< wxWindow * >(argp1);
33601 ecode2 = SWIG_AsVal_int(obj1, &val2);
33602 if (!SWIG_IsOK(ecode2)) {
33603 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33604 }
33605 arg2 = static_cast< int >(val2);
33606 ecode3 = SWIG_AsVal_int(obj2, &val3);
33607 if (!SWIG_IsOK(ecode3)) {
33608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33609 }
33610 arg3 = static_cast< int >(val3);
33611 ecode4 = SWIG_AsVal_int(obj3, &val4);
33612 if (!SWIG_IsOK(ecode4)) {
33613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33614 }
33615 arg4 = static_cast< int >(val4);
33616 {
33617 PyThreadState* __tstate = wxPyBeginAllowThreads();
33618 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33619 wxPyEndAllowThreads(__tstate);
33620 if (PyErr_Occurred()) SWIG_fail;
33621 }
33622 {
33623 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33624 }
33625 return resultobj;
33626 fail:
33627 return NULL;
33628 }
33629
33630
33631 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33632 PyObject *resultobj = 0;
33633 wxWindow *arg1 = (wxWindow *) 0 ;
33634 int arg2 ;
33635 bool result;
33636 void *argp1 = 0 ;
33637 int res1 = 0 ;
33638 int val2 ;
33639 int ecode2 = 0 ;
33640 PyObject * obj0 = 0 ;
33641 PyObject * obj1 = 0 ;
33642 char * kwnames[] = {
33643 (char *) "self",(char *) "hotkeyId", NULL
33644 };
33645
33646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33648 if (!SWIG_IsOK(res1)) {
33649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33650 }
33651 arg1 = reinterpret_cast< wxWindow * >(argp1);
33652 ecode2 = SWIG_AsVal_int(obj1, &val2);
33653 if (!SWIG_IsOK(ecode2)) {
33654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33655 }
33656 arg2 = static_cast< int >(val2);
33657 {
33658 PyThreadState* __tstate = wxPyBeginAllowThreads();
33659 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33660 wxPyEndAllowThreads(__tstate);
33661 if (PyErr_Occurred()) SWIG_fail;
33662 }
33663 {
33664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33665 }
33666 return resultobj;
33667 fail:
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33673 PyObject *resultobj = 0;
33674 wxWindow *arg1 = (wxWindow *) 0 ;
33675 wxPoint *arg2 = 0 ;
33676 wxPoint result;
33677 void *argp1 = 0 ;
33678 int res1 = 0 ;
33679 wxPoint temp2 ;
33680 PyObject * obj0 = 0 ;
33681 PyObject * obj1 = 0 ;
33682 char * kwnames[] = {
33683 (char *) "self",(char *) "pt", NULL
33684 };
33685
33686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33690 }
33691 arg1 = reinterpret_cast< wxWindow * >(argp1);
33692 {
33693 arg2 = &temp2;
33694 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33695 }
33696 {
33697 PyThreadState* __tstate = wxPyBeginAllowThreads();
33698 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33699 wxPyEndAllowThreads(__tstate);
33700 if (PyErr_Occurred()) SWIG_fail;
33701 }
33702 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33703 return resultobj;
33704 fail:
33705 return NULL;
33706 }
33707
33708
33709 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33710 PyObject *resultobj = 0;
33711 wxWindow *arg1 = (wxWindow *) 0 ;
33712 wxSize *arg2 = 0 ;
33713 wxSize result;
33714 void *argp1 = 0 ;
33715 int res1 = 0 ;
33716 wxSize temp2 ;
33717 PyObject * obj0 = 0 ;
33718 PyObject * obj1 = 0 ;
33719 char * kwnames[] = {
33720 (char *) "self",(char *) "sz", NULL
33721 };
33722
33723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33725 if (!SWIG_IsOK(res1)) {
33726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33727 }
33728 arg1 = reinterpret_cast< wxWindow * >(argp1);
33729 {
33730 arg2 = &temp2;
33731 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33732 }
33733 {
33734 PyThreadState* __tstate = wxPyBeginAllowThreads();
33735 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33736 wxPyEndAllowThreads(__tstate);
33737 if (PyErr_Occurred()) SWIG_fail;
33738 }
33739 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33740 return resultobj;
33741 fail:
33742 return NULL;
33743 }
33744
33745
33746 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33747 PyObject *resultobj = 0;
33748 wxWindow *arg1 = (wxWindow *) 0 ;
33749 wxPoint *arg2 = 0 ;
33750 wxPoint result;
33751 void *argp1 = 0 ;
33752 int res1 = 0 ;
33753 wxPoint temp2 ;
33754 PyObject * obj0 = 0 ;
33755 PyObject * obj1 = 0 ;
33756 char * kwnames[] = {
33757 (char *) "self",(char *) "pt", NULL
33758 };
33759
33760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33762 if (!SWIG_IsOK(res1)) {
33763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33764 }
33765 arg1 = reinterpret_cast< wxWindow * >(argp1);
33766 {
33767 arg2 = &temp2;
33768 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33769 }
33770 {
33771 PyThreadState* __tstate = wxPyBeginAllowThreads();
33772 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33773 wxPyEndAllowThreads(__tstate);
33774 if (PyErr_Occurred()) SWIG_fail;
33775 }
33776 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33777 return resultobj;
33778 fail:
33779 return NULL;
33780 }
33781
33782
33783 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33784 PyObject *resultobj = 0;
33785 wxWindow *arg1 = (wxWindow *) 0 ;
33786 wxSize *arg2 = 0 ;
33787 wxSize result;
33788 void *argp1 = 0 ;
33789 int res1 = 0 ;
33790 wxSize temp2 ;
33791 PyObject * obj0 = 0 ;
33792 PyObject * obj1 = 0 ;
33793 char * kwnames[] = {
33794 (char *) "self",(char *) "sz", NULL
33795 };
33796
33797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
33798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
33801 }
33802 arg1 = reinterpret_cast< wxWindow * >(argp1);
33803 {
33804 arg2 = &temp2;
33805 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33806 }
33807 {
33808 PyThreadState* __tstate = wxPyBeginAllowThreads();
33809 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33810 wxPyEndAllowThreads(__tstate);
33811 if (PyErr_Occurred()) SWIG_fail;
33812 }
33813 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33814 return resultobj;
33815 fail:
33816 return NULL;
33817 }
33818
33819
33820 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33821 PyObject *resultobj = 0;
33822 wxWindow *arg1 = (wxWindow *) 0 ;
33823 wxPoint *arg2 = 0 ;
33824 wxPoint result;
33825 void *argp1 = 0 ;
33826 int res1 = 0 ;
33827 wxPoint temp2 ;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 char * kwnames[] = {
33831 (char *) "self",(char *) "pt", NULL
33832 };
33833
33834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33836 if (!SWIG_IsOK(res1)) {
33837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33838 }
33839 arg1 = reinterpret_cast< wxWindow * >(argp1);
33840 {
33841 arg2 = &temp2;
33842 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33843 }
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33858 PyObject *resultobj = 0;
33859 wxWindow *arg1 = (wxWindow *) 0 ;
33860 wxSize *arg2 = 0 ;
33861 wxSize result;
33862 void *argp1 = 0 ;
33863 int res1 = 0 ;
33864 wxSize temp2 ;
33865 PyObject * obj0 = 0 ;
33866 PyObject * obj1 = 0 ;
33867 char * kwnames[] = {
33868 (char *) "self",(char *) "sz", NULL
33869 };
33870
33871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
33872 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33873 if (!SWIG_IsOK(res1)) {
33874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33875 }
33876 arg1 = reinterpret_cast< wxWindow * >(argp1);
33877 {
33878 arg2 = &temp2;
33879 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33880 }
33881 {
33882 PyThreadState* __tstate = wxPyBeginAllowThreads();
33883 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
33884 wxPyEndAllowThreads(__tstate);
33885 if (PyErr_Occurred()) SWIG_fail;
33886 }
33887 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33888 return resultobj;
33889 fail:
33890 return NULL;
33891 }
33892
33893
33894 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33895 PyObject *resultobj = 0;
33896 wxWindow *arg1 = (wxWindow *) 0 ;
33897 int arg2 ;
33898 int arg3 ;
33899 void *argp1 = 0 ;
33900 int res1 = 0 ;
33901 int val2 ;
33902 int ecode2 = 0 ;
33903 int val3 ;
33904 int ecode3 = 0 ;
33905 PyObject * obj0 = 0 ;
33906 PyObject * obj1 = 0 ;
33907 PyObject * obj2 = 0 ;
33908 char * kwnames[] = {
33909 (char *) "self",(char *) "x",(char *) "y", NULL
33910 };
33911
33912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33914 if (!SWIG_IsOK(res1)) {
33915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
33916 }
33917 arg1 = reinterpret_cast< wxWindow * >(argp1);
33918 ecode2 = SWIG_AsVal_int(obj1, &val2);
33919 if (!SWIG_IsOK(ecode2)) {
33920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
33921 }
33922 arg2 = static_cast< int >(val2);
33923 ecode3 = SWIG_AsVal_int(obj2, &val3);
33924 if (!SWIG_IsOK(ecode3)) {
33925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
33926 }
33927 arg3 = static_cast< int >(val3);
33928 {
33929 PyThreadState* __tstate = wxPyBeginAllowThreads();
33930 (arg1)->WarpPointer(arg2,arg3);
33931 wxPyEndAllowThreads(__tstate);
33932 if (PyErr_Occurred()) SWIG_fail;
33933 }
33934 resultobj = SWIG_Py_Void();
33935 return resultobj;
33936 fail:
33937 return NULL;
33938 }
33939
33940
33941 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33942 PyObject *resultobj = 0;
33943 wxWindow *arg1 = (wxWindow *) 0 ;
33944 void *argp1 = 0 ;
33945 int res1 = 0 ;
33946 PyObject *swig_obj[1] ;
33947
33948 if (!args) SWIG_fail;
33949 swig_obj[0] = args;
33950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33951 if (!SWIG_IsOK(res1)) {
33952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33953 }
33954 arg1 = reinterpret_cast< wxWindow * >(argp1);
33955 {
33956 PyThreadState* __tstate = wxPyBeginAllowThreads();
33957 (arg1)->CaptureMouse();
33958 wxPyEndAllowThreads(__tstate);
33959 if (PyErr_Occurred()) SWIG_fail;
33960 }
33961 resultobj = SWIG_Py_Void();
33962 return resultobj;
33963 fail:
33964 return NULL;
33965 }
33966
33967
33968 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33969 PyObject *resultobj = 0;
33970 wxWindow *arg1 = (wxWindow *) 0 ;
33971 void *argp1 = 0 ;
33972 int res1 = 0 ;
33973 PyObject *swig_obj[1] ;
33974
33975 if (!args) SWIG_fail;
33976 swig_obj[0] = args;
33977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33978 if (!SWIG_IsOK(res1)) {
33979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
33980 }
33981 arg1 = reinterpret_cast< wxWindow * >(argp1);
33982 {
33983 PyThreadState* __tstate = wxPyBeginAllowThreads();
33984 (arg1)->ReleaseMouse();
33985 wxPyEndAllowThreads(__tstate);
33986 if (PyErr_Occurred()) SWIG_fail;
33987 }
33988 resultobj = SWIG_Py_Void();
33989 return resultobj;
33990 fail:
33991 return NULL;
33992 }
33993
33994
33995 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33996 PyObject *resultobj = 0;
33997 wxWindow *result = 0 ;
33998
33999 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34000 {
34001 if (!wxPyCheckForApp()) SWIG_fail;
34002 PyThreadState* __tstate = wxPyBeginAllowThreads();
34003 result = (wxWindow *)wxWindow::GetCapture();
34004 wxPyEndAllowThreads(__tstate);
34005 if (PyErr_Occurred()) SWIG_fail;
34006 }
34007 {
34008 resultobj = wxPyMake_wxObject(result, 0);
34009 }
34010 return resultobj;
34011 fail:
34012 return NULL;
34013 }
34014
34015
34016 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34017 PyObject *resultobj = 0;
34018 wxWindow *arg1 = (wxWindow *) 0 ;
34019 bool result;
34020 void *argp1 = 0 ;
34021 int res1 = 0 ;
34022 PyObject *swig_obj[1] ;
34023
34024 if (!args) SWIG_fail;
34025 swig_obj[0] = args;
34026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34027 if (!SWIG_IsOK(res1)) {
34028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34029 }
34030 arg1 = reinterpret_cast< wxWindow * >(argp1);
34031 {
34032 PyThreadState* __tstate = wxPyBeginAllowThreads();
34033 result = (bool)((wxWindow const *)arg1)->HasCapture();
34034 wxPyEndAllowThreads(__tstate);
34035 if (PyErr_Occurred()) SWIG_fail;
34036 }
34037 {
34038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34039 }
34040 return resultobj;
34041 fail:
34042 return NULL;
34043 }
34044
34045
34046 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34047 PyObject *resultobj = 0;
34048 wxWindow *arg1 = (wxWindow *) 0 ;
34049 bool arg2 = (bool) true ;
34050 wxRect *arg3 = (wxRect *) NULL ;
34051 void *argp1 = 0 ;
34052 int res1 = 0 ;
34053 bool val2 ;
34054 int ecode2 = 0 ;
34055 void *argp3 = 0 ;
34056 int res3 = 0 ;
34057 PyObject * obj0 = 0 ;
34058 PyObject * obj1 = 0 ;
34059 PyObject * obj2 = 0 ;
34060 char * kwnames[] = {
34061 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34062 };
34063
34064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34066 if (!SWIG_IsOK(res1)) {
34067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34068 }
34069 arg1 = reinterpret_cast< wxWindow * >(argp1);
34070 if (obj1) {
34071 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34072 if (!SWIG_IsOK(ecode2)) {
34073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34074 }
34075 arg2 = static_cast< bool >(val2);
34076 }
34077 if (obj2) {
34078 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34079 if (!SWIG_IsOK(res3)) {
34080 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34081 }
34082 arg3 = reinterpret_cast< wxRect * >(argp3);
34083 }
34084 {
34085 PyThreadState* __tstate = wxPyBeginAllowThreads();
34086 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34087 wxPyEndAllowThreads(__tstate);
34088 if (PyErr_Occurred()) SWIG_fail;
34089 }
34090 resultobj = SWIG_Py_Void();
34091 return resultobj;
34092 fail:
34093 return NULL;
34094 }
34095
34096
34097 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34098 PyObject *resultobj = 0;
34099 wxWindow *arg1 = (wxWindow *) 0 ;
34100 wxRect *arg2 = 0 ;
34101 bool arg3 = (bool) true ;
34102 void *argp1 = 0 ;
34103 int res1 = 0 ;
34104 wxRect temp2 ;
34105 bool val3 ;
34106 int ecode3 = 0 ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 PyObject * obj2 = 0 ;
34110 char * kwnames[] = {
34111 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34112 };
34113
34114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 {
34121 arg2 = &temp2;
34122 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34123 }
34124 if (obj2) {
34125 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34126 if (!SWIG_IsOK(ecode3)) {
34127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34128 }
34129 arg3 = static_cast< bool >(val3);
34130 }
34131 {
34132 PyThreadState* __tstate = wxPyBeginAllowThreads();
34133 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 resultobj = SWIG_Py_Void();
34138 return resultobj;
34139 fail:
34140 return NULL;
34141 }
34142
34143
34144 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34145 PyObject *resultobj = 0;
34146 wxWindow *arg1 = (wxWindow *) 0 ;
34147 void *argp1 = 0 ;
34148 int res1 = 0 ;
34149 PyObject *swig_obj[1] ;
34150
34151 if (!args) SWIG_fail;
34152 swig_obj[0] = args;
34153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34154 if (!SWIG_IsOK(res1)) {
34155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34156 }
34157 arg1 = reinterpret_cast< wxWindow * >(argp1);
34158 {
34159 PyThreadState* __tstate = wxPyBeginAllowThreads();
34160 (arg1)->Update();
34161 wxPyEndAllowThreads(__tstate);
34162 if (PyErr_Occurred()) SWIG_fail;
34163 }
34164 resultobj = SWIG_Py_Void();
34165 return resultobj;
34166 fail:
34167 return NULL;
34168 }
34169
34170
34171 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34172 PyObject *resultobj = 0;
34173 wxWindow *arg1 = (wxWindow *) 0 ;
34174 void *argp1 = 0 ;
34175 int res1 = 0 ;
34176 PyObject *swig_obj[1] ;
34177
34178 if (!args) SWIG_fail;
34179 swig_obj[0] = args;
34180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34181 if (!SWIG_IsOK(res1)) {
34182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34183 }
34184 arg1 = reinterpret_cast< wxWindow * >(argp1);
34185 {
34186 PyThreadState* __tstate = wxPyBeginAllowThreads();
34187 (arg1)->ClearBackground();
34188 wxPyEndAllowThreads(__tstate);
34189 if (PyErr_Occurred()) SWIG_fail;
34190 }
34191 resultobj = SWIG_Py_Void();
34192 return resultobj;
34193 fail:
34194 return NULL;
34195 }
34196
34197
34198 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34199 PyObject *resultobj = 0;
34200 wxWindow *arg1 = (wxWindow *) 0 ;
34201 void *argp1 = 0 ;
34202 int res1 = 0 ;
34203 PyObject *swig_obj[1] ;
34204
34205 if (!args) SWIG_fail;
34206 swig_obj[0] = args;
34207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34208 if (!SWIG_IsOK(res1)) {
34209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34210 }
34211 arg1 = reinterpret_cast< wxWindow * >(argp1);
34212 {
34213 PyThreadState* __tstate = wxPyBeginAllowThreads();
34214 (arg1)->Freeze();
34215 wxPyEndAllowThreads(__tstate);
34216 if (PyErr_Occurred()) SWIG_fail;
34217 }
34218 resultobj = SWIG_Py_Void();
34219 return resultobj;
34220 fail:
34221 return NULL;
34222 }
34223
34224
34225 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34226 PyObject *resultobj = 0;
34227 wxWindow *arg1 = (wxWindow *) 0 ;
34228 void *argp1 = 0 ;
34229 int res1 = 0 ;
34230 PyObject *swig_obj[1] ;
34231
34232 if (!args) SWIG_fail;
34233 swig_obj[0] = args;
34234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34235 if (!SWIG_IsOK(res1)) {
34236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34237 }
34238 arg1 = reinterpret_cast< wxWindow * >(argp1);
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 (arg1)->Thaw();
34242 wxPyEndAllowThreads(__tstate);
34243 if (PyErr_Occurred()) SWIG_fail;
34244 }
34245 resultobj = SWIG_Py_Void();
34246 return resultobj;
34247 fail:
34248 return NULL;
34249 }
34250
34251
34252 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34253 PyObject *resultobj = 0;
34254 wxWindow *arg1 = (wxWindow *) 0 ;
34255 wxDC *arg2 = 0 ;
34256 void *argp1 = 0 ;
34257 int res1 = 0 ;
34258 void *argp2 = 0 ;
34259 int res2 = 0 ;
34260 PyObject * obj0 = 0 ;
34261 PyObject * obj1 = 0 ;
34262 char * kwnames[] = {
34263 (char *) "self",(char *) "dc", NULL
34264 };
34265
34266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34268 if (!SWIG_IsOK(res1)) {
34269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34270 }
34271 arg1 = reinterpret_cast< wxWindow * >(argp1);
34272 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34273 if (!SWIG_IsOK(res2)) {
34274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34275 }
34276 if (!argp2) {
34277 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34278 }
34279 arg2 = reinterpret_cast< wxDC * >(argp2);
34280 {
34281 PyThreadState* __tstate = wxPyBeginAllowThreads();
34282 (arg1)->PrepareDC(*arg2);
34283 wxPyEndAllowThreads(__tstate);
34284 if (PyErr_Occurred()) SWIG_fail;
34285 }
34286 resultobj = SWIG_Py_Void();
34287 return resultobj;
34288 fail:
34289 return NULL;
34290 }
34291
34292
34293 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34294 PyObject *resultobj = 0;
34295 wxWindow *arg1 = (wxWindow *) 0 ;
34296 wxRegion *result = 0 ;
34297 void *argp1 = 0 ;
34298 int res1 = 0 ;
34299 PyObject *swig_obj[1] ;
34300
34301 if (!args) SWIG_fail;
34302 swig_obj[0] = args;
34303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34304 if (!SWIG_IsOK(res1)) {
34305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34306 }
34307 arg1 = reinterpret_cast< wxWindow * >(argp1);
34308 {
34309 PyThreadState* __tstate = wxPyBeginAllowThreads();
34310 {
34311 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34312 result = (wxRegion *) &_result_ref;
34313 }
34314 wxPyEndAllowThreads(__tstate);
34315 if (PyErr_Occurred()) SWIG_fail;
34316 }
34317 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34318 return resultobj;
34319 fail:
34320 return NULL;
34321 }
34322
34323
34324 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34325 PyObject *resultobj = 0;
34326 wxWindow *arg1 = (wxWindow *) 0 ;
34327 wxRect result;
34328 void *argp1 = 0 ;
34329 int res1 = 0 ;
34330 PyObject *swig_obj[1] ;
34331
34332 if (!args) SWIG_fail;
34333 swig_obj[0] = args;
34334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34335 if (!SWIG_IsOK(res1)) {
34336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34337 }
34338 arg1 = reinterpret_cast< wxWindow * >(argp1);
34339 {
34340 PyThreadState* __tstate = wxPyBeginAllowThreads();
34341 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34342 wxPyEndAllowThreads(__tstate);
34343 if (PyErr_Occurred()) SWIG_fail;
34344 }
34345 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34346 return resultobj;
34347 fail:
34348 return NULL;
34349 }
34350
34351
34352 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34353 PyObject *resultobj = 0;
34354 wxWindow *arg1 = (wxWindow *) 0 ;
34355 int arg2 ;
34356 int arg3 ;
34357 int arg4 = (int) 1 ;
34358 int arg5 = (int) 1 ;
34359 bool result;
34360 void *argp1 = 0 ;
34361 int res1 = 0 ;
34362 int val2 ;
34363 int ecode2 = 0 ;
34364 int val3 ;
34365 int ecode3 = 0 ;
34366 int val4 ;
34367 int ecode4 = 0 ;
34368 int val5 ;
34369 int ecode5 = 0 ;
34370 PyObject * obj0 = 0 ;
34371 PyObject * obj1 = 0 ;
34372 PyObject * obj2 = 0 ;
34373 PyObject * obj3 = 0 ;
34374 PyObject * obj4 = 0 ;
34375 char * kwnames[] = {
34376 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34377 };
34378
34379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34381 if (!SWIG_IsOK(res1)) {
34382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34383 }
34384 arg1 = reinterpret_cast< wxWindow * >(argp1);
34385 ecode2 = SWIG_AsVal_int(obj1, &val2);
34386 if (!SWIG_IsOK(ecode2)) {
34387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34388 }
34389 arg2 = static_cast< int >(val2);
34390 ecode3 = SWIG_AsVal_int(obj2, &val3);
34391 if (!SWIG_IsOK(ecode3)) {
34392 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34393 }
34394 arg3 = static_cast< int >(val3);
34395 if (obj3) {
34396 ecode4 = SWIG_AsVal_int(obj3, &val4);
34397 if (!SWIG_IsOK(ecode4)) {
34398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34399 }
34400 arg4 = static_cast< int >(val4);
34401 }
34402 if (obj4) {
34403 ecode5 = SWIG_AsVal_int(obj4, &val5);
34404 if (!SWIG_IsOK(ecode5)) {
34405 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34406 }
34407 arg5 = static_cast< int >(val5);
34408 }
34409 {
34410 PyThreadState* __tstate = wxPyBeginAllowThreads();
34411 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34412 wxPyEndAllowThreads(__tstate);
34413 if (PyErr_Occurred()) SWIG_fail;
34414 }
34415 {
34416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34417 }
34418 return resultobj;
34419 fail:
34420 return NULL;
34421 }
34422
34423
34424 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34425 PyObject *resultobj = 0;
34426 wxWindow *arg1 = (wxWindow *) 0 ;
34427 wxPoint *arg2 = 0 ;
34428 bool result;
34429 void *argp1 = 0 ;
34430 int res1 = 0 ;
34431 wxPoint temp2 ;
34432 PyObject * obj0 = 0 ;
34433 PyObject * obj1 = 0 ;
34434 char * kwnames[] = {
34435 (char *) "self",(char *) "pt", NULL
34436 };
34437
34438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34440 if (!SWIG_IsOK(res1)) {
34441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34442 }
34443 arg1 = reinterpret_cast< wxWindow * >(argp1);
34444 {
34445 arg2 = &temp2;
34446 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34447 }
34448 {
34449 PyThreadState* __tstate = wxPyBeginAllowThreads();
34450 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34451 wxPyEndAllowThreads(__tstate);
34452 if (PyErr_Occurred()) SWIG_fail;
34453 }
34454 {
34455 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34456 }
34457 return resultobj;
34458 fail:
34459 return NULL;
34460 }
34461
34462
34463 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34464 PyObject *resultobj = 0;
34465 wxWindow *arg1 = (wxWindow *) 0 ;
34466 wxRect *arg2 = 0 ;
34467 bool result;
34468 void *argp1 = 0 ;
34469 int res1 = 0 ;
34470 wxRect temp2 ;
34471 PyObject * obj0 = 0 ;
34472 PyObject * obj1 = 0 ;
34473 char * kwnames[] = {
34474 (char *) "self",(char *) "rect", NULL
34475 };
34476
34477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34478 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34479 if (!SWIG_IsOK(res1)) {
34480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34481 }
34482 arg1 = reinterpret_cast< wxWindow * >(argp1);
34483 {
34484 arg2 = &temp2;
34485 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34486 }
34487 {
34488 PyThreadState* __tstate = wxPyBeginAllowThreads();
34489 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34490 wxPyEndAllowThreads(__tstate);
34491 if (PyErr_Occurred()) SWIG_fail;
34492 }
34493 {
34494 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34495 }
34496 return resultobj;
34497 fail:
34498 return NULL;
34499 }
34500
34501
34502 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34503 PyObject *resultobj = 0;
34504 wxWindow *arg1 = (wxWindow *) 0 ;
34505 SwigValueWrapper<wxVisualAttributes > result;
34506 void *argp1 = 0 ;
34507 int res1 = 0 ;
34508 PyObject *swig_obj[1] ;
34509
34510 if (!args) SWIG_fail;
34511 swig_obj[0] = args;
34512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34513 if (!SWIG_IsOK(res1)) {
34514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34515 }
34516 arg1 = reinterpret_cast< wxWindow * >(argp1);
34517 {
34518 PyThreadState* __tstate = wxPyBeginAllowThreads();
34519 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34524 return resultobj;
34525 fail:
34526 return NULL;
34527 }
34528
34529
34530 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34531 PyObject *resultobj = 0;
34532 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34533 SwigValueWrapper<wxVisualAttributes > result;
34534 int val1 ;
34535 int ecode1 = 0 ;
34536 PyObject * obj0 = 0 ;
34537 char * kwnames[] = {
34538 (char *) "variant", NULL
34539 };
34540
34541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34542 if (obj0) {
34543 ecode1 = SWIG_AsVal_int(obj0, &val1);
34544 if (!SWIG_IsOK(ecode1)) {
34545 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34546 }
34547 arg1 = static_cast< wxWindowVariant >(val1);
34548 }
34549 {
34550 if (!wxPyCheckForApp()) SWIG_fail;
34551 PyThreadState* __tstate = wxPyBeginAllowThreads();
34552 result = wxWindow::GetClassDefaultAttributes(arg1);
34553 wxPyEndAllowThreads(__tstate);
34554 if (PyErr_Occurred()) SWIG_fail;
34555 }
34556 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34557 return resultobj;
34558 fail:
34559 return NULL;
34560 }
34561
34562
34563 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34564 PyObject *resultobj = 0;
34565 wxWindow *arg1 = (wxWindow *) 0 ;
34566 wxColour *arg2 = 0 ;
34567 bool result;
34568 void *argp1 = 0 ;
34569 int res1 = 0 ;
34570 wxColour temp2 ;
34571 PyObject * obj0 = 0 ;
34572 PyObject * obj1 = 0 ;
34573 char * kwnames[] = {
34574 (char *) "self",(char *) "colour", NULL
34575 };
34576
34577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34579 if (!SWIG_IsOK(res1)) {
34580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34581 }
34582 arg1 = reinterpret_cast< wxWindow * >(argp1);
34583 {
34584 arg2 = &temp2;
34585 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34586 }
34587 {
34588 PyThreadState* __tstate = wxPyBeginAllowThreads();
34589 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34590 wxPyEndAllowThreads(__tstate);
34591 if (PyErr_Occurred()) SWIG_fail;
34592 }
34593 {
34594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34595 }
34596 return resultobj;
34597 fail:
34598 return NULL;
34599 }
34600
34601
34602 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34603 PyObject *resultobj = 0;
34604 wxWindow *arg1 = (wxWindow *) 0 ;
34605 wxColour *arg2 = 0 ;
34606 void *argp1 = 0 ;
34607 int res1 = 0 ;
34608 wxColour temp2 ;
34609 PyObject * obj0 = 0 ;
34610 PyObject * obj1 = 0 ;
34611 char * kwnames[] = {
34612 (char *) "self",(char *) "colour", NULL
34613 };
34614
34615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34617 if (!SWIG_IsOK(res1)) {
34618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34619 }
34620 arg1 = reinterpret_cast< wxWindow * >(argp1);
34621 {
34622 arg2 = &temp2;
34623 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34624 }
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 resultobj = SWIG_Py_Void();
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj = 0;
34640 wxWindow *arg1 = (wxWindow *) 0 ;
34641 wxColour *arg2 = 0 ;
34642 bool result;
34643 void *argp1 = 0 ;
34644 int res1 = 0 ;
34645 wxColour temp2 ;
34646 PyObject * obj0 = 0 ;
34647 PyObject * obj1 = 0 ;
34648 char * kwnames[] = {
34649 (char *) "self",(char *) "colour", NULL
34650 };
34651
34652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34654 if (!SWIG_IsOK(res1)) {
34655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34656 }
34657 arg1 = reinterpret_cast< wxWindow * >(argp1);
34658 {
34659 arg2 = &temp2;
34660 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34661 }
34662 {
34663 PyThreadState* __tstate = wxPyBeginAllowThreads();
34664 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34665 wxPyEndAllowThreads(__tstate);
34666 if (PyErr_Occurred()) SWIG_fail;
34667 }
34668 {
34669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34670 }
34671 return resultobj;
34672 fail:
34673 return NULL;
34674 }
34675
34676
34677 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34678 PyObject *resultobj = 0;
34679 wxWindow *arg1 = (wxWindow *) 0 ;
34680 wxColour *arg2 = 0 ;
34681 void *argp1 = 0 ;
34682 int res1 = 0 ;
34683 wxColour temp2 ;
34684 PyObject * obj0 = 0 ;
34685 PyObject * obj1 = 0 ;
34686 char * kwnames[] = {
34687 (char *) "self",(char *) "colour", NULL
34688 };
34689
34690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34692 if (!SWIG_IsOK(res1)) {
34693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34694 }
34695 arg1 = reinterpret_cast< wxWindow * >(argp1);
34696 {
34697 arg2 = &temp2;
34698 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34699 }
34700 {
34701 PyThreadState* __tstate = wxPyBeginAllowThreads();
34702 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34703 wxPyEndAllowThreads(__tstate);
34704 if (PyErr_Occurred()) SWIG_fail;
34705 }
34706 resultobj = SWIG_Py_Void();
34707 return resultobj;
34708 fail:
34709 return NULL;
34710 }
34711
34712
34713 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34714 PyObject *resultobj = 0;
34715 wxWindow *arg1 = (wxWindow *) 0 ;
34716 wxColour result;
34717 void *argp1 = 0 ;
34718 int res1 = 0 ;
34719 PyObject *swig_obj[1] ;
34720
34721 if (!args) SWIG_fail;
34722 swig_obj[0] = args;
34723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34724 if (!SWIG_IsOK(res1)) {
34725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34726 }
34727 arg1 = reinterpret_cast< wxWindow * >(argp1);
34728 {
34729 PyThreadState* __tstate = wxPyBeginAllowThreads();
34730 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34735 return resultobj;
34736 fail:
34737 return NULL;
34738 }
34739
34740
34741 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34742 PyObject *resultobj = 0;
34743 wxWindow *arg1 = (wxWindow *) 0 ;
34744 wxColour result;
34745 void *argp1 = 0 ;
34746 int res1 = 0 ;
34747 PyObject *swig_obj[1] ;
34748
34749 if (!args) SWIG_fail;
34750 swig_obj[0] = args;
34751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34752 if (!SWIG_IsOK(res1)) {
34753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34754 }
34755 arg1 = reinterpret_cast< wxWindow * >(argp1);
34756 {
34757 PyThreadState* __tstate = wxPyBeginAllowThreads();
34758 result = ((wxWindow const *)arg1)->GetForegroundColour();
34759 wxPyEndAllowThreads(__tstate);
34760 if (PyErr_Occurred()) SWIG_fail;
34761 }
34762 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34770 PyObject *resultobj = 0;
34771 wxWindow *arg1 = (wxWindow *) 0 ;
34772 bool result;
34773 void *argp1 = 0 ;
34774 int res1 = 0 ;
34775 PyObject *swig_obj[1] ;
34776
34777 if (!args) SWIG_fail;
34778 swig_obj[0] = args;
34779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34780 if (!SWIG_IsOK(res1)) {
34781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34782 }
34783 arg1 = reinterpret_cast< wxWindow * >(argp1);
34784 {
34785 PyThreadState* __tstate = wxPyBeginAllowThreads();
34786 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34787 wxPyEndAllowThreads(__tstate);
34788 if (PyErr_Occurred()) SWIG_fail;
34789 }
34790 {
34791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34792 }
34793 return resultobj;
34794 fail:
34795 return NULL;
34796 }
34797
34798
34799 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34800 PyObject *resultobj = 0;
34801 wxWindow *arg1 = (wxWindow *) 0 ;
34802 bool result;
34803 void *argp1 = 0 ;
34804 int res1 = 0 ;
34805 PyObject *swig_obj[1] ;
34806
34807 if (!args) SWIG_fail;
34808 swig_obj[0] = args;
34809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34810 if (!SWIG_IsOK(res1)) {
34811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
34812 }
34813 arg1 = reinterpret_cast< wxWindow * >(argp1);
34814 {
34815 PyThreadState* __tstate = wxPyBeginAllowThreads();
34816 result = (bool)((wxWindow const *)arg1)->UseBgCol();
34817 wxPyEndAllowThreads(__tstate);
34818 if (PyErr_Occurred()) SWIG_fail;
34819 }
34820 {
34821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34822 }
34823 return resultobj;
34824 fail:
34825 return NULL;
34826 }
34827
34828
34829 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34830 PyObject *resultobj = 0;
34831 wxWindow *arg1 = (wxWindow *) 0 ;
34832 wxBackgroundStyle arg2 ;
34833 bool result;
34834 void *argp1 = 0 ;
34835 int res1 = 0 ;
34836 int val2 ;
34837 int ecode2 = 0 ;
34838 PyObject * obj0 = 0 ;
34839 PyObject * obj1 = 0 ;
34840 char * kwnames[] = {
34841 (char *) "self",(char *) "style", NULL
34842 };
34843
34844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
34845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34846 if (!SWIG_IsOK(res1)) {
34847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
34848 }
34849 arg1 = reinterpret_cast< wxWindow * >(argp1);
34850 ecode2 = SWIG_AsVal_int(obj1, &val2);
34851 if (!SWIG_IsOK(ecode2)) {
34852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
34853 }
34854 arg2 = static_cast< wxBackgroundStyle >(val2);
34855 {
34856 PyThreadState* __tstate = wxPyBeginAllowThreads();
34857 result = (bool)(arg1)->SetBackgroundStyle(arg2);
34858 wxPyEndAllowThreads(__tstate);
34859 if (PyErr_Occurred()) SWIG_fail;
34860 }
34861 {
34862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34863 }
34864 return resultobj;
34865 fail:
34866 return NULL;
34867 }
34868
34869
34870 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34871 PyObject *resultobj = 0;
34872 wxWindow *arg1 = (wxWindow *) 0 ;
34873 wxBackgroundStyle result;
34874 void *argp1 = 0 ;
34875 int res1 = 0 ;
34876 PyObject *swig_obj[1] ;
34877
34878 if (!args) SWIG_fail;
34879 swig_obj[0] = args;
34880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34881 if (!SWIG_IsOK(res1)) {
34882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
34883 }
34884 arg1 = reinterpret_cast< wxWindow * >(argp1);
34885 {
34886 PyThreadState* __tstate = wxPyBeginAllowThreads();
34887 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
34888 wxPyEndAllowThreads(__tstate);
34889 if (PyErr_Occurred()) SWIG_fail;
34890 }
34891 resultobj = SWIG_From_int(static_cast< int >(result));
34892 return resultobj;
34893 fail:
34894 return NULL;
34895 }
34896
34897
34898 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34899 PyObject *resultobj = 0;
34900 wxWindow *arg1 = (wxWindow *) 0 ;
34901 bool result;
34902 void *argp1 = 0 ;
34903 int res1 = 0 ;
34904 PyObject *swig_obj[1] ;
34905
34906 if (!args) SWIG_fail;
34907 swig_obj[0] = args;
34908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34909 if (!SWIG_IsOK(res1)) {
34910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34911 }
34912 arg1 = reinterpret_cast< wxWindow * >(argp1);
34913 {
34914 PyThreadState* __tstate = wxPyBeginAllowThreads();
34915 result = (bool)(arg1)->HasTransparentBackground();
34916 wxPyEndAllowThreads(__tstate);
34917 if (PyErr_Occurred()) SWIG_fail;
34918 }
34919 {
34920 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34921 }
34922 return resultobj;
34923 fail:
34924 return NULL;
34925 }
34926
34927
34928 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34929 PyObject *resultobj = 0;
34930 wxWindow *arg1 = (wxWindow *) 0 ;
34931 wxCursor *arg2 = 0 ;
34932 bool result;
34933 void *argp1 = 0 ;
34934 int res1 = 0 ;
34935 void *argp2 = 0 ;
34936 int res2 = 0 ;
34937 PyObject * obj0 = 0 ;
34938 PyObject * obj1 = 0 ;
34939 char * kwnames[] = {
34940 (char *) "self",(char *) "cursor", NULL
34941 };
34942
34943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
34944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34945 if (!SWIG_IsOK(res1)) {
34946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34947 }
34948 arg1 = reinterpret_cast< wxWindow * >(argp1);
34949 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
34950 if (!SWIG_IsOK(res2)) {
34951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34952 }
34953 if (!argp2) {
34954 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
34955 }
34956 arg2 = reinterpret_cast< wxCursor * >(argp2);
34957 {
34958 PyThreadState* __tstate = wxPyBeginAllowThreads();
34959 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
34960 wxPyEndAllowThreads(__tstate);
34961 if (PyErr_Occurred()) SWIG_fail;
34962 }
34963 {
34964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34965 }
34966 return resultobj;
34967 fail:
34968 return NULL;
34969 }
34970
34971
34972 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34973 PyObject *resultobj = 0;
34974 wxWindow *arg1 = (wxWindow *) 0 ;
34975 wxCursor result;
34976 void *argp1 = 0 ;
34977 int res1 = 0 ;
34978 PyObject *swig_obj[1] ;
34979
34980 if (!args) SWIG_fail;
34981 swig_obj[0] = args;
34982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34983 if (!SWIG_IsOK(res1)) {
34984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
34985 }
34986 arg1 = reinterpret_cast< wxWindow * >(argp1);
34987 {
34988 PyThreadState* __tstate = wxPyBeginAllowThreads();
34989 result = (arg1)->GetCursor();
34990 wxPyEndAllowThreads(__tstate);
34991 if (PyErr_Occurred()) SWIG_fail;
34992 }
34993 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
34994 return resultobj;
34995 fail:
34996 return NULL;
34997 }
34998
34999
35000 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35001 PyObject *resultobj = 0;
35002 wxWindow *arg1 = (wxWindow *) 0 ;
35003 wxFont *arg2 = 0 ;
35004 bool result;
35005 void *argp1 = 0 ;
35006 int res1 = 0 ;
35007 void *argp2 = 0 ;
35008 int res2 = 0 ;
35009 PyObject * obj0 = 0 ;
35010 PyObject * obj1 = 0 ;
35011 char * kwnames[] = {
35012 (char *) "self",(char *) "font", NULL
35013 };
35014
35015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35017 if (!SWIG_IsOK(res1)) {
35018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35019 }
35020 arg1 = reinterpret_cast< wxWindow * >(argp1);
35021 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35022 if (!SWIG_IsOK(res2)) {
35023 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35024 }
35025 if (!argp2) {
35026 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35027 }
35028 arg2 = reinterpret_cast< wxFont * >(argp2);
35029 {
35030 PyThreadState* __tstate = wxPyBeginAllowThreads();
35031 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35032 wxPyEndAllowThreads(__tstate);
35033 if (PyErr_Occurred()) SWIG_fail;
35034 }
35035 {
35036 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35037 }
35038 return resultobj;
35039 fail:
35040 return NULL;
35041 }
35042
35043
35044 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35045 PyObject *resultobj = 0;
35046 wxWindow *arg1 = (wxWindow *) 0 ;
35047 wxFont *arg2 = 0 ;
35048 void *argp1 = 0 ;
35049 int res1 = 0 ;
35050 void *argp2 = 0 ;
35051 int res2 = 0 ;
35052 PyObject * obj0 = 0 ;
35053 PyObject * obj1 = 0 ;
35054 char * kwnames[] = {
35055 (char *) "self",(char *) "font", NULL
35056 };
35057
35058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35060 if (!SWIG_IsOK(res1)) {
35061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35062 }
35063 arg1 = reinterpret_cast< wxWindow * >(argp1);
35064 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35065 if (!SWIG_IsOK(res2)) {
35066 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35067 }
35068 if (!argp2) {
35069 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35070 }
35071 arg2 = reinterpret_cast< wxFont * >(argp2);
35072 {
35073 PyThreadState* __tstate = wxPyBeginAllowThreads();
35074 (arg1)->SetOwnFont((wxFont const &)*arg2);
35075 wxPyEndAllowThreads(__tstate);
35076 if (PyErr_Occurred()) SWIG_fail;
35077 }
35078 resultobj = SWIG_Py_Void();
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 wxFont result;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 PyObject *swig_obj[1] ;
35092
35093 if (!args) SWIG_fail;
35094 swig_obj[0] = args;
35095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35096 if (!SWIG_IsOK(res1)) {
35097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35098 }
35099 arg1 = reinterpret_cast< wxWindow * >(argp1);
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (arg1)->GetFont();
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35107 return resultobj;
35108 fail:
35109 return NULL;
35110 }
35111
35112
35113 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35114 PyObject *resultobj = 0;
35115 wxWindow *arg1 = (wxWindow *) 0 ;
35116 wxCaret *arg2 = (wxCaret *) 0 ;
35117 void *argp1 = 0 ;
35118 int res1 = 0 ;
35119 int res2 = 0 ;
35120 PyObject * obj0 = 0 ;
35121 PyObject * obj1 = 0 ;
35122 char * kwnames[] = {
35123 (char *) "self",(char *) "caret", NULL
35124 };
35125
35126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35128 if (!SWIG_IsOK(res1)) {
35129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35130 }
35131 arg1 = reinterpret_cast< wxWindow * >(argp1);
35132 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35133 if (!SWIG_IsOK(res2)) {
35134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35135 }
35136 {
35137 PyThreadState* __tstate = wxPyBeginAllowThreads();
35138 (arg1)->SetCaret(arg2);
35139 wxPyEndAllowThreads(__tstate);
35140 if (PyErr_Occurred()) SWIG_fail;
35141 }
35142 resultobj = SWIG_Py_Void();
35143 return resultobj;
35144 fail:
35145 return NULL;
35146 }
35147
35148
35149 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35150 PyObject *resultobj = 0;
35151 wxWindow *arg1 = (wxWindow *) 0 ;
35152 wxCaret *result = 0 ;
35153 void *argp1 = 0 ;
35154 int res1 = 0 ;
35155 PyObject *swig_obj[1] ;
35156
35157 if (!args) SWIG_fail;
35158 swig_obj[0] = args;
35159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35160 if (!SWIG_IsOK(res1)) {
35161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35162 }
35163 arg1 = reinterpret_cast< wxWindow * >(argp1);
35164 {
35165 PyThreadState* __tstate = wxPyBeginAllowThreads();
35166 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35167 wxPyEndAllowThreads(__tstate);
35168 if (PyErr_Occurred()) SWIG_fail;
35169 }
35170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35171 return resultobj;
35172 fail:
35173 return NULL;
35174 }
35175
35176
35177 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35178 PyObject *resultobj = 0;
35179 wxWindow *arg1 = (wxWindow *) 0 ;
35180 int result;
35181 void *argp1 = 0 ;
35182 int res1 = 0 ;
35183 PyObject *swig_obj[1] ;
35184
35185 if (!args) SWIG_fail;
35186 swig_obj[0] = args;
35187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35188 if (!SWIG_IsOK(res1)) {
35189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35190 }
35191 arg1 = reinterpret_cast< wxWindow * >(argp1);
35192 {
35193 PyThreadState* __tstate = wxPyBeginAllowThreads();
35194 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35195 wxPyEndAllowThreads(__tstate);
35196 if (PyErr_Occurred()) SWIG_fail;
35197 }
35198 resultobj = SWIG_From_int(static_cast< int >(result));
35199 return resultobj;
35200 fail:
35201 return NULL;
35202 }
35203
35204
35205 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35206 PyObject *resultobj = 0;
35207 wxWindow *arg1 = (wxWindow *) 0 ;
35208 int result;
35209 void *argp1 = 0 ;
35210 int res1 = 0 ;
35211 PyObject *swig_obj[1] ;
35212
35213 if (!args) SWIG_fail;
35214 swig_obj[0] = args;
35215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35216 if (!SWIG_IsOK(res1)) {
35217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35218 }
35219 arg1 = reinterpret_cast< wxWindow * >(argp1);
35220 {
35221 PyThreadState* __tstate = wxPyBeginAllowThreads();
35222 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35223 wxPyEndAllowThreads(__tstate);
35224 if (PyErr_Occurred()) SWIG_fail;
35225 }
35226 resultobj = SWIG_From_int(static_cast< int >(result));
35227 return resultobj;
35228 fail:
35229 return NULL;
35230 }
35231
35232
35233 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35234 PyObject *resultobj = 0;
35235 wxWindow *arg1 = (wxWindow *) 0 ;
35236 wxString *arg2 = 0 ;
35237 int *arg3 = (int *) 0 ;
35238 int *arg4 = (int *) 0 ;
35239 void *argp1 = 0 ;
35240 int res1 = 0 ;
35241 bool temp2 = false ;
35242 int temp3 ;
35243 int res3 = SWIG_TMPOBJ ;
35244 int temp4 ;
35245 int res4 = SWIG_TMPOBJ ;
35246 PyObject * obj0 = 0 ;
35247 PyObject * obj1 = 0 ;
35248 char * kwnames[] = {
35249 (char *) "self",(char *) "string", NULL
35250 };
35251
35252 arg3 = &temp3;
35253 arg4 = &temp4;
35254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35256 if (!SWIG_IsOK(res1)) {
35257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35258 }
35259 arg1 = reinterpret_cast< wxWindow * >(argp1);
35260 {
35261 arg2 = wxString_in_helper(obj1);
35262 if (arg2 == NULL) SWIG_fail;
35263 temp2 = true;
35264 }
35265 {
35266 PyThreadState* __tstate = wxPyBeginAllowThreads();
35267 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35268 wxPyEndAllowThreads(__tstate);
35269 if (PyErr_Occurred()) SWIG_fail;
35270 }
35271 resultobj = SWIG_Py_Void();
35272 if (SWIG_IsTmpObj(res3)) {
35273 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35274 } else {
35275 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35276 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35277 }
35278 if (SWIG_IsTmpObj(res4)) {
35279 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35280 } else {
35281 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35282 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35283 }
35284 {
35285 if (temp2)
35286 delete arg2;
35287 }
35288 return resultobj;
35289 fail:
35290 {
35291 if (temp2)
35292 delete arg2;
35293 }
35294 return NULL;
35295 }
35296
35297
35298 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35299 PyObject *resultobj = 0;
35300 wxWindow *arg1 = (wxWindow *) 0 ;
35301 wxString *arg2 = 0 ;
35302 int *arg3 = (int *) 0 ;
35303 int *arg4 = (int *) 0 ;
35304 int *arg5 = (int *) 0 ;
35305 int *arg6 = (int *) 0 ;
35306 wxFont *arg7 = (wxFont *) NULL ;
35307 void *argp1 = 0 ;
35308 int res1 = 0 ;
35309 bool temp2 = false ;
35310 int temp3 ;
35311 int res3 = SWIG_TMPOBJ ;
35312 int temp4 ;
35313 int res4 = SWIG_TMPOBJ ;
35314 int temp5 ;
35315 int res5 = SWIG_TMPOBJ ;
35316 int temp6 ;
35317 int res6 = SWIG_TMPOBJ ;
35318 void *argp7 = 0 ;
35319 int res7 = 0 ;
35320 PyObject * obj0 = 0 ;
35321 PyObject * obj1 = 0 ;
35322 PyObject * obj2 = 0 ;
35323 char * kwnames[] = {
35324 (char *) "self",(char *) "string",(char *) "font", NULL
35325 };
35326
35327 arg3 = &temp3;
35328 arg4 = &temp4;
35329 arg5 = &temp5;
35330 arg6 = &temp6;
35331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35333 if (!SWIG_IsOK(res1)) {
35334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35335 }
35336 arg1 = reinterpret_cast< wxWindow * >(argp1);
35337 {
35338 arg2 = wxString_in_helper(obj1);
35339 if (arg2 == NULL) SWIG_fail;
35340 temp2 = true;
35341 }
35342 if (obj2) {
35343 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35344 if (!SWIG_IsOK(res7)) {
35345 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35346 }
35347 arg7 = reinterpret_cast< wxFont * >(argp7);
35348 }
35349 {
35350 PyThreadState* __tstate = wxPyBeginAllowThreads();
35351 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35352 wxPyEndAllowThreads(__tstate);
35353 if (PyErr_Occurred()) SWIG_fail;
35354 }
35355 resultobj = SWIG_Py_Void();
35356 if (SWIG_IsTmpObj(res3)) {
35357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35358 } else {
35359 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35361 }
35362 if (SWIG_IsTmpObj(res4)) {
35363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35364 } else {
35365 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35367 }
35368 if (SWIG_IsTmpObj(res5)) {
35369 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35370 } else {
35371 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35372 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35373 }
35374 if (SWIG_IsTmpObj(res6)) {
35375 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35376 } else {
35377 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35378 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35379 }
35380 {
35381 if (temp2)
35382 delete arg2;
35383 }
35384 return resultobj;
35385 fail:
35386 {
35387 if (temp2)
35388 delete arg2;
35389 }
35390 return NULL;
35391 }
35392
35393
35394 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35395 PyObject *resultobj = 0;
35396 wxWindow *arg1 = (wxWindow *) 0 ;
35397 int *arg2 = (int *) 0 ;
35398 int *arg3 = (int *) 0 ;
35399 void *argp1 = 0 ;
35400 int res1 = 0 ;
35401 int temp2 ;
35402 int res2 = 0 ;
35403 int temp3 ;
35404 int res3 = 0 ;
35405 PyObject * obj0 = 0 ;
35406 PyObject * obj1 = 0 ;
35407 PyObject * obj2 = 0 ;
35408 char * kwnames[] = {
35409 (char *) "self",(char *) "x",(char *) "y", NULL
35410 };
35411
35412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35414 if (!SWIG_IsOK(res1)) {
35415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35416 }
35417 arg1 = reinterpret_cast< wxWindow * >(argp1);
35418 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35419 int val;
35420 int ecode = SWIG_AsVal_int(obj1, &val);
35421 if (!SWIG_IsOK(ecode)) {
35422 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35423 }
35424 temp2 = static_cast< int >(val);
35425 arg2 = &temp2;
35426 res2 = SWIG_AddTmpMask(ecode);
35427 }
35428 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35429 int val;
35430 int ecode = SWIG_AsVal_int(obj2, &val);
35431 if (!SWIG_IsOK(ecode)) {
35432 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35433 }
35434 temp3 = static_cast< int >(val);
35435 arg3 = &temp3;
35436 res3 = SWIG_AddTmpMask(ecode);
35437 }
35438 {
35439 PyThreadState* __tstate = wxPyBeginAllowThreads();
35440 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35441 wxPyEndAllowThreads(__tstate);
35442 if (PyErr_Occurred()) SWIG_fail;
35443 }
35444 resultobj = SWIG_Py_Void();
35445 if (SWIG_IsTmpObj(res2)) {
35446 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35447 } else {
35448 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35449 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35450 }
35451 if (SWIG_IsTmpObj(res3)) {
35452 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35453 } else {
35454 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35455 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35456 }
35457 return resultobj;
35458 fail:
35459 return NULL;
35460 }
35461
35462
35463 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35464 PyObject *resultobj = 0;
35465 wxWindow *arg1 = (wxWindow *) 0 ;
35466 int *arg2 = (int *) 0 ;
35467 int *arg3 = (int *) 0 ;
35468 void *argp1 = 0 ;
35469 int res1 = 0 ;
35470 int temp2 ;
35471 int res2 = 0 ;
35472 int temp3 ;
35473 int res3 = 0 ;
35474 PyObject * obj0 = 0 ;
35475 PyObject * obj1 = 0 ;
35476 PyObject * obj2 = 0 ;
35477 char * kwnames[] = {
35478 (char *) "self",(char *) "x",(char *) "y", NULL
35479 };
35480
35481 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35482 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35483 if (!SWIG_IsOK(res1)) {
35484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35485 }
35486 arg1 = reinterpret_cast< wxWindow * >(argp1);
35487 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35488 int val;
35489 int ecode = SWIG_AsVal_int(obj1, &val);
35490 if (!SWIG_IsOK(ecode)) {
35491 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35492 }
35493 temp2 = static_cast< int >(val);
35494 arg2 = &temp2;
35495 res2 = SWIG_AddTmpMask(ecode);
35496 }
35497 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35498 int val;
35499 int ecode = SWIG_AsVal_int(obj2, &val);
35500 if (!SWIG_IsOK(ecode)) {
35501 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35502 }
35503 temp3 = static_cast< int >(val);
35504 arg3 = &temp3;
35505 res3 = SWIG_AddTmpMask(ecode);
35506 }
35507 {
35508 PyThreadState* __tstate = wxPyBeginAllowThreads();
35509 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35510 wxPyEndAllowThreads(__tstate);
35511 if (PyErr_Occurred()) SWIG_fail;
35512 }
35513 resultobj = SWIG_Py_Void();
35514 if (SWIG_IsTmpObj(res2)) {
35515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35516 } else {
35517 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35519 }
35520 if (SWIG_IsTmpObj(res3)) {
35521 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35522 } else {
35523 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35524 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35525 }
35526 return resultobj;
35527 fail:
35528 return NULL;
35529 }
35530
35531
35532 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35533 PyObject *resultobj = 0;
35534 wxWindow *arg1 = (wxWindow *) 0 ;
35535 wxPoint *arg2 = 0 ;
35536 wxPoint result;
35537 void *argp1 = 0 ;
35538 int res1 = 0 ;
35539 wxPoint temp2 ;
35540 PyObject * obj0 = 0 ;
35541 PyObject * obj1 = 0 ;
35542 char * kwnames[] = {
35543 (char *) "self",(char *) "pt", NULL
35544 };
35545
35546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35548 if (!SWIG_IsOK(res1)) {
35549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35550 }
35551 arg1 = reinterpret_cast< wxWindow * >(argp1);
35552 {
35553 arg2 = &temp2;
35554 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35555 }
35556 {
35557 PyThreadState* __tstate = wxPyBeginAllowThreads();
35558 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35559 wxPyEndAllowThreads(__tstate);
35560 if (PyErr_Occurred()) SWIG_fail;
35561 }
35562 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35563 return resultobj;
35564 fail:
35565 return NULL;
35566 }
35567
35568
35569 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35570 PyObject *resultobj = 0;
35571 wxWindow *arg1 = (wxWindow *) 0 ;
35572 wxPoint *arg2 = 0 ;
35573 wxPoint result;
35574 void *argp1 = 0 ;
35575 int res1 = 0 ;
35576 wxPoint temp2 ;
35577 PyObject * obj0 = 0 ;
35578 PyObject * obj1 = 0 ;
35579 char * kwnames[] = {
35580 (char *) "self",(char *) "pt", NULL
35581 };
35582
35583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35585 if (!SWIG_IsOK(res1)) {
35586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35587 }
35588 arg1 = reinterpret_cast< wxWindow * >(argp1);
35589 {
35590 arg2 = &temp2;
35591 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35592 }
35593 {
35594 PyThreadState* __tstate = wxPyBeginAllowThreads();
35595 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35596 wxPyEndAllowThreads(__tstate);
35597 if (PyErr_Occurred()) SWIG_fail;
35598 }
35599 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35600 return resultobj;
35601 fail:
35602 return NULL;
35603 }
35604
35605
35606 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35607 PyObject *resultobj = 0;
35608 wxWindow *arg1 = (wxWindow *) 0 ;
35609 int arg2 ;
35610 int arg3 ;
35611 wxHitTest result;
35612 void *argp1 = 0 ;
35613 int res1 = 0 ;
35614 int val2 ;
35615 int ecode2 = 0 ;
35616 int val3 ;
35617 int ecode3 = 0 ;
35618 PyObject * obj0 = 0 ;
35619 PyObject * obj1 = 0 ;
35620 PyObject * obj2 = 0 ;
35621 char * kwnames[] = {
35622 (char *) "self",(char *) "x",(char *) "y", NULL
35623 };
35624
35625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35627 if (!SWIG_IsOK(res1)) {
35628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35629 }
35630 arg1 = reinterpret_cast< wxWindow * >(argp1);
35631 ecode2 = SWIG_AsVal_int(obj1, &val2);
35632 if (!SWIG_IsOK(ecode2)) {
35633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35634 }
35635 arg2 = static_cast< int >(val2);
35636 ecode3 = SWIG_AsVal_int(obj2, &val3);
35637 if (!SWIG_IsOK(ecode3)) {
35638 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35639 }
35640 arg3 = static_cast< int >(val3);
35641 {
35642 PyThreadState* __tstate = wxPyBeginAllowThreads();
35643 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35644 wxPyEndAllowThreads(__tstate);
35645 if (PyErr_Occurred()) SWIG_fail;
35646 }
35647 resultobj = SWIG_From_int(static_cast< int >(result));
35648 return resultobj;
35649 fail:
35650 return NULL;
35651 }
35652
35653
35654 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35655 PyObject *resultobj = 0;
35656 wxWindow *arg1 = (wxWindow *) 0 ;
35657 wxPoint *arg2 = 0 ;
35658 wxHitTest result;
35659 void *argp1 = 0 ;
35660 int res1 = 0 ;
35661 wxPoint temp2 ;
35662 PyObject * obj0 = 0 ;
35663 PyObject * obj1 = 0 ;
35664 char * kwnames[] = {
35665 (char *) "self",(char *) "pt", NULL
35666 };
35667
35668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35670 if (!SWIG_IsOK(res1)) {
35671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35672 }
35673 arg1 = reinterpret_cast< wxWindow * >(argp1);
35674 {
35675 arg2 = &temp2;
35676 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35677 }
35678 {
35679 PyThreadState* __tstate = wxPyBeginAllowThreads();
35680 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35681 wxPyEndAllowThreads(__tstate);
35682 if (PyErr_Occurred()) SWIG_fail;
35683 }
35684 resultobj = SWIG_From_int(static_cast< int >(result));
35685 return resultobj;
35686 fail:
35687 return NULL;
35688 }
35689
35690
35691 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35692 PyObject *resultobj = 0;
35693 wxWindow *arg1 = (wxWindow *) 0 ;
35694 long arg2 ;
35695 wxBorder result;
35696 void *argp1 = 0 ;
35697 int res1 = 0 ;
35698 long val2 ;
35699 int ecode2 = 0 ;
35700
35701 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35703 if (!SWIG_IsOK(res1)) {
35704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35705 }
35706 arg1 = reinterpret_cast< wxWindow * >(argp1);
35707 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35708 if (!SWIG_IsOK(ecode2)) {
35709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35710 }
35711 arg2 = static_cast< long >(val2);
35712 {
35713 PyThreadState* __tstate = wxPyBeginAllowThreads();
35714 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35715 wxPyEndAllowThreads(__tstate);
35716 if (PyErr_Occurred()) SWIG_fail;
35717 }
35718 resultobj = SWIG_From_int(static_cast< int >(result));
35719 return resultobj;
35720 fail:
35721 return NULL;
35722 }
35723
35724
35725 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35726 PyObject *resultobj = 0;
35727 wxWindow *arg1 = (wxWindow *) 0 ;
35728 wxBorder result;
35729 void *argp1 = 0 ;
35730 int res1 = 0 ;
35731
35732 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35734 if (!SWIG_IsOK(res1)) {
35735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35736 }
35737 arg1 = reinterpret_cast< wxWindow * >(argp1);
35738 {
35739 PyThreadState* __tstate = wxPyBeginAllowThreads();
35740 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35741 wxPyEndAllowThreads(__tstate);
35742 if (PyErr_Occurred()) SWIG_fail;
35743 }
35744 resultobj = SWIG_From_int(static_cast< int >(result));
35745 return resultobj;
35746 fail:
35747 return NULL;
35748 }
35749
35750
35751 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35752 int argc;
35753 PyObject *argv[3];
35754
35755 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35756 --argc;
35757 if (argc == 1) {
35758 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35759 }
35760 if (argc == 2) {
35761 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35762 }
35763
35764 fail:
35765 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35766 return NULL;
35767 }
35768
35769
35770 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35771 PyObject *resultobj = 0;
35772 wxWindow *arg1 = (wxWindow *) 0 ;
35773 long arg2 = (long) wxUPDATE_UI_NONE ;
35774 void *argp1 = 0 ;
35775 int res1 = 0 ;
35776 long val2 ;
35777 int ecode2 = 0 ;
35778 PyObject * obj0 = 0 ;
35779 PyObject * obj1 = 0 ;
35780 char * kwnames[] = {
35781 (char *) "self",(char *) "flags", NULL
35782 };
35783
35784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35786 if (!SWIG_IsOK(res1)) {
35787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35788 }
35789 arg1 = reinterpret_cast< wxWindow * >(argp1);
35790 if (obj1) {
35791 ecode2 = SWIG_AsVal_long(obj1, &val2);
35792 if (!SWIG_IsOK(ecode2)) {
35793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35794 }
35795 arg2 = static_cast< long >(val2);
35796 }
35797 {
35798 PyThreadState* __tstate = wxPyBeginAllowThreads();
35799 (arg1)->UpdateWindowUI(arg2);
35800 wxPyEndAllowThreads(__tstate);
35801 if (PyErr_Occurred()) SWIG_fail;
35802 }
35803 resultobj = SWIG_Py_Void();
35804 return resultobj;
35805 fail:
35806 return NULL;
35807 }
35808
35809
35810 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35811 PyObject *resultobj = 0;
35812 wxWindow *arg1 = (wxWindow *) 0 ;
35813 wxMenu *arg2 = (wxMenu *) 0 ;
35814 int arg3 = (int) -1 ;
35815 int arg4 = (int) -1 ;
35816 bool result;
35817 void *argp1 = 0 ;
35818 int res1 = 0 ;
35819 void *argp2 = 0 ;
35820 int res2 = 0 ;
35821 int val3 ;
35822 int ecode3 = 0 ;
35823 int val4 ;
35824 int ecode4 = 0 ;
35825 PyObject * obj0 = 0 ;
35826 PyObject * obj1 = 0 ;
35827 PyObject * obj2 = 0 ;
35828 PyObject * obj3 = 0 ;
35829 char * kwnames[] = {
35830 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
35831 };
35832
35833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35835 if (!SWIG_IsOK(res1)) {
35836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
35837 }
35838 arg1 = reinterpret_cast< wxWindow * >(argp1);
35839 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35840 if (!SWIG_IsOK(res2)) {
35841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
35842 }
35843 arg2 = reinterpret_cast< wxMenu * >(argp2);
35844 if (obj2) {
35845 ecode3 = SWIG_AsVal_int(obj2, &val3);
35846 if (!SWIG_IsOK(ecode3)) {
35847 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
35848 }
35849 arg3 = static_cast< int >(val3);
35850 }
35851 if (obj3) {
35852 ecode4 = SWIG_AsVal_int(obj3, &val4);
35853 if (!SWIG_IsOK(ecode4)) {
35854 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
35855 }
35856 arg4 = static_cast< int >(val4);
35857 }
35858 {
35859 PyThreadState* __tstate = wxPyBeginAllowThreads();
35860 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
35861 wxPyEndAllowThreads(__tstate);
35862 if (PyErr_Occurred()) SWIG_fail;
35863 }
35864 {
35865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35866 }
35867 return resultobj;
35868 fail:
35869 return NULL;
35870 }
35871
35872
35873 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35874 PyObject *resultobj = 0;
35875 wxWindow *arg1 = (wxWindow *) 0 ;
35876 wxMenu *arg2 = (wxMenu *) 0 ;
35877 wxPoint const &arg3_defvalue = wxDefaultPosition ;
35878 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
35879 bool result;
35880 void *argp1 = 0 ;
35881 int res1 = 0 ;
35882 void *argp2 = 0 ;
35883 int res2 = 0 ;
35884 wxPoint temp3 ;
35885 PyObject * obj0 = 0 ;
35886 PyObject * obj1 = 0 ;
35887 PyObject * obj2 = 0 ;
35888 char * kwnames[] = {
35889 (char *) "self",(char *) "menu",(char *) "pos", NULL
35890 };
35891
35892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35894 if (!SWIG_IsOK(res1)) {
35895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
35896 }
35897 arg1 = reinterpret_cast< wxWindow * >(argp1);
35898 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
35899 if (!SWIG_IsOK(res2)) {
35900 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
35901 }
35902 arg2 = reinterpret_cast< wxMenu * >(argp2);
35903 if (obj2) {
35904 {
35905 arg3 = &temp3;
35906 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
35907 }
35908 }
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
35912 wxPyEndAllowThreads(__tstate);
35913 if (PyErr_Occurred()) SWIG_fail;
35914 }
35915 {
35916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35917 }
35918 return resultobj;
35919 fail:
35920 return NULL;
35921 }
35922
35923
35924 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35925 PyObject *resultobj = 0;
35926 wxWindow *arg1 = (wxWindow *) 0 ;
35927 long result;
35928 void *argp1 = 0 ;
35929 int res1 = 0 ;
35930 PyObject *swig_obj[1] ;
35931
35932 if (!args) SWIG_fail;
35933 swig_obj[0] = args;
35934 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35935 if (!SWIG_IsOK(res1)) {
35936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35937 }
35938 arg1 = reinterpret_cast< wxWindow * >(argp1);
35939 {
35940 PyThreadState* __tstate = wxPyBeginAllowThreads();
35941 result = (long)wxWindow_GetHandle(arg1);
35942 wxPyEndAllowThreads(__tstate);
35943 if (PyErr_Occurred()) SWIG_fail;
35944 }
35945 resultobj = SWIG_From_long(static_cast< long >(result));
35946 return resultobj;
35947 fail:
35948 return NULL;
35949 }
35950
35951
35952 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35953 PyObject *resultobj = 0;
35954 wxWindow *arg1 = (wxWindow *) 0 ;
35955 long arg2 ;
35956 void *argp1 = 0 ;
35957 int res1 = 0 ;
35958 long val2 ;
35959 int ecode2 = 0 ;
35960 PyObject * obj0 = 0 ;
35961 PyObject * obj1 = 0 ;
35962 char * kwnames[] = {
35963 (char *) "self",(char *) "handle", NULL
35964 };
35965
35966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
35967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35968 if (!SWIG_IsOK(res1)) {
35969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
35970 }
35971 arg1 = reinterpret_cast< wxWindow * >(argp1);
35972 ecode2 = SWIG_AsVal_long(obj1, &val2);
35973 if (!SWIG_IsOK(ecode2)) {
35974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
35975 }
35976 arg2 = static_cast< long >(val2);
35977 {
35978 PyThreadState* __tstate = wxPyBeginAllowThreads();
35979 wxWindow_AssociateHandle(arg1,arg2);
35980 wxPyEndAllowThreads(__tstate);
35981 if (PyErr_Occurred()) SWIG_fail;
35982 }
35983 resultobj = SWIG_Py_Void();
35984 return resultobj;
35985 fail:
35986 return NULL;
35987 }
35988
35989
35990 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35991 PyObject *resultobj = 0;
35992 wxWindow *arg1 = (wxWindow *) 0 ;
35993 void *argp1 = 0 ;
35994 int res1 = 0 ;
35995 PyObject *swig_obj[1] ;
35996
35997 if (!args) SWIG_fail;
35998 swig_obj[0] = args;
35999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36000 if (!SWIG_IsOK(res1)) {
36001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36002 }
36003 arg1 = reinterpret_cast< wxWindow * >(argp1);
36004 {
36005 PyThreadState* __tstate = wxPyBeginAllowThreads();
36006 (arg1)->DissociateHandle();
36007 wxPyEndAllowThreads(__tstate);
36008 if (PyErr_Occurred()) SWIG_fail;
36009 }
36010 resultobj = SWIG_Py_Void();
36011 return resultobj;
36012 fail:
36013 return NULL;
36014 }
36015
36016
36017 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36018 PyObject *resultobj = 0;
36019 wxWindow *arg1 = (wxWindow *) 0 ;
36020 wxPaintEvent *arg2 = 0 ;
36021 void *argp1 = 0 ;
36022 int res1 = 0 ;
36023 void *argp2 = 0 ;
36024 int res2 = 0 ;
36025 PyObject * obj0 = 0 ;
36026 PyObject * obj1 = 0 ;
36027 char * kwnames[] = {
36028 (char *) "self",(char *) "event", NULL
36029 };
36030
36031 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
36032 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36033 if (!SWIG_IsOK(res1)) {
36034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
36035 }
36036 arg1 = reinterpret_cast< wxWindow * >(argp1);
36037 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
36038 if (!SWIG_IsOK(res2)) {
36039 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36040 }
36041 if (!argp2) {
36042 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
36043 }
36044 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
36045 {
36046 PyThreadState* __tstate = wxPyBeginAllowThreads();
36047 (arg1)->OnPaint(*arg2);
36048 wxPyEndAllowThreads(__tstate);
36049 if (PyErr_Occurred()) SWIG_fail;
36050 }
36051 resultobj = SWIG_Py_Void();
36052 return resultobj;
36053 fail:
36054 return NULL;
36055 }
36056
36057
36058 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36059 PyObject *resultobj = 0;
36060 wxWindow *arg1 = (wxWindow *) 0 ;
36061 int arg2 ;
36062 bool result;
36063 void *argp1 = 0 ;
36064 int res1 = 0 ;
36065 int val2 ;
36066 int ecode2 = 0 ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 char * kwnames[] = {
36070 (char *) "self",(char *) "orient", NULL
36071 };
36072
36073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36075 if (!SWIG_IsOK(res1)) {
36076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36077 }
36078 arg1 = reinterpret_cast< wxWindow * >(argp1);
36079 ecode2 = SWIG_AsVal_int(obj1, &val2);
36080 if (!SWIG_IsOK(ecode2)) {
36081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36082 }
36083 arg2 = static_cast< int >(val2);
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
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_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36100 PyObject *resultobj = 0;
36101 wxWindow *arg1 = (wxWindow *) 0 ;
36102 int arg2 ;
36103 int arg3 ;
36104 int arg4 ;
36105 int arg5 ;
36106 bool arg6 = (bool) true ;
36107 void *argp1 = 0 ;
36108 int res1 = 0 ;
36109 int val2 ;
36110 int ecode2 = 0 ;
36111 int val3 ;
36112 int ecode3 = 0 ;
36113 int val4 ;
36114 int ecode4 = 0 ;
36115 int val5 ;
36116 int ecode5 = 0 ;
36117 bool val6 ;
36118 int ecode6 = 0 ;
36119 PyObject * obj0 = 0 ;
36120 PyObject * obj1 = 0 ;
36121 PyObject * obj2 = 0 ;
36122 PyObject * obj3 = 0 ;
36123 PyObject * obj4 = 0 ;
36124 PyObject * obj5 = 0 ;
36125 char * kwnames[] = {
36126 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36127 };
36128
36129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36131 if (!SWIG_IsOK(res1)) {
36132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36133 }
36134 arg1 = reinterpret_cast< wxWindow * >(argp1);
36135 ecode2 = SWIG_AsVal_int(obj1, &val2);
36136 if (!SWIG_IsOK(ecode2)) {
36137 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36138 }
36139 arg2 = static_cast< int >(val2);
36140 ecode3 = SWIG_AsVal_int(obj2, &val3);
36141 if (!SWIG_IsOK(ecode3)) {
36142 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36143 }
36144 arg3 = static_cast< int >(val3);
36145 ecode4 = SWIG_AsVal_int(obj3, &val4);
36146 if (!SWIG_IsOK(ecode4)) {
36147 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36148 }
36149 arg4 = static_cast< int >(val4);
36150 ecode5 = SWIG_AsVal_int(obj4, &val5);
36151 if (!SWIG_IsOK(ecode5)) {
36152 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36153 }
36154 arg5 = static_cast< int >(val5);
36155 if (obj5) {
36156 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36157 if (!SWIG_IsOK(ecode6)) {
36158 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36159 }
36160 arg6 = static_cast< bool >(val6);
36161 }
36162 {
36163 PyThreadState* __tstate = wxPyBeginAllowThreads();
36164 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 resultobj = SWIG_Py_Void();
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36176 PyObject *resultobj = 0;
36177 wxWindow *arg1 = (wxWindow *) 0 ;
36178 int arg2 ;
36179 int arg3 ;
36180 bool arg4 = (bool) true ;
36181 void *argp1 = 0 ;
36182 int res1 = 0 ;
36183 int val2 ;
36184 int ecode2 = 0 ;
36185 int val3 ;
36186 int ecode3 = 0 ;
36187 bool val4 ;
36188 int ecode4 = 0 ;
36189 PyObject * obj0 = 0 ;
36190 PyObject * obj1 = 0 ;
36191 PyObject * obj2 = 0 ;
36192 PyObject * obj3 = 0 ;
36193 char * kwnames[] = {
36194 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36195 };
36196
36197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36199 if (!SWIG_IsOK(res1)) {
36200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36201 }
36202 arg1 = reinterpret_cast< wxWindow * >(argp1);
36203 ecode2 = SWIG_AsVal_int(obj1, &val2);
36204 if (!SWIG_IsOK(ecode2)) {
36205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36206 }
36207 arg2 = static_cast< int >(val2);
36208 ecode3 = SWIG_AsVal_int(obj2, &val3);
36209 if (!SWIG_IsOK(ecode3)) {
36210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36211 }
36212 arg3 = static_cast< int >(val3);
36213 if (obj3) {
36214 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36215 if (!SWIG_IsOK(ecode4)) {
36216 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36217 }
36218 arg4 = static_cast< bool >(val4);
36219 }
36220 {
36221 PyThreadState* __tstate = wxPyBeginAllowThreads();
36222 (arg1)->SetScrollPos(arg2,arg3,arg4);
36223 wxPyEndAllowThreads(__tstate);
36224 if (PyErr_Occurred()) SWIG_fail;
36225 }
36226 resultobj = SWIG_Py_Void();
36227 return resultobj;
36228 fail:
36229 return NULL;
36230 }
36231
36232
36233 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36234 PyObject *resultobj = 0;
36235 wxWindow *arg1 = (wxWindow *) 0 ;
36236 int arg2 ;
36237 int result;
36238 void *argp1 = 0 ;
36239 int res1 = 0 ;
36240 int val2 ;
36241 int ecode2 = 0 ;
36242 PyObject * obj0 = 0 ;
36243 PyObject * obj1 = 0 ;
36244 char * kwnames[] = {
36245 (char *) "self",(char *) "orientation", NULL
36246 };
36247
36248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36250 if (!SWIG_IsOK(res1)) {
36251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36252 }
36253 arg1 = reinterpret_cast< wxWindow * >(argp1);
36254 ecode2 = SWIG_AsVal_int(obj1, &val2);
36255 if (!SWIG_IsOK(ecode2)) {
36256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36257 }
36258 arg2 = static_cast< int >(val2);
36259 {
36260 PyThreadState* __tstate = wxPyBeginAllowThreads();
36261 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36262 wxPyEndAllowThreads(__tstate);
36263 if (PyErr_Occurred()) SWIG_fail;
36264 }
36265 resultobj = SWIG_From_int(static_cast< int >(result));
36266 return resultobj;
36267 fail:
36268 return NULL;
36269 }
36270
36271
36272 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36273 PyObject *resultobj = 0;
36274 wxWindow *arg1 = (wxWindow *) 0 ;
36275 int arg2 ;
36276 int result;
36277 void *argp1 = 0 ;
36278 int res1 = 0 ;
36279 int val2 ;
36280 int ecode2 = 0 ;
36281 PyObject * obj0 = 0 ;
36282 PyObject * obj1 = 0 ;
36283 char * kwnames[] = {
36284 (char *) "self",(char *) "orientation", NULL
36285 };
36286
36287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36289 if (!SWIG_IsOK(res1)) {
36290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36291 }
36292 arg1 = reinterpret_cast< wxWindow * >(argp1);
36293 ecode2 = SWIG_AsVal_int(obj1, &val2);
36294 if (!SWIG_IsOK(ecode2)) {
36295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36296 }
36297 arg2 = static_cast< int >(val2);
36298 {
36299 PyThreadState* __tstate = wxPyBeginAllowThreads();
36300 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36301 wxPyEndAllowThreads(__tstate);
36302 if (PyErr_Occurred()) SWIG_fail;
36303 }
36304 resultobj = SWIG_From_int(static_cast< int >(result));
36305 return resultobj;
36306 fail:
36307 return NULL;
36308 }
36309
36310
36311 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36312 PyObject *resultobj = 0;
36313 wxWindow *arg1 = (wxWindow *) 0 ;
36314 int arg2 ;
36315 int result;
36316 void *argp1 = 0 ;
36317 int res1 = 0 ;
36318 int val2 ;
36319 int ecode2 = 0 ;
36320 PyObject * obj0 = 0 ;
36321 PyObject * obj1 = 0 ;
36322 char * kwnames[] = {
36323 (char *) "self",(char *) "orientation", NULL
36324 };
36325
36326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36328 if (!SWIG_IsOK(res1)) {
36329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36330 }
36331 arg1 = reinterpret_cast< wxWindow * >(argp1);
36332 ecode2 = SWIG_AsVal_int(obj1, &val2);
36333 if (!SWIG_IsOK(ecode2)) {
36334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36335 }
36336 arg2 = static_cast< int >(val2);
36337 {
36338 PyThreadState* __tstate = wxPyBeginAllowThreads();
36339 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36340 wxPyEndAllowThreads(__tstate);
36341 if (PyErr_Occurred()) SWIG_fail;
36342 }
36343 resultobj = SWIG_From_int(static_cast< int >(result));
36344 return resultobj;
36345 fail:
36346 return NULL;
36347 }
36348
36349
36350 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36351 PyObject *resultobj = 0;
36352 wxWindow *arg1 = (wxWindow *) 0 ;
36353 int arg2 ;
36354 int arg3 ;
36355 wxRect *arg4 = (wxRect *) NULL ;
36356 void *argp1 = 0 ;
36357 int res1 = 0 ;
36358 int val2 ;
36359 int ecode2 = 0 ;
36360 int val3 ;
36361 int ecode3 = 0 ;
36362 void *argp4 = 0 ;
36363 int res4 = 0 ;
36364 PyObject * obj0 = 0 ;
36365 PyObject * obj1 = 0 ;
36366 PyObject * obj2 = 0 ;
36367 PyObject * obj3 = 0 ;
36368 char * kwnames[] = {
36369 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36370 };
36371
36372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36374 if (!SWIG_IsOK(res1)) {
36375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36376 }
36377 arg1 = reinterpret_cast< wxWindow * >(argp1);
36378 ecode2 = SWIG_AsVal_int(obj1, &val2);
36379 if (!SWIG_IsOK(ecode2)) {
36380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36381 }
36382 arg2 = static_cast< int >(val2);
36383 ecode3 = SWIG_AsVal_int(obj2, &val3);
36384 if (!SWIG_IsOK(ecode3)) {
36385 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36386 }
36387 arg3 = static_cast< int >(val3);
36388 if (obj3) {
36389 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36390 if (!SWIG_IsOK(res4)) {
36391 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36392 }
36393 arg4 = reinterpret_cast< wxRect * >(argp4);
36394 }
36395 {
36396 PyThreadState* __tstate = wxPyBeginAllowThreads();
36397 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36398 wxPyEndAllowThreads(__tstate);
36399 if (PyErr_Occurred()) SWIG_fail;
36400 }
36401 resultobj = SWIG_Py_Void();
36402 return resultobj;
36403 fail:
36404 return NULL;
36405 }
36406
36407
36408 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36409 PyObject *resultobj = 0;
36410 wxWindow *arg1 = (wxWindow *) 0 ;
36411 int arg2 ;
36412 bool result;
36413 void *argp1 = 0 ;
36414 int res1 = 0 ;
36415 int val2 ;
36416 int ecode2 = 0 ;
36417 PyObject * obj0 = 0 ;
36418 PyObject * obj1 = 0 ;
36419 char * kwnames[] = {
36420 (char *) "self",(char *) "lines", NULL
36421 };
36422
36423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36425 if (!SWIG_IsOK(res1)) {
36426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36427 }
36428 arg1 = reinterpret_cast< wxWindow * >(argp1);
36429 ecode2 = SWIG_AsVal_int(obj1, &val2);
36430 if (!SWIG_IsOK(ecode2)) {
36431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36432 }
36433 arg2 = static_cast< int >(val2);
36434 {
36435 PyThreadState* __tstate = wxPyBeginAllowThreads();
36436 result = (bool)(arg1)->ScrollLines(arg2);
36437 wxPyEndAllowThreads(__tstate);
36438 if (PyErr_Occurred()) SWIG_fail;
36439 }
36440 {
36441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36442 }
36443 return resultobj;
36444 fail:
36445 return NULL;
36446 }
36447
36448
36449 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36450 PyObject *resultobj = 0;
36451 wxWindow *arg1 = (wxWindow *) 0 ;
36452 int arg2 ;
36453 bool result;
36454 void *argp1 = 0 ;
36455 int res1 = 0 ;
36456 int val2 ;
36457 int ecode2 = 0 ;
36458 PyObject * obj0 = 0 ;
36459 PyObject * obj1 = 0 ;
36460 char * kwnames[] = {
36461 (char *) "self",(char *) "pages", NULL
36462 };
36463
36464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36466 if (!SWIG_IsOK(res1)) {
36467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36468 }
36469 arg1 = reinterpret_cast< wxWindow * >(argp1);
36470 ecode2 = SWIG_AsVal_int(obj1, &val2);
36471 if (!SWIG_IsOK(ecode2)) {
36472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36473 }
36474 arg2 = static_cast< int >(val2);
36475 {
36476 PyThreadState* __tstate = wxPyBeginAllowThreads();
36477 result = (bool)(arg1)->ScrollPages(arg2);
36478 wxPyEndAllowThreads(__tstate);
36479 if (PyErr_Occurred()) SWIG_fail;
36480 }
36481 {
36482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36483 }
36484 return resultobj;
36485 fail:
36486 return NULL;
36487 }
36488
36489
36490 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36491 PyObject *resultobj = 0;
36492 wxWindow *arg1 = (wxWindow *) 0 ;
36493 bool result;
36494 void *argp1 = 0 ;
36495 int res1 = 0 ;
36496 PyObject *swig_obj[1] ;
36497
36498 if (!args) SWIG_fail;
36499 swig_obj[0] = args;
36500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36501 if (!SWIG_IsOK(res1)) {
36502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36503 }
36504 arg1 = reinterpret_cast< wxWindow * >(argp1);
36505 {
36506 PyThreadState* __tstate = wxPyBeginAllowThreads();
36507 result = (bool)(arg1)->LineUp();
36508 wxPyEndAllowThreads(__tstate);
36509 if (PyErr_Occurred()) SWIG_fail;
36510 }
36511 {
36512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36513 }
36514 return resultobj;
36515 fail:
36516 return NULL;
36517 }
36518
36519
36520 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36521 PyObject *resultobj = 0;
36522 wxWindow *arg1 = (wxWindow *) 0 ;
36523 bool result;
36524 void *argp1 = 0 ;
36525 int res1 = 0 ;
36526 PyObject *swig_obj[1] ;
36527
36528 if (!args) SWIG_fail;
36529 swig_obj[0] = args;
36530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36531 if (!SWIG_IsOK(res1)) {
36532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36533 }
36534 arg1 = reinterpret_cast< wxWindow * >(argp1);
36535 {
36536 PyThreadState* __tstate = wxPyBeginAllowThreads();
36537 result = (bool)(arg1)->LineDown();
36538 wxPyEndAllowThreads(__tstate);
36539 if (PyErr_Occurred()) SWIG_fail;
36540 }
36541 {
36542 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36543 }
36544 return resultobj;
36545 fail:
36546 return NULL;
36547 }
36548
36549
36550 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36551 PyObject *resultobj = 0;
36552 wxWindow *arg1 = (wxWindow *) 0 ;
36553 bool result;
36554 void *argp1 = 0 ;
36555 int res1 = 0 ;
36556 PyObject *swig_obj[1] ;
36557
36558 if (!args) SWIG_fail;
36559 swig_obj[0] = args;
36560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36561 if (!SWIG_IsOK(res1)) {
36562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36563 }
36564 arg1 = reinterpret_cast< wxWindow * >(argp1);
36565 {
36566 PyThreadState* __tstate = wxPyBeginAllowThreads();
36567 result = (bool)(arg1)->PageUp();
36568 wxPyEndAllowThreads(__tstate);
36569 if (PyErr_Occurred()) SWIG_fail;
36570 }
36571 {
36572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36573 }
36574 return resultobj;
36575 fail:
36576 return NULL;
36577 }
36578
36579
36580 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36581 PyObject *resultobj = 0;
36582 wxWindow *arg1 = (wxWindow *) 0 ;
36583 bool result;
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_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36593 }
36594 arg1 = reinterpret_cast< wxWindow * >(argp1);
36595 {
36596 PyThreadState* __tstate = wxPyBeginAllowThreads();
36597 result = (bool)(arg1)->PageDown();
36598 wxPyEndAllowThreads(__tstate);
36599 if (PyErr_Occurred()) SWIG_fail;
36600 }
36601 {
36602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36603 }
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 wxString *arg2 = 0 ;
36614 void *argp1 = 0 ;
36615 int res1 = 0 ;
36616 bool temp2 = false ;
36617 PyObject * obj0 = 0 ;
36618 PyObject * obj1 = 0 ;
36619 char * kwnames[] = {
36620 (char *) "self",(char *) "text", NULL
36621 };
36622
36623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36625 if (!SWIG_IsOK(res1)) {
36626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36627 }
36628 arg1 = reinterpret_cast< wxWindow * >(argp1);
36629 {
36630 arg2 = wxString_in_helper(obj1);
36631 if (arg2 == NULL) SWIG_fail;
36632 temp2 = true;
36633 }
36634 {
36635 PyThreadState* __tstate = wxPyBeginAllowThreads();
36636 (arg1)->SetHelpText((wxString const &)*arg2);
36637 wxPyEndAllowThreads(__tstate);
36638 if (PyErr_Occurred()) SWIG_fail;
36639 }
36640 resultobj = SWIG_Py_Void();
36641 {
36642 if (temp2)
36643 delete arg2;
36644 }
36645 return resultobj;
36646 fail:
36647 {
36648 if (temp2)
36649 delete arg2;
36650 }
36651 return NULL;
36652 }
36653
36654
36655 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36656 PyObject *resultobj = 0;
36657 wxWindow *arg1 = (wxWindow *) 0 ;
36658 wxString *arg2 = 0 ;
36659 void *argp1 = 0 ;
36660 int res1 = 0 ;
36661 bool temp2 = false ;
36662 PyObject * obj0 = 0 ;
36663 PyObject * obj1 = 0 ;
36664 char * kwnames[] = {
36665 (char *) "self",(char *) "text", NULL
36666 };
36667
36668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36670 if (!SWIG_IsOK(res1)) {
36671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36672 }
36673 arg1 = reinterpret_cast< wxWindow * >(argp1);
36674 {
36675 arg2 = wxString_in_helper(obj1);
36676 if (arg2 == NULL) SWIG_fail;
36677 temp2 = true;
36678 }
36679 {
36680 PyThreadState* __tstate = wxPyBeginAllowThreads();
36681 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36682 wxPyEndAllowThreads(__tstate);
36683 if (PyErr_Occurred()) SWIG_fail;
36684 }
36685 resultobj = SWIG_Py_Void();
36686 {
36687 if (temp2)
36688 delete arg2;
36689 }
36690 return resultobj;
36691 fail:
36692 {
36693 if (temp2)
36694 delete arg2;
36695 }
36696 return NULL;
36697 }
36698
36699
36700 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36701 PyObject *resultobj = 0;
36702 wxWindow *arg1 = (wxWindow *) 0 ;
36703 wxString result;
36704 void *argp1 = 0 ;
36705 int res1 = 0 ;
36706 PyObject *swig_obj[1] ;
36707
36708 if (!args) SWIG_fail;
36709 swig_obj[0] = args;
36710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36711 if (!SWIG_IsOK(res1)) {
36712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36713 }
36714 arg1 = reinterpret_cast< wxWindow * >(argp1);
36715 {
36716 PyThreadState* __tstate = wxPyBeginAllowThreads();
36717 result = ((wxWindow const *)arg1)->GetHelpText();
36718 wxPyEndAllowThreads(__tstate);
36719 if (PyErr_Occurred()) SWIG_fail;
36720 }
36721 {
36722 #if wxUSE_UNICODE
36723 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36724 #else
36725 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36726 #endif
36727 }
36728 return resultobj;
36729 fail:
36730 return NULL;
36731 }
36732
36733
36734 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36735 PyObject *resultobj = 0;
36736 wxWindow *arg1 = (wxWindow *) 0 ;
36737 wxString *arg2 = 0 ;
36738 void *argp1 = 0 ;
36739 int res1 = 0 ;
36740 bool temp2 = false ;
36741 PyObject * obj0 = 0 ;
36742 PyObject * obj1 = 0 ;
36743 char * kwnames[] = {
36744 (char *) "self",(char *) "tip", NULL
36745 };
36746
36747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36749 if (!SWIG_IsOK(res1)) {
36750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36751 }
36752 arg1 = reinterpret_cast< wxWindow * >(argp1);
36753 {
36754 arg2 = wxString_in_helper(obj1);
36755 if (arg2 == NULL) SWIG_fail;
36756 temp2 = true;
36757 }
36758 {
36759 PyThreadState* __tstate = wxPyBeginAllowThreads();
36760 (arg1)->SetToolTip((wxString const &)*arg2);
36761 wxPyEndAllowThreads(__tstate);
36762 if (PyErr_Occurred()) SWIG_fail;
36763 }
36764 resultobj = SWIG_Py_Void();
36765 {
36766 if (temp2)
36767 delete arg2;
36768 }
36769 return resultobj;
36770 fail:
36771 {
36772 if (temp2)
36773 delete arg2;
36774 }
36775 return NULL;
36776 }
36777
36778
36779 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36780 PyObject *resultobj = 0;
36781 wxWindow *arg1 = (wxWindow *) 0 ;
36782 wxToolTip *arg2 = (wxToolTip *) 0 ;
36783 void *argp1 = 0 ;
36784 int res1 = 0 ;
36785 int res2 = 0 ;
36786 PyObject * obj0 = 0 ;
36787 PyObject * obj1 = 0 ;
36788 char * kwnames[] = {
36789 (char *) "self",(char *) "tip", NULL
36790 };
36791
36792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36794 if (!SWIG_IsOK(res1)) {
36795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36796 }
36797 arg1 = reinterpret_cast< wxWindow * >(argp1);
36798 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36799 if (!SWIG_IsOK(res2)) {
36800 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36801 }
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 (arg1)->SetToolTip(arg2);
36805 wxPyEndAllowThreads(__tstate);
36806 if (PyErr_Occurred()) SWIG_fail;
36807 }
36808 resultobj = SWIG_Py_Void();
36809 return resultobj;
36810 fail:
36811 return NULL;
36812 }
36813
36814
36815 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36816 PyObject *resultobj = 0;
36817 wxWindow *arg1 = (wxWindow *) 0 ;
36818 wxToolTip *result = 0 ;
36819 void *argp1 = 0 ;
36820 int res1 = 0 ;
36821 PyObject *swig_obj[1] ;
36822
36823 if (!args) SWIG_fail;
36824 swig_obj[0] = args;
36825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36826 if (!SWIG_IsOK(res1)) {
36827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36828 }
36829 arg1 = reinterpret_cast< wxWindow * >(argp1);
36830 {
36831 PyThreadState* __tstate = wxPyBeginAllowThreads();
36832 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36833 wxPyEndAllowThreads(__tstate);
36834 if (PyErr_Occurred()) SWIG_fail;
36835 }
36836 {
36837 resultobj = wxPyMake_wxObject(result, (bool)0);
36838 }
36839 return resultobj;
36840 fail:
36841 return NULL;
36842 }
36843
36844
36845 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36846 PyObject *resultobj = 0;
36847 wxWindow *arg1 = (wxWindow *) 0 ;
36848 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
36849 void *argp1 = 0 ;
36850 int res1 = 0 ;
36851 int res2 = 0 ;
36852 PyObject * obj0 = 0 ;
36853 PyObject * obj1 = 0 ;
36854 char * kwnames[] = {
36855 (char *) "self",(char *) "dropTarget", NULL
36856 };
36857
36858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
36859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36860 if (!SWIG_IsOK(res1)) {
36861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
36862 }
36863 arg1 = reinterpret_cast< wxWindow * >(argp1);
36864 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
36865 if (!SWIG_IsOK(res2)) {
36866 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
36867 }
36868 {
36869 PyThreadState* __tstate = wxPyBeginAllowThreads();
36870 (arg1)->SetDropTarget(arg2);
36871 wxPyEndAllowThreads(__tstate);
36872 if (PyErr_Occurred()) SWIG_fail;
36873 }
36874 resultobj = SWIG_Py_Void();
36875 return resultobj;
36876 fail:
36877 return NULL;
36878 }
36879
36880
36881 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36882 PyObject *resultobj = 0;
36883 wxWindow *arg1 = (wxWindow *) 0 ;
36884 wxPyDropTarget *result = 0 ;
36885 void *argp1 = 0 ;
36886 int res1 = 0 ;
36887 PyObject *swig_obj[1] ;
36888
36889 if (!args) SWIG_fail;
36890 swig_obj[0] = args;
36891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36892 if (!SWIG_IsOK(res1)) {
36893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
36894 }
36895 arg1 = reinterpret_cast< wxWindow * >(argp1);
36896 {
36897 PyThreadState* __tstate = wxPyBeginAllowThreads();
36898 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
36899 wxPyEndAllowThreads(__tstate);
36900 if (PyErr_Occurred()) SWIG_fail;
36901 }
36902 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
36903 return resultobj;
36904 fail:
36905 return NULL;
36906 }
36907
36908
36909 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36910 PyObject *resultobj = 0;
36911 wxWindow *arg1 = (wxWindow *) 0 ;
36912 bool arg2 ;
36913 void *argp1 = 0 ;
36914 int res1 = 0 ;
36915 bool val2 ;
36916 int ecode2 = 0 ;
36917 PyObject * obj0 = 0 ;
36918 PyObject * obj1 = 0 ;
36919 char * kwnames[] = {
36920 (char *) "self",(char *) "accept", NULL
36921 };
36922
36923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
36924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36925 if (!SWIG_IsOK(res1)) {
36926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
36927 }
36928 arg1 = reinterpret_cast< wxWindow * >(argp1);
36929 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36930 if (!SWIG_IsOK(ecode2)) {
36931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
36932 }
36933 arg2 = static_cast< bool >(val2);
36934 {
36935 PyThreadState* __tstate = wxPyBeginAllowThreads();
36936 (arg1)->DragAcceptFiles(arg2);
36937 wxPyEndAllowThreads(__tstate);
36938 if (PyErr_Occurred()) SWIG_fail;
36939 }
36940 resultobj = SWIG_Py_Void();
36941 return resultobj;
36942 fail:
36943 return NULL;
36944 }
36945
36946
36947 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36948 PyObject *resultobj = 0;
36949 wxWindow *arg1 = (wxWindow *) 0 ;
36950 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
36951 void *argp1 = 0 ;
36952 int res1 = 0 ;
36953 int res2 = 0 ;
36954 PyObject * obj0 = 0 ;
36955 PyObject * obj1 = 0 ;
36956 char * kwnames[] = {
36957 (char *) "self",(char *) "constraints", NULL
36958 };
36959
36960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
36961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36962 if (!SWIG_IsOK(res1)) {
36963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
36964 }
36965 arg1 = reinterpret_cast< wxWindow * >(argp1);
36966 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
36967 if (!SWIG_IsOK(res2)) {
36968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
36969 }
36970 {
36971 PyThreadState* __tstate = wxPyBeginAllowThreads();
36972 (arg1)->SetConstraints(arg2);
36973 wxPyEndAllowThreads(__tstate);
36974 if (PyErr_Occurred()) SWIG_fail;
36975 }
36976 resultobj = SWIG_Py_Void();
36977 return resultobj;
36978 fail:
36979 return NULL;
36980 }
36981
36982
36983 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36984 PyObject *resultobj = 0;
36985 wxWindow *arg1 = (wxWindow *) 0 ;
36986 wxLayoutConstraints *result = 0 ;
36987 void *argp1 = 0 ;
36988 int res1 = 0 ;
36989 PyObject *swig_obj[1] ;
36990
36991 if (!args) SWIG_fail;
36992 swig_obj[0] = args;
36993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36994 if (!SWIG_IsOK(res1)) {
36995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
36996 }
36997 arg1 = reinterpret_cast< wxWindow * >(argp1);
36998 {
36999 PyThreadState* __tstate = wxPyBeginAllowThreads();
37000 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37001 wxPyEndAllowThreads(__tstate);
37002 if (PyErr_Occurred()) SWIG_fail;
37003 }
37004 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37005 return resultobj;
37006 fail:
37007 return NULL;
37008 }
37009
37010
37011 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37012 PyObject *resultobj = 0;
37013 wxWindow *arg1 = (wxWindow *) 0 ;
37014 bool arg2 ;
37015 void *argp1 = 0 ;
37016 int res1 = 0 ;
37017 bool val2 ;
37018 int ecode2 = 0 ;
37019 PyObject * obj0 = 0 ;
37020 PyObject * obj1 = 0 ;
37021 char * kwnames[] = {
37022 (char *) "self",(char *) "autoLayout", NULL
37023 };
37024
37025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37027 if (!SWIG_IsOK(res1)) {
37028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37029 }
37030 arg1 = reinterpret_cast< wxWindow * >(argp1);
37031 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37032 if (!SWIG_IsOK(ecode2)) {
37033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37034 }
37035 arg2 = static_cast< bool >(val2);
37036 {
37037 PyThreadState* __tstate = wxPyBeginAllowThreads();
37038 (arg1)->SetAutoLayout(arg2);
37039 wxPyEndAllowThreads(__tstate);
37040 if (PyErr_Occurred()) SWIG_fail;
37041 }
37042 resultobj = SWIG_Py_Void();
37043 return resultobj;
37044 fail:
37045 return NULL;
37046 }
37047
37048
37049 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37050 PyObject *resultobj = 0;
37051 wxWindow *arg1 = (wxWindow *) 0 ;
37052 bool result;
37053 void *argp1 = 0 ;
37054 int res1 = 0 ;
37055 PyObject *swig_obj[1] ;
37056
37057 if (!args) SWIG_fail;
37058 swig_obj[0] = args;
37059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37060 if (!SWIG_IsOK(res1)) {
37061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37062 }
37063 arg1 = reinterpret_cast< wxWindow * >(argp1);
37064 {
37065 PyThreadState* __tstate = wxPyBeginAllowThreads();
37066 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37067 wxPyEndAllowThreads(__tstate);
37068 if (PyErr_Occurred()) SWIG_fail;
37069 }
37070 {
37071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37072 }
37073 return resultobj;
37074 fail:
37075 return NULL;
37076 }
37077
37078
37079 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37080 PyObject *resultobj = 0;
37081 wxWindow *arg1 = (wxWindow *) 0 ;
37082 bool result;
37083 void *argp1 = 0 ;
37084 int res1 = 0 ;
37085 PyObject *swig_obj[1] ;
37086
37087 if (!args) SWIG_fail;
37088 swig_obj[0] = args;
37089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37090 if (!SWIG_IsOK(res1)) {
37091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37092 }
37093 arg1 = reinterpret_cast< wxWindow * >(argp1);
37094 {
37095 PyThreadState* __tstate = wxPyBeginAllowThreads();
37096 result = (bool)(arg1)->Layout();
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 {
37101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37102 }
37103 return resultobj;
37104 fail:
37105 return NULL;
37106 }
37107
37108
37109 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37110 PyObject *resultobj = 0;
37111 wxWindow *arg1 = (wxWindow *) 0 ;
37112 wxSizer *arg2 = (wxSizer *) 0 ;
37113 bool arg3 = (bool) true ;
37114 void *argp1 = 0 ;
37115 int res1 = 0 ;
37116 int res2 = 0 ;
37117 bool val3 ;
37118 int ecode3 = 0 ;
37119 PyObject * obj0 = 0 ;
37120 PyObject * obj1 = 0 ;
37121 PyObject * obj2 = 0 ;
37122 char * kwnames[] = {
37123 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37124 };
37125
37126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37128 if (!SWIG_IsOK(res1)) {
37129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37130 }
37131 arg1 = reinterpret_cast< wxWindow * >(argp1);
37132 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37133 if (!SWIG_IsOK(res2)) {
37134 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37135 }
37136 if (obj2) {
37137 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37138 if (!SWIG_IsOK(ecode3)) {
37139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37140 }
37141 arg3 = static_cast< bool >(val3);
37142 }
37143 {
37144 PyThreadState* __tstate = wxPyBeginAllowThreads();
37145 (arg1)->SetSizer(arg2,arg3);
37146 wxPyEndAllowThreads(__tstate);
37147 if (PyErr_Occurred()) SWIG_fail;
37148 }
37149 resultobj = SWIG_Py_Void();
37150 return resultobj;
37151 fail:
37152 return NULL;
37153 }
37154
37155
37156 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37157 PyObject *resultobj = 0;
37158 wxWindow *arg1 = (wxWindow *) 0 ;
37159 wxSizer *arg2 = (wxSizer *) 0 ;
37160 bool arg3 = (bool) true ;
37161 void *argp1 = 0 ;
37162 int res1 = 0 ;
37163 int res2 = 0 ;
37164 bool val3 ;
37165 int ecode3 = 0 ;
37166 PyObject * obj0 = 0 ;
37167 PyObject * obj1 = 0 ;
37168 PyObject * obj2 = 0 ;
37169 char * kwnames[] = {
37170 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37171 };
37172
37173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37175 if (!SWIG_IsOK(res1)) {
37176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37177 }
37178 arg1 = reinterpret_cast< wxWindow * >(argp1);
37179 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37180 if (!SWIG_IsOK(res2)) {
37181 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37182 }
37183 if (obj2) {
37184 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37185 if (!SWIG_IsOK(ecode3)) {
37186 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37187 }
37188 arg3 = static_cast< bool >(val3);
37189 }
37190 {
37191 PyThreadState* __tstate = wxPyBeginAllowThreads();
37192 (arg1)->SetSizerAndFit(arg2,arg3);
37193 wxPyEndAllowThreads(__tstate);
37194 if (PyErr_Occurred()) SWIG_fail;
37195 }
37196 resultobj = SWIG_Py_Void();
37197 return resultobj;
37198 fail:
37199 return NULL;
37200 }
37201
37202
37203 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37204 PyObject *resultobj = 0;
37205 wxWindow *arg1 = (wxWindow *) 0 ;
37206 wxSizer *result = 0 ;
37207 void *argp1 = 0 ;
37208 int res1 = 0 ;
37209 PyObject *swig_obj[1] ;
37210
37211 if (!args) SWIG_fail;
37212 swig_obj[0] = args;
37213 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37214 if (!SWIG_IsOK(res1)) {
37215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37216 }
37217 arg1 = reinterpret_cast< wxWindow * >(argp1);
37218 {
37219 PyThreadState* __tstate = wxPyBeginAllowThreads();
37220 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37221 wxPyEndAllowThreads(__tstate);
37222 if (PyErr_Occurred()) SWIG_fail;
37223 }
37224 {
37225 resultobj = wxPyMake_wxObject(result, (bool)0);
37226 }
37227 return resultobj;
37228 fail:
37229 return NULL;
37230 }
37231
37232
37233 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37234 PyObject *resultobj = 0;
37235 wxWindow *arg1 = (wxWindow *) 0 ;
37236 wxSizer *arg2 = (wxSizer *) 0 ;
37237 void *argp1 = 0 ;
37238 int res1 = 0 ;
37239 void *argp2 = 0 ;
37240 int res2 = 0 ;
37241 PyObject * obj0 = 0 ;
37242 PyObject * obj1 = 0 ;
37243 char * kwnames[] = {
37244 (char *) "self",(char *) "sizer", NULL
37245 };
37246
37247 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37248 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37249 if (!SWIG_IsOK(res1)) {
37250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37251 }
37252 arg1 = reinterpret_cast< wxWindow * >(argp1);
37253 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37254 if (!SWIG_IsOK(res2)) {
37255 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37256 }
37257 arg2 = reinterpret_cast< wxSizer * >(argp2);
37258 {
37259 PyThreadState* __tstate = wxPyBeginAllowThreads();
37260 (arg1)->SetContainingSizer(arg2);
37261 wxPyEndAllowThreads(__tstate);
37262 if (PyErr_Occurred()) SWIG_fail;
37263 }
37264 resultobj = SWIG_Py_Void();
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37272 PyObject *resultobj = 0;
37273 wxWindow *arg1 = (wxWindow *) 0 ;
37274 wxSizer *result = 0 ;
37275 void *argp1 = 0 ;
37276 int res1 = 0 ;
37277 PyObject *swig_obj[1] ;
37278
37279 if (!args) SWIG_fail;
37280 swig_obj[0] = args;
37281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37282 if (!SWIG_IsOK(res1)) {
37283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37284 }
37285 arg1 = reinterpret_cast< wxWindow * >(argp1);
37286 {
37287 PyThreadState* __tstate = wxPyBeginAllowThreads();
37288 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37289 wxPyEndAllowThreads(__tstate);
37290 if (PyErr_Occurred()) SWIG_fail;
37291 }
37292 {
37293 resultobj = wxPyMake_wxObject(result, (bool)0);
37294 }
37295 return resultobj;
37296 fail:
37297 return NULL;
37298 }
37299
37300
37301 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37302 PyObject *resultobj = 0;
37303 wxWindow *arg1 = (wxWindow *) 0 ;
37304 void *argp1 = 0 ;
37305 int res1 = 0 ;
37306 PyObject *swig_obj[1] ;
37307
37308 if (!args) SWIG_fail;
37309 swig_obj[0] = args;
37310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37311 if (!SWIG_IsOK(res1)) {
37312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37313 }
37314 arg1 = reinterpret_cast< wxWindow * >(argp1);
37315 {
37316 PyThreadState* __tstate = wxPyBeginAllowThreads();
37317 (arg1)->InheritAttributes();
37318 wxPyEndAllowThreads(__tstate);
37319 if (PyErr_Occurred()) SWIG_fail;
37320 }
37321 resultobj = SWIG_Py_Void();
37322 return resultobj;
37323 fail:
37324 return NULL;
37325 }
37326
37327
37328 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37329 PyObject *resultobj = 0;
37330 wxWindow *arg1 = (wxWindow *) 0 ;
37331 bool result;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 PyObject *swig_obj[1] ;
37335
37336 if (!args) SWIG_fail;
37337 swig_obj[0] = args;
37338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37339 if (!SWIG_IsOK(res1)) {
37340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37341 }
37342 arg1 = reinterpret_cast< wxWindow * >(argp1);
37343 {
37344 PyThreadState* __tstate = wxPyBeginAllowThreads();
37345 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37346 wxPyEndAllowThreads(__tstate);
37347 if (PyErr_Occurred()) SWIG_fail;
37348 }
37349 {
37350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37351 }
37352 return resultobj;
37353 fail:
37354 return NULL;
37355 }
37356
37357
37358 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37359 PyObject *obj;
37360 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37361 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37362 return SWIG_Py_Void();
37363 }
37364
37365 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37366 return SWIG_Python_InitShadowInstance(args);
37367 }
37368
37369 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj = 0;
37371 long arg1 ;
37372 wxWindow *arg2 = (wxWindow *) NULL ;
37373 wxWindow *result = 0 ;
37374 long val1 ;
37375 int ecode1 = 0 ;
37376 void *argp2 = 0 ;
37377 int res2 = 0 ;
37378 PyObject * obj0 = 0 ;
37379 PyObject * obj1 = 0 ;
37380 char * kwnames[] = {
37381 (char *) "id",(char *) "parent", NULL
37382 };
37383
37384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37385 ecode1 = SWIG_AsVal_long(obj0, &val1);
37386 if (!SWIG_IsOK(ecode1)) {
37387 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37388 }
37389 arg1 = static_cast< long >(val1);
37390 if (obj1) {
37391 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37392 if (!SWIG_IsOK(res2)) {
37393 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37394 }
37395 arg2 = reinterpret_cast< wxWindow * >(argp2);
37396 }
37397 {
37398 if (!wxPyCheckForApp()) SWIG_fail;
37399 PyThreadState* __tstate = wxPyBeginAllowThreads();
37400 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37401 wxPyEndAllowThreads(__tstate);
37402 if (PyErr_Occurred()) SWIG_fail;
37403 }
37404 {
37405 resultobj = wxPyMake_wxObject(result, 0);
37406 }
37407 return resultobj;
37408 fail:
37409 return NULL;
37410 }
37411
37412
37413 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37414 PyObject *resultobj = 0;
37415 wxString *arg1 = 0 ;
37416 wxWindow *arg2 = (wxWindow *) NULL ;
37417 wxWindow *result = 0 ;
37418 bool temp1 = false ;
37419 void *argp2 = 0 ;
37420 int res2 = 0 ;
37421 PyObject * obj0 = 0 ;
37422 PyObject * obj1 = 0 ;
37423 char * kwnames[] = {
37424 (char *) "name",(char *) "parent", NULL
37425 };
37426
37427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37428 {
37429 arg1 = wxString_in_helper(obj0);
37430 if (arg1 == NULL) SWIG_fail;
37431 temp1 = true;
37432 }
37433 if (obj1) {
37434 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37435 if (!SWIG_IsOK(res2)) {
37436 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37437 }
37438 arg2 = reinterpret_cast< wxWindow * >(argp2);
37439 }
37440 {
37441 if (!wxPyCheckForApp()) SWIG_fail;
37442 PyThreadState* __tstate = wxPyBeginAllowThreads();
37443 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37444 wxPyEndAllowThreads(__tstate);
37445 if (PyErr_Occurred()) SWIG_fail;
37446 }
37447 {
37448 resultobj = wxPyMake_wxObject(result, 0);
37449 }
37450 {
37451 if (temp1)
37452 delete arg1;
37453 }
37454 return resultobj;
37455 fail:
37456 {
37457 if (temp1)
37458 delete arg1;
37459 }
37460 return NULL;
37461 }
37462
37463
37464 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37465 PyObject *resultobj = 0;
37466 wxString *arg1 = 0 ;
37467 wxWindow *arg2 = (wxWindow *) NULL ;
37468 wxWindow *result = 0 ;
37469 bool temp1 = false ;
37470 void *argp2 = 0 ;
37471 int res2 = 0 ;
37472 PyObject * obj0 = 0 ;
37473 PyObject * obj1 = 0 ;
37474 char * kwnames[] = {
37475 (char *) "label",(char *) "parent", NULL
37476 };
37477
37478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37479 {
37480 arg1 = wxString_in_helper(obj0);
37481 if (arg1 == NULL) SWIG_fail;
37482 temp1 = true;
37483 }
37484 if (obj1) {
37485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37486 if (!SWIG_IsOK(res2)) {
37487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37488 }
37489 arg2 = reinterpret_cast< wxWindow * >(argp2);
37490 }
37491 {
37492 if (!wxPyCheckForApp()) SWIG_fail;
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37495 wxPyEndAllowThreads(__tstate);
37496 if (PyErr_Occurred()) SWIG_fail;
37497 }
37498 {
37499 resultobj = wxPyMake_wxObject(result, 0);
37500 }
37501 {
37502 if (temp1)
37503 delete arg1;
37504 }
37505 return resultobj;
37506 fail:
37507 {
37508 if (temp1)
37509 delete arg1;
37510 }
37511 return NULL;
37512 }
37513
37514
37515 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37516 PyObject *resultobj = 0;
37517 wxWindow *arg1 = (wxWindow *) 0 ;
37518 unsigned long arg2 ;
37519 wxWindow *result = 0 ;
37520 void *argp1 = 0 ;
37521 int res1 = 0 ;
37522 unsigned long val2 ;
37523 int ecode2 = 0 ;
37524 PyObject * obj0 = 0 ;
37525 PyObject * obj1 = 0 ;
37526 char * kwnames[] = {
37527 (char *) "parent",(char *) "_hWnd", NULL
37528 };
37529
37530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37532 if (!SWIG_IsOK(res1)) {
37533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37534 }
37535 arg1 = reinterpret_cast< wxWindow * >(argp1);
37536 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37537 if (!SWIG_IsOK(ecode2)) {
37538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37539 }
37540 arg2 = static_cast< unsigned long >(val2);
37541 {
37542 PyThreadState* __tstate = wxPyBeginAllowThreads();
37543 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37544 wxPyEndAllowThreads(__tstate);
37545 if (PyErr_Occurred()) SWIG_fail;
37546 }
37547 {
37548 resultobj = wxPyMake_wxObject(result, 0);
37549 }
37550 return resultobj;
37551 fail:
37552 return NULL;
37553 }
37554
37555
37556 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37557 PyObject *resultobj = 0;
37558 PyObject *result = 0 ;
37559
37560 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37561 {
37562 PyThreadState* __tstate = wxPyBeginAllowThreads();
37563 result = (PyObject *)GetTopLevelWindows();
37564 wxPyEndAllowThreads(__tstate);
37565 if (PyErr_Occurred()) SWIG_fail;
37566 }
37567 resultobj = result;
37568 return resultobj;
37569 fail:
37570 return NULL;
37571 }
37572
37573
37574 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37575 PyObject *resultobj = 0;
37576 wxValidator *result = 0 ;
37577
37578 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37579 {
37580 PyThreadState* __tstate = wxPyBeginAllowThreads();
37581 result = (wxValidator *)new wxValidator();
37582 wxPyEndAllowThreads(__tstate);
37583 if (PyErr_Occurred()) SWIG_fail;
37584 }
37585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37586 return resultobj;
37587 fail:
37588 return NULL;
37589 }
37590
37591
37592 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37593 PyObject *resultobj = 0;
37594 wxValidator *arg1 = (wxValidator *) 0 ;
37595 wxValidator *result = 0 ;
37596 void *argp1 = 0 ;
37597 int res1 = 0 ;
37598 PyObject *swig_obj[1] ;
37599
37600 if (!args) SWIG_fail;
37601 swig_obj[0] = args;
37602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37603 if (!SWIG_IsOK(res1)) {
37604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37605 }
37606 arg1 = reinterpret_cast< wxValidator * >(argp1);
37607 {
37608 PyThreadState* __tstate = wxPyBeginAllowThreads();
37609 result = (wxValidator *)(arg1)->Clone();
37610 wxPyEndAllowThreads(__tstate);
37611 if (PyErr_Occurred()) SWIG_fail;
37612 }
37613 {
37614 resultobj = wxPyMake_wxObject(result, 0);
37615 }
37616 return resultobj;
37617 fail:
37618 return NULL;
37619 }
37620
37621
37622 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37623 PyObject *resultobj = 0;
37624 wxValidator *arg1 = (wxValidator *) 0 ;
37625 wxWindow *arg2 = (wxWindow *) 0 ;
37626 bool result;
37627 void *argp1 = 0 ;
37628 int res1 = 0 ;
37629 void *argp2 = 0 ;
37630 int res2 = 0 ;
37631 PyObject * obj0 = 0 ;
37632 PyObject * obj1 = 0 ;
37633 char * kwnames[] = {
37634 (char *) "self",(char *) "parent", NULL
37635 };
37636
37637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37639 if (!SWIG_IsOK(res1)) {
37640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37641 }
37642 arg1 = reinterpret_cast< wxValidator * >(argp1);
37643 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37644 if (!SWIG_IsOK(res2)) {
37645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37646 }
37647 arg2 = reinterpret_cast< wxWindow * >(argp2);
37648 {
37649 PyThreadState* __tstate = wxPyBeginAllowThreads();
37650 result = (bool)(arg1)->Validate(arg2);
37651 wxPyEndAllowThreads(__tstate);
37652 if (PyErr_Occurred()) SWIG_fail;
37653 }
37654 {
37655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37656 }
37657 return resultobj;
37658 fail:
37659 return NULL;
37660 }
37661
37662
37663 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37664 PyObject *resultobj = 0;
37665 wxValidator *arg1 = (wxValidator *) 0 ;
37666 bool result;
37667 void *argp1 = 0 ;
37668 int res1 = 0 ;
37669 PyObject *swig_obj[1] ;
37670
37671 if (!args) SWIG_fail;
37672 swig_obj[0] = args;
37673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37674 if (!SWIG_IsOK(res1)) {
37675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37676 }
37677 arg1 = reinterpret_cast< wxValidator * >(argp1);
37678 {
37679 PyThreadState* __tstate = wxPyBeginAllowThreads();
37680 result = (bool)(arg1)->TransferToWindow();
37681 wxPyEndAllowThreads(__tstate);
37682 if (PyErr_Occurred()) SWIG_fail;
37683 }
37684 {
37685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37686 }
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37694 PyObject *resultobj = 0;
37695 wxValidator *arg1 = (wxValidator *) 0 ;
37696 bool result;
37697 void *argp1 = 0 ;
37698 int res1 = 0 ;
37699 PyObject *swig_obj[1] ;
37700
37701 if (!args) SWIG_fail;
37702 swig_obj[0] = args;
37703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37704 if (!SWIG_IsOK(res1)) {
37705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37706 }
37707 arg1 = reinterpret_cast< wxValidator * >(argp1);
37708 {
37709 PyThreadState* __tstate = wxPyBeginAllowThreads();
37710 result = (bool)(arg1)->TransferFromWindow();
37711 wxPyEndAllowThreads(__tstate);
37712 if (PyErr_Occurred()) SWIG_fail;
37713 }
37714 {
37715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37716 }
37717 return resultobj;
37718 fail:
37719 return NULL;
37720 }
37721
37722
37723 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37724 PyObject *resultobj = 0;
37725 wxValidator *arg1 = (wxValidator *) 0 ;
37726 wxWindow *result = 0 ;
37727 void *argp1 = 0 ;
37728 int res1 = 0 ;
37729 PyObject *swig_obj[1] ;
37730
37731 if (!args) SWIG_fail;
37732 swig_obj[0] = args;
37733 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37734 if (!SWIG_IsOK(res1)) {
37735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37736 }
37737 arg1 = reinterpret_cast< wxValidator * >(argp1);
37738 {
37739 PyThreadState* __tstate = wxPyBeginAllowThreads();
37740 result = (wxWindow *)(arg1)->GetWindow();
37741 wxPyEndAllowThreads(__tstate);
37742 if (PyErr_Occurred()) SWIG_fail;
37743 }
37744 {
37745 resultobj = wxPyMake_wxObject(result, 0);
37746 }
37747 return resultobj;
37748 fail:
37749 return NULL;
37750 }
37751
37752
37753 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37754 PyObject *resultobj = 0;
37755 wxValidator *arg1 = (wxValidator *) 0 ;
37756 wxWindow *arg2 = (wxWindow *) 0 ;
37757 void *argp1 = 0 ;
37758 int res1 = 0 ;
37759 void *argp2 = 0 ;
37760 int res2 = 0 ;
37761 PyObject * obj0 = 0 ;
37762 PyObject * obj1 = 0 ;
37763 char * kwnames[] = {
37764 (char *) "self",(char *) "window", NULL
37765 };
37766
37767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37769 if (!SWIG_IsOK(res1)) {
37770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37771 }
37772 arg1 = reinterpret_cast< wxValidator * >(argp1);
37773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37774 if (!SWIG_IsOK(res2)) {
37775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37776 }
37777 arg2 = reinterpret_cast< wxWindow * >(argp2);
37778 {
37779 PyThreadState* __tstate = wxPyBeginAllowThreads();
37780 (arg1)->SetWindow(arg2);
37781 wxPyEndAllowThreads(__tstate);
37782 if (PyErr_Occurred()) SWIG_fail;
37783 }
37784 resultobj = SWIG_Py_Void();
37785 return resultobj;
37786 fail:
37787 return NULL;
37788 }
37789
37790
37791 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37792 PyObject *resultobj = 0;
37793 bool result;
37794
37795 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37796 {
37797 PyThreadState* __tstate = wxPyBeginAllowThreads();
37798 result = (bool)wxValidator::IsSilent();
37799 wxPyEndAllowThreads(__tstate);
37800 if (PyErr_Occurred()) SWIG_fail;
37801 }
37802 {
37803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37804 }
37805 return resultobj;
37806 fail:
37807 return NULL;
37808 }
37809
37810
37811 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37812 PyObject *resultobj = 0;
37813 int arg1 = (int) true ;
37814 int val1 ;
37815 int ecode1 = 0 ;
37816 PyObject * obj0 = 0 ;
37817 char * kwnames[] = {
37818 (char *) "doIt", NULL
37819 };
37820
37821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37822 if (obj0) {
37823 ecode1 = SWIG_AsVal_int(obj0, &val1);
37824 if (!SWIG_IsOK(ecode1)) {
37825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37826 }
37827 arg1 = static_cast< int >(val1);
37828 }
37829 {
37830 PyThreadState* __tstate = wxPyBeginAllowThreads();
37831 wxValidator::SetBellOnError(arg1);
37832 wxPyEndAllowThreads(__tstate);
37833 if (PyErr_Occurred()) SWIG_fail;
37834 }
37835 resultobj = SWIG_Py_Void();
37836 return resultobj;
37837 fail:
37838 return NULL;
37839 }
37840
37841
37842 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37843 PyObject *obj;
37844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37845 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
37846 return SWIG_Py_Void();
37847 }
37848
37849 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37850 return SWIG_Python_InitShadowInstance(args);
37851 }
37852
37853 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37854 PyObject *resultobj = 0;
37855 wxPyValidator *result = 0 ;
37856
37857 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
37858 {
37859 PyThreadState* __tstate = wxPyBeginAllowThreads();
37860 result = (wxPyValidator *)new wxPyValidator();
37861 wxPyEndAllowThreads(__tstate);
37862 if (PyErr_Occurred()) SWIG_fail;
37863 }
37864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
37865 return resultobj;
37866 fail:
37867 return NULL;
37868 }
37869
37870
37871 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37872 PyObject *resultobj = 0;
37873 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
37874 PyObject *arg2 = (PyObject *) 0 ;
37875 PyObject *arg3 = (PyObject *) 0 ;
37876 int arg4 = (int) true ;
37877 void *argp1 = 0 ;
37878 int res1 = 0 ;
37879 int val4 ;
37880 int ecode4 = 0 ;
37881 PyObject * obj0 = 0 ;
37882 PyObject * obj1 = 0 ;
37883 PyObject * obj2 = 0 ;
37884 PyObject * obj3 = 0 ;
37885 char * kwnames[] = {
37886 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
37887 };
37888
37889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
37891 if (!SWIG_IsOK(res1)) {
37892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
37893 }
37894 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
37895 arg2 = obj1;
37896 arg3 = obj2;
37897 if (obj3) {
37898 ecode4 = SWIG_AsVal_int(obj3, &val4);
37899 if (!SWIG_IsOK(ecode4)) {
37900 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
37901 }
37902 arg4 = static_cast< int >(val4);
37903 }
37904 {
37905 PyThreadState* __tstate = wxPyBeginAllowThreads();
37906 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
37907 wxPyEndAllowThreads(__tstate);
37908 if (PyErr_Occurred()) SWIG_fail;
37909 }
37910 resultobj = SWIG_Py_Void();
37911 return resultobj;
37912 fail:
37913 return NULL;
37914 }
37915
37916
37917 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37918 PyObject *obj;
37919 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37920 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
37921 return SWIG_Py_Void();
37922 }
37923
37924 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37925 return SWIG_Python_InitShadowInstance(args);
37926 }
37927
37928 SWIGINTERN int DefaultValidator_set(PyObject *) {
37929 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
37930 return 1;
37931 }
37932
37933
37934 SWIGINTERN PyObject *DefaultValidator_get(void) {
37935 PyObject *pyobj = 0;
37936
37937 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
37938 return pyobj;
37939 }
37940
37941
37942 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37943 PyObject *resultobj = 0;
37944 wxString const &arg1_defvalue = wxPyEmptyString ;
37945 wxString *arg1 = (wxString *) &arg1_defvalue ;
37946 long arg2 = (long) 0 ;
37947 wxMenu *result = 0 ;
37948 bool temp1 = false ;
37949 long val2 ;
37950 int ecode2 = 0 ;
37951 PyObject * obj0 = 0 ;
37952 PyObject * obj1 = 0 ;
37953 char * kwnames[] = {
37954 (char *) "title",(char *) "style", NULL
37955 };
37956
37957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
37958 if (obj0) {
37959 {
37960 arg1 = wxString_in_helper(obj0);
37961 if (arg1 == NULL) SWIG_fail;
37962 temp1 = true;
37963 }
37964 }
37965 if (obj1) {
37966 ecode2 = SWIG_AsVal_long(obj1, &val2);
37967 if (!SWIG_IsOK(ecode2)) {
37968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
37969 }
37970 arg2 = static_cast< long >(val2);
37971 }
37972 {
37973 if (!wxPyCheckForApp()) SWIG_fail;
37974 PyThreadState* __tstate = wxPyBeginAllowThreads();
37975 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
37976 wxPyEndAllowThreads(__tstate);
37977 if (PyErr_Occurred()) SWIG_fail;
37978 }
37979 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
37980 {
37981 if (temp1)
37982 delete arg1;
37983 }
37984 return resultobj;
37985 fail:
37986 {
37987 if (temp1)
37988 delete arg1;
37989 }
37990 return NULL;
37991 }
37992
37993
37994 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37995 PyObject *resultobj = 0;
37996 wxMenu *arg1 = (wxMenu *) 0 ;
37997 int arg2 ;
37998 wxString *arg3 = 0 ;
37999 wxString const &arg4_defvalue = wxPyEmptyString ;
38000 wxString *arg4 = (wxString *) &arg4_defvalue ;
38001 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38002 wxMenuItem *result = 0 ;
38003 void *argp1 = 0 ;
38004 int res1 = 0 ;
38005 int val2 ;
38006 int ecode2 = 0 ;
38007 bool temp3 = false ;
38008 bool temp4 = false ;
38009 int val5 ;
38010 int ecode5 = 0 ;
38011 PyObject * obj0 = 0 ;
38012 PyObject * obj1 = 0 ;
38013 PyObject * obj2 = 0 ;
38014 PyObject * obj3 = 0 ;
38015 PyObject * obj4 = 0 ;
38016 char * kwnames[] = {
38017 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38018 };
38019
38020 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38021 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38022 if (!SWIG_IsOK(res1)) {
38023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38024 }
38025 arg1 = reinterpret_cast< wxMenu * >(argp1);
38026 ecode2 = SWIG_AsVal_int(obj1, &val2);
38027 if (!SWIG_IsOK(ecode2)) {
38028 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38029 }
38030 arg2 = static_cast< int >(val2);
38031 {
38032 arg3 = wxString_in_helper(obj2);
38033 if (arg3 == NULL) SWIG_fail;
38034 temp3 = true;
38035 }
38036 if (obj3) {
38037 {
38038 arg4 = wxString_in_helper(obj3);
38039 if (arg4 == NULL) SWIG_fail;
38040 temp4 = true;
38041 }
38042 }
38043 if (obj4) {
38044 ecode5 = SWIG_AsVal_int(obj4, &val5);
38045 if (!SWIG_IsOK(ecode5)) {
38046 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38047 }
38048 arg5 = static_cast< wxItemKind >(val5);
38049 }
38050 {
38051 PyThreadState* __tstate = wxPyBeginAllowThreads();
38052 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38053 wxPyEndAllowThreads(__tstate);
38054 if (PyErr_Occurred()) SWIG_fail;
38055 }
38056 {
38057 resultobj = wxPyMake_wxObject(result, (bool)0);
38058 }
38059 {
38060 if (temp3)
38061 delete arg3;
38062 }
38063 {
38064 if (temp4)
38065 delete arg4;
38066 }
38067 return resultobj;
38068 fail:
38069 {
38070 if (temp3)
38071 delete arg3;
38072 }
38073 {
38074 if (temp4)
38075 delete arg4;
38076 }
38077 return NULL;
38078 }
38079
38080
38081 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38082 PyObject *resultobj = 0;
38083 wxMenu *arg1 = (wxMenu *) 0 ;
38084 wxMenuItem *result = 0 ;
38085 void *argp1 = 0 ;
38086 int res1 = 0 ;
38087 PyObject *swig_obj[1] ;
38088
38089 if (!args) SWIG_fail;
38090 swig_obj[0] = args;
38091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38092 if (!SWIG_IsOK(res1)) {
38093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38094 }
38095 arg1 = reinterpret_cast< wxMenu * >(argp1);
38096 {
38097 PyThreadState* __tstate = wxPyBeginAllowThreads();
38098 result = (wxMenuItem *)(arg1)->AppendSeparator();
38099 wxPyEndAllowThreads(__tstate);
38100 if (PyErr_Occurred()) SWIG_fail;
38101 }
38102 {
38103 resultobj = wxPyMake_wxObject(result, (bool)0);
38104 }
38105 return resultobj;
38106 fail:
38107 return NULL;
38108 }
38109
38110
38111 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38112 PyObject *resultobj = 0;
38113 wxMenu *arg1 = (wxMenu *) 0 ;
38114 int arg2 ;
38115 wxString *arg3 = 0 ;
38116 wxString const &arg4_defvalue = wxPyEmptyString ;
38117 wxString *arg4 = (wxString *) &arg4_defvalue ;
38118 wxMenuItem *result = 0 ;
38119 void *argp1 = 0 ;
38120 int res1 = 0 ;
38121 int val2 ;
38122 int ecode2 = 0 ;
38123 bool temp3 = false ;
38124 bool temp4 = false ;
38125 PyObject * obj0 = 0 ;
38126 PyObject * obj1 = 0 ;
38127 PyObject * obj2 = 0 ;
38128 PyObject * obj3 = 0 ;
38129 char * kwnames[] = {
38130 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38131 };
38132
38133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38135 if (!SWIG_IsOK(res1)) {
38136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38137 }
38138 arg1 = reinterpret_cast< wxMenu * >(argp1);
38139 ecode2 = SWIG_AsVal_int(obj1, &val2);
38140 if (!SWIG_IsOK(ecode2)) {
38141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38142 }
38143 arg2 = static_cast< int >(val2);
38144 {
38145 arg3 = wxString_in_helper(obj2);
38146 if (arg3 == NULL) SWIG_fail;
38147 temp3 = true;
38148 }
38149 if (obj3) {
38150 {
38151 arg4 = wxString_in_helper(obj3);
38152 if (arg4 == NULL) SWIG_fail;
38153 temp4 = true;
38154 }
38155 }
38156 {
38157 PyThreadState* __tstate = wxPyBeginAllowThreads();
38158 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38159 wxPyEndAllowThreads(__tstate);
38160 if (PyErr_Occurred()) SWIG_fail;
38161 }
38162 {
38163 resultobj = wxPyMake_wxObject(result, (bool)0);
38164 }
38165 {
38166 if (temp3)
38167 delete arg3;
38168 }
38169 {
38170 if (temp4)
38171 delete arg4;
38172 }
38173 return resultobj;
38174 fail:
38175 {
38176 if (temp3)
38177 delete arg3;
38178 }
38179 {
38180 if (temp4)
38181 delete arg4;
38182 }
38183 return NULL;
38184 }
38185
38186
38187 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38188 PyObject *resultobj = 0;
38189 wxMenu *arg1 = (wxMenu *) 0 ;
38190 int arg2 ;
38191 wxString *arg3 = 0 ;
38192 wxString const &arg4_defvalue = wxPyEmptyString ;
38193 wxString *arg4 = (wxString *) &arg4_defvalue ;
38194 wxMenuItem *result = 0 ;
38195 void *argp1 = 0 ;
38196 int res1 = 0 ;
38197 int val2 ;
38198 int ecode2 = 0 ;
38199 bool temp3 = false ;
38200 bool temp4 = false ;
38201 PyObject * obj0 = 0 ;
38202 PyObject * obj1 = 0 ;
38203 PyObject * obj2 = 0 ;
38204 PyObject * obj3 = 0 ;
38205 char * kwnames[] = {
38206 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38207 };
38208
38209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38211 if (!SWIG_IsOK(res1)) {
38212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38213 }
38214 arg1 = reinterpret_cast< wxMenu * >(argp1);
38215 ecode2 = SWIG_AsVal_int(obj1, &val2);
38216 if (!SWIG_IsOK(ecode2)) {
38217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38218 }
38219 arg2 = static_cast< int >(val2);
38220 {
38221 arg3 = wxString_in_helper(obj2);
38222 if (arg3 == NULL) SWIG_fail;
38223 temp3 = true;
38224 }
38225 if (obj3) {
38226 {
38227 arg4 = wxString_in_helper(obj3);
38228 if (arg4 == NULL) SWIG_fail;
38229 temp4 = true;
38230 }
38231 }
38232 {
38233 PyThreadState* __tstate = wxPyBeginAllowThreads();
38234 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38235 wxPyEndAllowThreads(__tstate);
38236 if (PyErr_Occurred()) SWIG_fail;
38237 }
38238 {
38239 resultobj = wxPyMake_wxObject(result, (bool)0);
38240 }
38241 {
38242 if (temp3)
38243 delete arg3;
38244 }
38245 {
38246 if (temp4)
38247 delete arg4;
38248 }
38249 return resultobj;
38250 fail:
38251 {
38252 if (temp3)
38253 delete arg3;
38254 }
38255 {
38256 if (temp4)
38257 delete arg4;
38258 }
38259 return NULL;
38260 }
38261
38262
38263 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38264 PyObject *resultobj = 0;
38265 wxMenu *arg1 = (wxMenu *) 0 ;
38266 int arg2 ;
38267 wxString *arg3 = 0 ;
38268 wxMenu *arg4 = (wxMenu *) 0 ;
38269 wxString const &arg5_defvalue = wxPyEmptyString ;
38270 wxString *arg5 = (wxString *) &arg5_defvalue ;
38271 wxMenuItem *result = 0 ;
38272 void *argp1 = 0 ;
38273 int res1 = 0 ;
38274 int val2 ;
38275 int ecode2 = 0 ;
38276 bool temp3 = false ;
38277 void *argp4 = 0 ;
38278 int res4 = 0 ;
38279 bool temp5 = false ;
38280 PyObject * obj0 = 0 ;
38281 PyObject * obj1 = 0 ;
38282 PyObject * obj2 = 0 ;
38283 PyObject * obj3 = 0 ;
38284 PyObject * obj4 = 0 ;
38285 char * kwnames[] = {
38286 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38287 };
38288
38289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38291 if (!SWIG_IsOK(res1)) {
38292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38293 }
38294 arg1 = reinterpret_cast< wxMenu * >(argp1);
38295 ecode2 = SWIG_AsVal_int(obj1, &val2);
38296 if (!SWIG_IsOK(ecode2)) {
38297 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38298 }
38299 arg2 = static_cast< int >(val2);
38300 {
38301 arg3 = wxString_in_helper(obj2);
38302 if (arg3 == NULL) SWIG_fail;
38303 temp3 = true;
38304 }
38305 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38306 if (!SWIG_IsOK(res4)) {
38307 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38308 }
38309 arg4 = reinterpret_cast< wxMenu * >(argp4);
38310 if (obj4) {
38311 {
38312 arg5 = wxString_in_helper(obj4);
38313 if (arg5 == NULL) SWIG_fail;
38314 temp5 = true;
38315 }
38316 }
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = wxPyMake_wxObject(result, (bool)0);
38325 }
38326 {
38327 if (temp3)
38328 delete arg3;
38329 }
38330 {
38331 if (temp5)
38332 delete arg5;
38333 }
38334 return resultobj;
38335 fail:
38336 {
38337 if (temp3)
38338 delete arg3;
38339 }
38340 {
38341 if (temp5)
38342 delete arg5;
38343 }
38344 return NULL;
38345 }
38346
38347
38348 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38349 PyObject *resultobj = 0;
38350 wxMenu *arg1 = (wxMenu *) 0 ;
38351 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38352 wxMenuItem *result = 0 ;
38353 void *argp1 = 0 ;
38354 int res1 = 0 ;
38355 int res2 = 0 ;
38356 PyObject * obj0 = 0 ;
38357 PyObject * obj1 = 0 ;
38358 char * kwnames[] = {
38359 (char *) "self",(char *) "item", NULL
38360 };
38361
38362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38364 if (!SWIG_IsOK(res1)) {
38365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38366 }
38367 arg1 = reinterpret_cast< wxMenu * >(argp1);
38368 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38369 if (!SWIG_IsOK(res2)) {
38370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38371 }
38372 {
38373 PyThreadState* __tstate = wxPyBeginAllowThreads();
38374 result = (wxMenuItem *)(arg1)->Append(arg2);
38375 wxPyEndAllowThreads(__tstate);
38376 if (PyErr_Occurred()) SWIG_fail;
38377 }
38378 {
38379 resultobj = wxPyMake_wxObject(result, (bool)0);
38380 }
38381 return resultobj;
38382 fail:
38383 return NULL;
38384 }
38385
38386
38387 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38388 PyObject *resultobj = 0;
38389 wxMenu *arg1 = (wxMenu *) 0 ;
38390 size_t arg2 ;
38391 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38392 wxMenuItem *result = 0 ;
38393 void *argp1 = 0 ;
38394 int res1 = 0 ;
38395 size_t val2 ;
38396 int ecode2 = 0 ;
38397 int res3 = 0 ;
38398 PyObject * obj0 = 0 ;
38399 PyObject * obj1 = 0 ;
38400 PyObject * obj2 = 0 ;
38401 char * kwnames[] = {
38402 (char *) "self",(char *) "pos",(char *) "item", NULL
38403 };
38404
38405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38407 if (!SWIG_IsOK(res1)) {
38408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38409 }
38410 arg1 = reinterpret_cast< wxMenu * >(argp1);
38411 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38412 if (!SWIG_IsOK(ecode2)) {
38413 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38414 }
38415 arg2 = static_cast< size_t >(val2);
38416 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38417 if (!SWIG_IsOK(res3)) {
38418 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38419 }
38420 {
38421 PyThreadState* __tstate = wxPyBeginAllowThreads();
38422 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38423 wxPyEndAllowThreads(__tstate);
38424 if (PyErr_Occurred()) SWIG_fail;
38425 }
38426 {
38427 resultobj = wxPyMake_wxObject(result, (bool)0);
38428 }
38429 return resultobj;
38430 fail:
38431 return NULL;
38432 }
38433
38434
38435 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38436 PyObject *resultobj = 0;
38437 wxMenu *arg1 = (wxMenu *) 0 ;
38438 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38439 wxMenuItem *result = 0 ;
38440 void *argp1 = 0 ;
38441 int res1 = 0 ;
38442 int res2 = 0 ;
38443 PyObject * obj0 = 0 ;
38444 PyObject * obj1 = 0 ;
38445 char * kwnames[] = {
38446 (char *) "self",(char *) "item", NULL
38447 };
38448
38449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38451 if (!SWIG_IsOK(res1)) {
38452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38453 }
38454 arg1 = reinterpret_cast< wxMenu * >(argp1);
38455 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38456 if (!SWIG_IsOK(res2)) {
38457 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38458 }
38459 {
38460 PyThreadState* __tstate = wxPyBeginAllowThreads();
38461 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38462 wxPyEndAllowThreads(__tstate);
38463 if (PyErr_Occurred()) SWIG_fail;
38464 }
38465 {
38466 resultobj = wxPyMake_wxObject(result, (bool)0);
38467 }
38468 return resultobj;
38469 fail:
38470 return NULL;
38471 }
38472
38473
38474 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38475 PyObject *resultobj = 0;
38476 wxMenu *arg1 = (wxMenu *) 0 ;
38477 void *argp1 = 0 ;
38478 int res1 = 0 ;
38479 PyObject *swig_obj[1] ;
38480
38481 if (!args) SWIG_fail;
38482 swig_obj[0] = args;
38483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38484 if (!SWIG_IsOK(res1)) {
38485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38486 }
38487 arg1 = reinterpret_cast< wxMenu * >(argp1);
38488 {
38489 PyThreadState* __tstate = wxPyBeginAllowThreads();
38490 (arg1)->Break();
38491 wxPyEndAllowThreads(__tstate);
38492 if (PyErr_Occurred()) SWIG_fail;
38493 }
38494 resultobj = SWIG_Py_Void();
38495 return resultobj;
38496 fail:
38497 return NULL;
38498 }
38499
38500
38501 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38502 PyObject *resultobj = 0;
38503 wxMenu *arg1 = (wxMenu *) 0 ;
38504 size_t arg2 ;
38505 int arg3 ;
38506 wxString *arg4 = 0 ;
38507 wxString const &arg5_defvalue = wxPyEmptyString ;
38508 wxString *arg5 = (wxString *) &arg5_defvalue ;
38509 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38510 wxMenuItem *result = 0 ;
38511 void *argp1 = 0 ;
38512 int res1 = 0 ;
38513 size_t val2 ;
38514 int ecode2 = 0 ;
38515 int val3 ;
38516 int ecode3 = 0 ;
38517 bool temp4 = false ;
38518 bool temp5 = false ;
38519 int val6 ;
38520 int ecode6 = 0 ;
38521 PyObject * obj0 = 0 ;
38522 PyObject * obj1 = 0 ;
38523 PyObject * obj2 = 0 ;
38524 PyObject * obj3 = 0 ;
38525 PyObject * obj4 = 0 ;
38526 PyObject * obj5 = 0 ;
38527 char * kwnames[] = {
38528 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38529 };
38530
38531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38533 if (!SWIG_IsOK(res1)) {
38534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38535 }
38536 arg1 = reinterpret_cast< wxMenu * >(argp1);
38537 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38538 if (!SWIG_IsOK(ecode2)) {
38539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38540 }
38541 arg2 = static_cast< size_t >(val2);
38542 ecode3 = SWIG_AsVal_int(obj2, &val3);
38543 if (!SWIG_IsOK(ecode3)) {
38544 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38545 }
38546 arg3 = static_cast< int >(val3);
38547 {
38548 arg4 = wxString_in_helper(obj3);
38549 if (arg4 == NULL) SWIG_fail;
38550 temp4 = true;
38551 }
38552 if (obj4) {
38553 {
38554 arg5 = wxString_in_helper(obj4);
38555 if (arg5 == NULL) SWIG_fail;
38556 temp5 = true;
38557 }
38558 }
38559 if (obj5) {
38560 ecode6 = SWIG_AsVal_int(obj5, &val6);
38561 if (!SWIG_IsOK(ecode6)) {
38562 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38563 }
38564 arg6 = static_cast< wxItemKind >(val6);
38565 }
38566 {
38567 PyThreadState* __tstate = wxPyBeginAllowThreads();
38568 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38569 wxPyEndAllowThreads(__tstate);
38570 if (PyErr_Occurred()) SWIG_fail;
38571 }
38572 {
38573 resultobj = wxPyMake_wxObject(result, (bool)0);
38574 }
38575 {
38576 if (temp4)
38577 delete arg4;
38578 }
38579 {
38580 if (temp5)
38581 delete arg5;
38582 }
38583 return resultobj;
38584 fail:
38585 {
38586 if (temp4)
38587 delete arg4;
38588 }
38589 {
38590 if (temp5)
38591 delete arg5;
38592 }
38593 return NULL;
38594 }
38595
38596
38597 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38598 PyObject *resultobj = 0;
38599 wxMenu *arg1 = (wxMenu *) 0 ;
38600 size_t arg2 ;
38601 wxMenuItem *result = 0 ;
38602 void *argp1 = 0 ;
38603 int res1 = 0 ;
38604 size_t val2 ;
38605 int ecode2 = 0 ;
38606 PyObject * obj0 = 0 ;
38607 PyObject * obj1 = 0 ;
38608 char * kwnames[] = {
38609 (char *) "self",(char *) "pos", NULL
38610 };
38611
38612 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38613 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38614 if (!SWIG_IsOK(res1)) {
38615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38616 }
38617 arg1 = reinterpret_cast< wxMenu * >(argp1);
38618 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38619 if (!SWIG_IsOK(ecode2)) {
38620 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38621 }
38622 arg2 = static_cast< size_t >(val2);
38623 {
38624 PyThreadState* __tstate = wxPyBeginAllowThreads();
38625 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38626 wxPyEndAllowThreads(__tstate);
38627 if (PyErr_Occurred()) SWIG_fail;
38628 }
38629 {
38630 resultobj = wxPyMake_wxObject(result, (bool)0);
38631 }
38632 return resultobj;
38633 fail:
38634 return NULL;
38635 }
38636
38637
38638 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38639 PyObject *resultobj = 0;
38640 wxMenu *arg1 = (wxMenu *) 0 ;
38641 size_t arg2 ;
38642 int arg3 ;
38643 wxString *arg4 = 0 ;
38644 wxString const &arg5_defvalue = wxPyEmptyString ;
38645 wxString *arg5 = (wxString *) &arg5_defvalue ;
38646 wxMenuItem *result = 0 ;
38647 void *argp1 = 0 ;
38648 int res1 = 0 ;
38649 size_t val2 ;
38650 int ecode2 = 0 ;
38651 int val3 ;
38652 int ecode3 = 0 ;
38653 bool temp4 = false ;
38654 bool temp5 = false ;
38655 PyObject * obj0 = 0 ;
38656 PyObject * obj1 = 0 ;
38657 PyObject * obj2 = 0 ;
38658 PyObject * obj3 = 0 ;
38659 PyObject * obj4 = 0 ;
38660 char * kwnames[] = {
38661 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38662 };
38663
38664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38666 if (!SWIG_IsOK(res1)) {
38667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38668 }
38669 arg1 = reinterpret_cast< wxMenu * >(argp1);
38670 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38671 if (!SWIG_IsOK(ecode2)) {
38672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38673 }
38674 arg2 = static_cast< size_t >(val2);
38675 ecode3 = SWIG_AsVal_int(obj2, &val3);
38676 if (!SWIG_IsOK(ecode3)) {
38677 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38678 }
38679 arg3 = static_cast< int >(val3);
38680 {
38681 arg4 = wxString_in_helper(obj3);
38682 if (arg4 == NULL) SWIG_fail;
38683 temp4 = true;
38684 }
38685 if (obj4) {
38686 {
38687 arg5 = wxString_in_helper(obj4);
38688 if (arg5 == NULL) SWIG_fail;
38689 temp5 = true;
38690 }
38691 }
38692 {
38693 PyThreadState* __tstate = wxPyBeginAllowThreads();
38694 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38695 wxPyEndAllowThreads(__tstate);
38696 if (PyErr_Occurred()) SWIG_fail;
38697 }
38698 {
38699 resultobj = wxPyMake_wxObject(result, (bool)0);
38700 }
38701 {
38702 if (temp4)
38703 delete arg4;
38704 }
38705 {
38706 if (temp5)
38707 delete arg5;
38708 }
38709 return resultobj;
38710 fail:
38711 {
38712 if (temp4)
38713 delete arg4;
38714 }
38715 {
38716 if (temp5)
38717 delete arg5;
38718 }
38719 return NULL;
38720 }
38721
38722
38723 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38724 PyObject *resultobj = 0;
38725 wxMenu *arg1 = (wxMenu *) 0 ;
38726 size_t arg2 ;
38727 int arg3 ;
38728 wxString *arg4 = 0 ;
38729 wxString const &arg5_defvalue = wxPyEmptyString ;
38730 wxString *arg5 = (wxString *) &arg5_defvalue ;
38731 wxMenuItem *result = 0 ;
38732 void *argp1 = 0 ;
38733 int res1 = 0 ;
38734 size_t val2 ;
38735 int ecode2 = 0 ;
38736 int val3 ;
38737 int ecode3 = 0 ;
38738 bool temp4 = false ;
38739 bool temp5 = false ;
38740 PyObject * obj0 = 0 ;
38741 PyObject * obj1 = 0 ;
38742 PyObject * obj2 = 0 ;
38743 PyObject * obj3 = 0 ;
38744 PyObject * obj4 = 0 ;
38745 char * kwnames[] = {
38746 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38747 };
38748
38749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38751 if (!SWIG_IsOK(res1)) {
38752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38753 }
38754 arg1 = reinterpret_cast< wxMenu * >(argp1);
38755 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38756 if (!SWIG_IsOK(ecode2)) {
38757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38758 }
38759 arg2 = static_cast< size_t >(val2);
38760 ecode3 = SWIG_AsVal_int(obj2, &val3);
38761 if (!SWIG_IsOK(ecode3)) {
38762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
38763 }
38764 arg3 = static_cast< int >(val3);
38765 {
38766 arg4 = wxString_in_helper(obj3);
38767 if (arg4 == NULL) SWIG_fail;
38768 temp4 = true;
38769 }
38770 if (obj4) {
38771 {
38772 arg5 = wxString_in_helper(obj4);
38773 if (arg5 == NULL) SWIG_fail;
38774 temp5 = true;
38775 }
38776 }
38777 {
38778 PyThreadState* __tstate = wxPyBeginAllowThreads();
38779 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38780 wxPyEndAllowThreads(__tstate);
38781 if (PyErr_Occurred()) SWIG_fail;
38782 }
38783 {
38784 resultobj = wxPyMake_wxObject(result, (bool)0);
38785 }
38786 {
38787 if (temp4)
38788 delete arg4;
38789 }
38790 {
38791 if (temp5)
38792 delete arg5;
38793 }
38794 return resultobj;
38795 fail:
38796 {
38797 if (temp4)
38798 delete arg4;
38799 }
38800 {
38801 if (temp5)
38802 delete arg5;
38803 }
38804 return NULL;
38805 }
38806
38807
38808 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38809 PyObject *resultobj = 0;
38810 wxMenu *arg1 = (wxMenu *) 0 ;
38811 size_t arg2 ;
38812 int arg3 ;
38813 wxString *arg4 = 0 ;
38814 wxMenu *arg5 = (wxMenu *) 0 ;
38815 wxString const &arg6_defvalue = wxPyEmptyString ;
38816 wxString *arg6 = (wxString *) &arg6_defvalue ;
38817 wxMenuItem *result = 0 ;
38818 void *argp1 = 0 ;
38819 int res1 = 0 ;
38820 size_t val2 ;
38821 int ecode2 = 0 ;
38822 int val3 ;
38823 int ecode3 = 0 ;
38824 bool temp4 = false ;
38825 void *argp5 = 0 ;
38826 int res5 = 0 ;
38827 bool temp6 = false ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 PyObject * obj2 = 0 ;
38831 PyObject * obj3 = 0 ;
38832 PyObject * obj4 = 0 ;
38833 PyObject * obj5 = 0 ;
38834 char * kwnames[] = {
38835 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38836 };
38837
38838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38840 if (!SWIG_IsOK(res1)) {
38841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38842 }
38843 arg1 = reinterpret_cast< wxMenu * >(argp1);
38844 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38845 if (!SWIG_IsOK(ecode2)) {
38846 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
38847 }
38848 arg2 = static_cast< size_t >(val2);
38849 ecode3 = SWIG_AsVal_int(obj2, &val3);
38850 if (!SWIG_IsOK(ecode3)) {
38851 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
38852 }
38853 arg3 = static_cast< int >(val3);
38854 {
38855 arg4 = wxString_in_helper(obj3);
38856 if (arg4 == NULL) SWIG_fail;
38857 temp4 = true;
38858 }
38859 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
38860 if (!SWIG_IsOK(res5)) {
38861 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
38862 }
38863 arg5 = reinterpret_cast< wxMenu * >(argp5);
38864 if (obj5) {
38865 {
38866 arg6 = wxString_in_helper(obj5);
38867 if (arg6 == NULL) SWIG_fail;
38868 temp6 = true;
38869 }
38870 }
38871 {
38872 PyThreadState* __tstate = wxPyBeginAllowThreads();
38873 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
38874 wxPyEndAllowThreads(__tstate);
38875 if (PyErr_Occurred()) SWIG_fail;
38876 }
38877 {
38878 resultobj = wxPyMake_wxObject(result, (bool)0);
38879 }
38880 {
38881 if (temp4)
38882 delete arg4;
38883 }
38884 {
38885 if (temp6)
38886 delete arg6;
38887 }
38888 return resultobj;
38889 fail:
38890 {
38891 if (temp4)
38892 delete arg4;
38893 }
38894 {
38895 if (temp6)
38896 delete arg6;
38897 }
38898 return NULL;
38899 }
38900
38901
38902 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38903 PyObject *resultobj = 0;
38904 wxMenu *arg1 = (wxMenu *) 0 ;
38905 int arg2 ;
38906 wxString *arg3 = 0 ;
38907 wxString const &arg4_defvalue = wxPyEmptyString ;
38908 wxString *arg4 = (wxString *) &arg4_defvalue ;
38909 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38910 wxMenuItem *result = 0 ;
38911 void *argp1 = 0 ;
38912 int res1 = 0 ;
38913 int val2 ;
38914 int ecode2 = 0 ;
38915 bool temp3 = false ;
38916 bool temp4 = false ;
38917 int val5 ;
38918 int ecode5 = 0 ;
38919 PyObject * obj0 = 0 ;
38920 PyObject * obj1 = 0 ;
38921 PyObject * obj2 = 0 ;
38922 PyObject * obj3 = 0 ;
38923 PyObject * obj4 = 0 ;
38924 char * kwnames[] = {
38925 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38926 };
38927
38928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38930 if (!SWIG_IsOK(res1)) {
38931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
38932 }
38933 arg1 = reinterpret_cast< wxMenu * >(argp1);
38934 ecode2 = SWIG_AsVal_int(obj1, &val2);
38935 if (!SWIG_IsOK(ecode2)) {
38936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
38937 }
38938 arg2 = static_cast< int >(val2);
38939 {
38940 arg3 = wxString_in_helper(obj2);
38941 if (arg3 == NULL) SWIG_fail;
38942 temp3 = true;
38943 }
38944 if (obj3) {
38945 {
38946 arg4 = wxString_in_helper(obj3);
38947 if (arg4 == NULL) SWIG_fail;
38948 temp4 = true;
38949 }
38950 }
38951 if (obj4) {
38952 ecode5 = SWIG_AsVal_int(obj4, &val5);
38953 if (!SWIG_IsOK(ecode5)) {
38954 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
38955 }
38956 arg5 = static_cast< wxItemKind >(val5);
38957 }
38958 {
38959 PyThreadState* __tstate = wxPyBeginAllowThreads();
38960 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38961 wxPyEndAllowThreads(__tstate);
38962 if (PyErr_Occurred()) SWIG_fail;
38963 }
38964 {
38965 resultobj = wxPyMake_wxObject(result, (bool)0);
38966 }
38967 {
38968 if (temp3)
38969 delete arg3;
38970 }
38971 {
38972 if (temp4)
38973 delete arg4;
38974 }
38975 return resultobj;
38976 fail:
38977 {
38978 if (temp3)
38979 delete arg3;
38980 }
38981 {
38982 if (temp4)
38983 delete arg4;
38984 }
38985 return NULL;
38986 }
38987
38988
38989 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38990 PyObject *resultobj = 0;
38991 wxMenu *arg1 = (wxMenu *) 0 ;
38992 wxMenuItem *result = 0 ;
38993 void *argp1 = 0 ;
38994 int res1 = 0 ;
38995 PyObject *swig_obj[1] ;
38996
38997 if (!args) SWIG_fail;
38998 swig_obj[0] = args;
38999 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39000 if (!SWIG_IsOK(res1)) {
39001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39002 }
39003 arg1 = reinterpret_cast< wxMenu * >(argp1);
39004 {
39005 PyThreadState* __tstate = wxPyBeginAllowThreads();
39006 result = (wxMenuItem *)(arg1)->PrependSeparator();
39007 wxPyEndAllowThreads(__tstate);
39008 if (PyErr_Occurred()) SWIG_fail;
39009 }
39010 {
39011 resultobj = wxPyMake_wxObject(result, (bool)0);
39012 }
39013 return resultobj;
39014 fail:
39015 return NULL;
39016 }
39017
39018
39019 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39020 PyObject *resultobj = 0;
39021 wxMenu *arg1 = (wxMenu *) 0 ;
39022 int arg2 ;
39023 wxString *arg3 = 0 ;
39024 wxString const &arg4_defvalue = wxPyEmptyString ;
39025 wxString *arg4 = (wxString *) &arg4_defvalue ;
39026 wxMenuItem *result = 0 ;
39027 void *argp1 = 0 ;
39028 int res1 = 0 ;
39029 int val2 ;
39030 int ecode2 = 0 ;
39031 bool temp3 = false ;
39032 bool temp4 = false ;
39033 PyObject * obj0 = 0 ;
39034 PyObject * obj1 = 0 ;
39035 PyObject * obj2 = 0 ;
39036 PyObject * obj3 = 0 ;
39037 char * kwnames[] = {
39038 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39039 };
39040
39041 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39042 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39043 if (!SWIG_IsOK(res1)) {
39044 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39045 }
39046 arg1 = reinterpret_cast< wxMenu * >(argp1);
39047 ecode2 = SWIG_AsVal_int(obj1, &val2);
39048 if (!SWIG_IsOK(ecode2)) {
39049 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39050 }
39051 arg2 = static_cast< int >(val2);
39052 {
39053 arg3 = wxString_in_helper(obj2);
39054 if (arg3 == NULL) SWIG_fail;
39055 temp3 = true;
39056 }
39057 if (obj3) {
39058 {
39059 arg4 = wxString_in_helper(obj3);
39060 if (arg4 == NULL) SWIG_fail;
39061 temp4 = true;
39062 }
39063 }
39064 {
39065 PyThreadState* __tstate = wxPyBeginAllowThreads();
39066 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39067 wxPyEndAllowThreads(__tstate);
39068 if (PyErr_Occurred()) SWIG_fail;
39069 }
39070 {
39071 resultobj = wxPyMake_wxObject(result, (bool)0);
39072 }
39073 {
39074 if (temp3)
39075 delete arg3;
39076 }
39077 {
39078 if (temp4)
39079 delete arg4;
39080 }
39081 return resultobj;
39082 fail:
39083 {
39084 if (temp3)
39085 delete arg3;
39086 }
39087 {
39088 if (temp4)
39089 delete arg4;
39090 }
39091 return NULL;
39092 }
39093
39094
39095 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39096 PyObject *resultobj = 0;
39097 wxMenu *arg1 = (wxMenu *) 0 ;
39098 int arg2 ;
39099 wxString *arg3 = 0 ;
39100 wxString const &arg4_defvalue = wxPyEmptyString ;
39101 wxString *arg4 = (wxString *) &arg4_defvalue ;
39102 wxMenuItem *result = 0 ;
39103 void *argp1 = 0 ;
39104 int res1 = 0 ;
39105 int val2 ;
39106 int ecode2 = 0 ;
39107 bool temp3 = false ;
39108 bool temp4 = false ;
39109 PyObject * obj0 = 0 ;
39110 PyObject * obj1 = 0 ;
39111 PyObject * obj2 = 0 ;
39112 PyObject * obj3 = 0 ;
39113 char * kwnames[] = {
39114 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39115 };
39116
39117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39119 if (!SWIG_IsOK(res1)) {
39120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39121 }
39122 arg1 = reinterpret_cast< wxMenu * >(argp1);
39123 ecode2 = SWIG_AsVal_int(obj1, &val2);
39124 if (!SWIG_IsOK(ecode2)) {
39125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39126 }
39127 arg2 = static_cast< int >(val2);
39128 {
39129 arg3 = wxString_in_helper(obj2);
39130 if (arg3 == NULL) SWIG_fail;
39131 temp3 = true;
39132 }
39133 if (obj3) {
39134 {
39135 arg4 = wxString_in_helper(obj3);
39136 if (arg4 == NULL) SWIG_fail;
39137 temp4 = true;
39138 }
39139 }
39140 {
39141 PyThreadState* __tstate = wxPyBeginAllowThreads();
39142 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39143 wxPyEndAllowThreads(__tstate);
39144 if (PyErr_Occurred()) SWIG_fail;
39145 }
39146 {
39147 resultobj = wxPyMake_wxObject(result, (bool)0);
39148 }
39149 {
39150 if (temp3)
39151 delete arg3;
39152 }
39153 {
39154 if (temp4)
39155 delete arg4;
39156 }
39157 return resultobj;
39158 fail:
39159 {
39160 if (temp3)
39161 delete arg3;
39162 }
39163 {
39164 if (temp4)
39165 delete arg4;
39166 }
39167 return NULL;
39168 }
39169
39170
39171 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39172 PyObject *resultobj = 0;
39173 wxMenu *arg1 = (wxMenu *) 0 ;
39174 int arg2 ;
39175 wxString *arg3 = 0 ;
39176 wxMenu *arg4 = (wxMenu *) 0 ;
39177 wxString const &arg5_defvalue = wxPyEmptyString ;
39178 wxString *arg5 = (wxString *) &arg5_defvalue ;
39179 wxMenuItem *result = 0 ;
39180 void *argp1 = 0 ;
39181 int res1 = 0 ;
39182 int val2 ;
39183 int ecode2 = 0 ;
39184 bool temp3 = false ;
39185 void *argp4 = 0 ;
39186 int res4 = 0 ;
39187 bool temp5 = false ;
39188 PyObject * obj0 = 0 ;
39189 PyObject * obj1 = 0 ;
39190 PyObject * obj2 = 0 ;
39191 PyObject * obj3 = 0 ;
39192 PyObject * obj4 = 0 ;
39193 char * kwnames[] = {
39194 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39195 };
39196
39197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39199 if (!SWIG_IsOK(res1)) {
39200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39201 }
39202 arg1 = reinterpret_cast< wxMenu * >(argp1);
39203 ecode2 = SWIG_AsVal_int(obj1, &val2);
39204 if (!SWIG_IsOK(ecode2)) {
39205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39206 }
39207 arg2 = static_cast< int >(val2);
39208 {
39209 arg3 = wxString_in_helper(obj2);
39210 if (arg3 == NULL) SWIG_fail;
39211 temp3 = true;
39212 }
39213 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39214 if (!SWIG_IsOK(res4)) {
39215 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39216 }
39217 arg4 = reinterpret_cast< wxMenu * >(argp4);
39218 if (obj4) {
39219 {
39220 arg5 = wxString_in_helper(obj4);
39221 if (arg5 == NULL) SWIG_fail;
39222 temp5 = true;
39223 }
39224 }
39225 {
39226 PyThreadState* __tstate = wxPyBeginAllowThreads();
39227 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39228 wxPyEndAllowThreads(__tstate);
39229 if (PyErr_Occurred()) SWIG_fail;
39230 }
39231 {
39232 resultobj = wxPyMake_wxObject(result, (bool)0);
39233 }
39234 {
39235 if (temp3)
39236 delete arg3;
39237 }
39238 {
39239 if (temp5)
39240 delete arg5;
39241 }
39242 return resultobj;
39243 fail:
39244 {
39245 if (temp3)
39246 delete arg3;
39247 }
39248 {
39249 if (temp5)
39250 delete arg5;
39251 }
39252 return NULL;
39253 }
39254
39255
39256 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39257 PyObject *resultobj = 0;
39258 wxMenu *arg1 = (wxMenu *) 0 ;
39259 int arg2 ;
39260 wxMenuItem *result = 0 ;
39261 void *argp1 = 0 ;
39262 int res1 = 0 ;
39263 int val2 ;
39264 int ecode2 = 0 ;
39265 PyObject * obj0 = 0 ;
39266 PyObject * obj1 = 0 ;
39267 char * kwnames[] = {
39268 (char *) "self",(char *) "id", NULL
39269 };
39270
39271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39273 if (!SWIG_IsOK(res1)) {
39274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39275 }
39276 arg1 = reinterpret_cast< wxMenu * >(argp1);
39277 ecode2 = SWIG_AsVal_int(obj1, &val2);
39278 if (!SWIG_IsOK(ecode2)) {
39279 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39280 }
39281 arg2 = static_cast< int >(val2);
39282 {
39283 PyThreadState* __tstate = wxPyBeginAllowThreads();
39284 result = (wxMenuItem *)(arg1)->Remove(arg2);
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39290 }
39291 return resultobj;
39292 fail:
39293 return NULL;
39294 }
39295
39296
39297 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39298 PyObject *resultobj = 0;
39299 wxMenu *arg1 = (wxMenu *) 0 ;
39300 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39301 wxMenuItem *result = 0 ;
39302 void *argp1 = 0 ;
39303 int res1 = 0 ;
39304 void *argp2 = 0 ;
39305 int res2 = 0 ;
39306 PyObject * obj0 = 0 ;
39307 PyObject * obj1 = 0 ;
39308 char * kwnames[] = {
39309 (char *) "self",(char *) "item", NULL
39310 };
39311
39312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39314 if (!SWIG_IsOK(res1)) {
39315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39316 }
39317 arg1 = reinterpret_cast< wxMenu * >(argp1);
39318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39319 if (!SWIG_IsOK(res2)) {
39320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39321 }
39322 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39323 {
39324 PyThreadState* __tstate = wxPyBeginAllowThreads();
39325 result = (wxMenuItem *)(arg1)->Remove(arg2);
39326 wxPyEndAllowThreads(__tstate);
39327 if (PyErr_Occurred()) SWIG_fail;
39328 }
39329 {
39330 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39331 }
39332 return resultobj;
39333 fail:
39334 return NULL;
39335 }
39336
39337
39338 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39339 PyObject *resultobj = 0;
39340 wxMenu *arg1 = (wxMenu *) 0 ;
39341 int arg2 ;
39342 bool result;
39343 void *argp1 = 0 ;
39344 int res1 = 0 ;
39345 int val2 ;
39346 int ecode2 = 0 ;
39347 PyObject * obj0 = 0 ;
39348 PyObject * obj1 = 0 ;
39349 char * kwnames[] = {
39350 (char *) "self",(char *) "id", NULL
39351 };
39352
39353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39355 if (!SWIG_IsOK(res1)) {
39356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39357 }
39358 arg1 = reinterpret_cast< wxMenu * >(argp1);
39359 ecode2 = SWIG_AsVal_int(obj1, &val2);
39360 if (!SWIG_IsOK(ecode2)) {
39361 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39362 }
39363 arg2 = static_cast< int >(val2);
39364 {
39365 PyThreadState* __tstate = wxPyBeginAllowThreads();
39366 result = (bool)(arg1)->Delete(arg2);
39367 wxPyEndAllowThreads(__tstate);
39368 if (PyErr_Occurred()) SWIG_fail;
39369 }
39370 {
39371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39372 }
39373 return resultobj;
39374 fail:
39375 return NULL;
39376 }
39377
39378
39379 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39380 PyObject *resultobj = 0;
39381 wxMenu *arg1 = (wxMenu *) 0 ;
39382 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39383 bool result;
39384 void *argp1 = 0 ;
39385 int res1 = 0 ;
39386 void *argp2 = 0 ;
39387 int res2 = 0 ;
39388 PyObject * obj0 = 0 ;
39389 PyObject * obj1 = 0 ;
39390 char * kwnames[] = {
39391 (char *) "self",(char *) "item", NULL
39392 };
39393
39394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39396 if (!SWIG_IsOK(res1)) {
39397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39398 }
39399 arg1 = reinterpret_cast< wxMenu * >(argp1);
39400 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39401 if (!SWIG_IsOK(res2)) {
39402 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39403 }
39404 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39405 {
39406 PyThreadState* __tstate = wxPyBeginAllowThreads();
39407 result = (bool)(arg1)->Delete(arg2);
39408 wxPyEndAllowThreads(__tstate);
39409 if (PyErr_Occurred()) SWIG_fail;
39410 }
39411 {
39412 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39413 }
39414 return resultobj;
39415 fail:
39416 return NULL;
39417 }
39418
39419
39420 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39421 PyObject *resultobj = 0;
39422 wxMenu *arg1 = (wxMenu *) 0 ;
39423 void *argp1 = 0 ;
39424 int res1 = 0 ;
39425 PyObject *swig_obj[1] ;
39426
39427 if (!args) SWIG_fail;
39428 swig_obj[0] = args;
39429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39430 if (!SWIG_IsOK(res1)) {
39431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39432 }
39433 arg1 = reinterpret_cast< wxMenu * >(argp1);
39434 {
39435 PyThreadState* __tstate = wxPyBeginAllowThreads();
39436 wxMenu_Destroy(arg1);
39437 wxPyEndAllowThreads(__tstate);
39438 if (PyErr_Occurred()) SWIG_fail;
39439 }
39440 resultobj = SWIG_Py_Void();
39441 return resultobj;
39442 fail:
39443 return NULL;
39444 }
39445
39446
39447 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39448 PyObject *resultobj = 0;
39449 wxMenu *arg1 = (wxMenu *) 0 ;
39450 int arg2 ;
39451 bool result;
39452 void *argp1 = 0 ;
39453 int res1 = 0 ;
39454 int val2 ;
39455 int ecode2 = 0 ;
39456 PyObject * obj0 = 0 ;
39457 PyObject * obj1 = 0 ;
39458 char * kwnames[] = {
39459 (char *) "self",(char *) "id", NULL
39460 };
39461
39462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39464 if (!SWIG_IsOK(res1)) {
39465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39466 }
39467 arg1 = reinterpret_cast< wxMenu * >(argp1);
39468 ecode2 = SWIG_AsVal_int(obj1, &val2);
39469 if (!SWIG_IsOK(ecode2)) {
39470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39471 }
39472 arg2 = static_cast< int >(val2);
39473 {
39474 PyThreadState* __tstate = wxPyBeginAllowThreads();
39475 result = (bool)(arg1)->Destroy(arg2);
39476 wxPyEndAllowThreads(__tstate);
39477 if (PyErr_Occurred()) SWIG_fail;
39478 }
39479 {
39480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39481 }
39482 return resultobj;
39483 fail:
39484 return NULL;
39485 }
39486
39487
39488 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39489 PyObject *resultobj = 0;
39490 wxMenu *arg1 = (wxMenu *) 0 ;
39491 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39492 bool result;
39493 void *argp1 = 0 ;
39494 int res1 = 0 ;
39495 void *argp2 = 0 ;
39496 int res2 = 0 ;
39497 PyObject * obj0 = 0 ;
39498 PyObject * obj1 = 0 ;
39499 char * kwnames[] = {
39500 (char *) "self",(char *) "item", NULL
39501 };
39502
39503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39505 if (!SWIG_IsOK(res1)) {
39506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39507 }
39508 arg1 = reinterpret_cast< wxMenu * >(argp1);
39509 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39510 if (!SWIG_IsOK(res2)) {
39511 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39512 }
39513 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39514 {
39515 PyThreadState* __tstate = wxPyBeginAllowThreads();
39516 result = (bool)(arg1)->Destroy(arg2);
39517 wxPyEndAllowThreads(__tstate);
39518 if (PyErr_Occurred()) SWIG_fail;
39519 }
39520 {
39521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39522 }
39523 return resultobj;
39524 fail:
39525 return NULL;
39526 }
39527
39528
39529 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39530 PyObject *resultobj = 0;
39531 wxMenu *arg1 = (wxMenu *) 0 ;
39532 size_t result;
39533 void *argp1 = 0 ;
39534 int res1 = 0 ;
39535 PyObject *swig_obj[1] ;
39536
39537 if (!args) SWIG_fail;
39538 swig_obj[0] = args;
39539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39540 if (!SWIG_IsOK(res1)) {
39541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39542 }
39543 arg1 = reinterpret_cast< wxMenu * >(argp1);
39544 {
39545 PyThreadState* __tstate = wxPyBeginAllowThreads();
39546 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39547 wxPyEndAllowThreads(__tstate);
39548 if (PyErr_Occurred()) SWIG_fail;
39549 }
39550 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39551 return resultobj;
39552 fail:
39553 return NULL;
39554 }
39555
39556
39557 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39558 PyObject *resultobj = 0;
39559 wxMenu *arg1 = (wxMenu *) 0 ;
39560 PyObject *result = 0 ;
39561 void *argp1 = 0 ;
39562 int res1 = 0 ;
39563 PyObject *swig_obj[1] ;
39564
39565 if (!args) SWIG_fail;
39566 swig_obj[0] = args;
39567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39568 if (!SWIG_IsOK(res1)) {
39569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39570 }
39571 arg1 = reinterpret_cast< wxMenu * >(argp1);
39572 {
39573 PyThreadState* __tstate = wxPyBeginAllowThreads();
39574 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39575 wxPyEndAllowThreads(__tstate);
39576 if (PyErr_Occurred()) SWIG_fail;
39577 }
39578 resultobj = result;
39579 return resultobj;
39580 fail:
39581 return NULL;
39582 }
39583
39584
39585 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39586 PyObject *resultobj = 0;
39587 wxMenu *arg1 = (wxMenu *) 0 ;
39588 wxString *arg2 = 0 ;
39589 int result;
39590 void *argp1 = 0 ;
39591 int res1 = 0 ;
39592 bool temp2 = false ;
39593 PyObject * obj0 = 0 ;
39594 PyObject * obj1 = 0 ;
39595 char * kwnames[] = {
39596 (char *) "self",(char *) "item", NULL
39597 };
39598
39599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39601 if (!SWIG_IsOK(res1)) {
39602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39603 }
39604 arg1 = reinterpret_cast< wxMenu * >(argp1);
39605 {
39606 arg2 = wxString_in_helper(obj1);
39607 if (arg2 == NULL) SWIG_fail;
39608 temp2 = true;
39609 }
39610 {
39611 PyThreadState* __tstate = wxPyBeginAllowThreads();
39612 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39613 wxPyEndAllowThreads(__tstate);
39614 if (PyErr_Occurred()) SWIG_fail;
39615 }
39616 resultobj = SWIG_From_int(static_cast< int >(result));
39617 {
39618 if (temp2)
39619 delete arg2;
39620 }
39621 return resultobj;
39622 fail:
39623 {
39624 if (temp2)
39625 delete arg2;
39626 }
39627 return NULL;
39628 }
39629
39630
39631 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39632 PyObject *resultobj = 0;
39633 wxMenu *arg1 = (wxMenu *) 0 ;
39634 int arg2 ;
39635 wxMenuItem *result = 0 ;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 int val2 ;
39639 int ecode2 = 0 ;
39640 PyObject * obj0 = 0 ;
39641 PyObject * obj1 = 0 ;
39642 char * kwnames[] = {
39643 (char *) "self",(char *) "id", NULL
39644 };
39645
39646 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39647 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39648 if (!SWIG_IsOK(res1)) {
39649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39650 }
39651 arg1 = reinterpret_cast< wxMenu * >(argp1);
39652 ecode2 = SWIG_AsVal_int(obj1, &val2);
39653 if (!SWIG_IsOK(ecode2)) {
39654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39655 }
39656 arg2 = static_cast< int >(val2);
39657 {
39658 PyThreadState* __tstate = wxPyBeginAllowThreads();
39659 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39660 wxPyEndAllowThreads(__tstate);
39661 if (PyErr_Occurred()) SWIG_fail;
39662 }
39663 {
39664 resultobj = wxPyMake_wxObject(result, (bool)0);
39665 }
39666 return resultobj;
39667 fail:
39668 return NULL;
39669 }
39670
39671
39672 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39673 PyObject *resultobj = 0;
39674 wxMenu *arg1 = (wxMenu *) 0 ;
39675 size_t arg2 ;
39676 wxMenuItem *result = 0 ;
39677 void *argp1 = 0 ;
39678 int res1 = 0 ;
39679 size_t val2 ;
39680 int ecode2 = 0 ;
39681 PyObject * obj0 = 0 ;
39682 PyObject * obj1 = 0 ;
39683 char * kwnames[] = {
39684 (char *) "self",(char *) "position", NULL
39685 };
39686
39687 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39688 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39689 if (!SWIG_IsOK(res1)) {
39690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39691 }
39692 arg1 = reinterpret_cast< wxMenu * >(argp1);
39693 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39694 if (!SWIG_IsOK(ecode2)) {
39695 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39696 }
39697 arg2 = static_cast< size_t >(val2);
39698 {
39699 PyThreadState* __tstate = wxPyBeginAllowThreads();
39700 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39701 wxPyEndAllowThreads(__tstate);
39702 if (PyErr_Occurred()) SWIG_fail;
39703 }
39704 {
39705 resultobj = wxPyMake_wxObject(result, (bool)0);
39706 }
39707 return resultobj;
39708 fail:
39709 return NULL;
39710 }
39711
39712
39713 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39714 PyObject *resultobj = 0;
39715 wxMenu *arg1 = (wxMenu *) 0 ;
39716 int arg2 ;
39717 bool arg3 ;
39718 void *argp1 = 0 ;
39719 int res1 = 0 ;
39720 int val2 ;
39721 int ecode2 = 0 ;
39722 bool val3 ;
39723 int ecode3 = 0 ;
39724 PyObject * obj0 = 0 ;
39725 PyObject * obj1 = 0 ;
39726 PyObject * obj2 = 0 ;
39727 char * kwnames[] = {
39728 (char *) "self",(char *) "id",(char *) "enable", NULL
39729 };
39730
39731 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39732 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39733 if (!SWIG_IsOK(res1)) {
39734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39735 }
39736 arg1 = reinterpret_cast< wxMenu * >(argp1);
39737 ecode2 = SWIG_AsVal_int(obj1, &val2);
39738 if (!SWIG_IsOK(ecode2)) {
39739 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39740 }
39741 arg2 = static_cast< int >(val2);
39742 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39743 if (!SWIG_IsOK(ecode3)) {
39744 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39745 }
39746 arg3 = static_cast< bool >(val3);
39747 {
39748 PyThreadState* __tstate = wxPyBeginAllowThreads();
39749 (arg1)->Enable(arg2,arg3);
39750 wxPyEndAllowThreads(__tstate);
39751 if (PyErr_Occurred()) SWIG_fail;
39752 }
39753 resultobj = SWIG_Py_Void();
39754 return resultobj;
39755 fail:
39756 return NULL;
39757 }
39758
39759
39760 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39761 PyObject *resultobj = 0;
39762 wxMenu *arg1 = (wxMenu *) 0 ;
39763 int arg2 ;
39764 bool result;
39765 void *argp1 = 0 ;
39766 int res1 = 0 ;
39767 int val2 ;
39768 int ecode2 = 0 ;
39769 PyObject * obj0 = 0 ;
39770 PyObject * obj1 = 0 ;
39771 char * kwnames[] = {
39772 (char *) "self",(char *) "id", NULL
39773 };
39774
39775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
39776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39777 if (!SWIG_IsOK(res1)) {
39778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
39779 }
39780 arg1 = reinterpret_cast< wxMenu * >(argp1);
39781 ecode2 = SWIG_AsVal_int(obj1, &val2);
39782 if (!SWIG_IsOK(ecode2)) {
39783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
39784 }
39785 arg2 = static_cast< int >(val2);
39786 {
39787 PyThreadState* __tstate = wxPyBeginAllowThreads();
39788 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
39789 wxPyEndAllowThreads(__tstate);
39790 if (PyErr_Occurred()) SWIG_fail;
39791 }
39792 {
39793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39794 }
39795 return resultobj;
39796 fail:
39797 return NULL;
39798 }
39799
39800
39801 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39802 PyObject *resultobj = 0;
39803 wxMenu *arg1 = (wxMenu *) 0 ;
39804 int arg2 ;
39805 bool arg3 ;
39806 void *argp1 = 0 ;
39807 int res1 = 0 ;
39808 int val2 ;
39809 int ecode2 = 0 ;
39810 bool val3 ;
39811 int ecode3 = 0 ;
39812 PyObject * obj0 = 0 ;
39813 PyObject * obj1 = 0 ;
39814 PyObject * obj2 = 0 ;
39815 char * kwnames[] = {
39816 (char *) "self",(char *) "id",(char *) "check", NULL
39817 };
39818
39819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39821 if (!SWIG_IsOK(res1)) {
39822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
39823 }
39824 arg1 = reinterpret_cast< wxMenu * >(argp1);
39825 ecode2 = SWIG_AsVal_int(obj1, &val2);
39826 if (!SWIG_IsOK(ecode2)) {
39827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
39828 }
39829 arg2 = static_cast< int >(val2);
39830 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39831 if (!SWIG_IsOK(ecode3)) {
39832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
39833 }
39834 arg3 = static_cast< bool >(val3);
39835 {
39836 PyThreadState* __tstate = wxPyBeginAllowThreads();
39837 (arg1)->Check(arg2,arg3);
39838 wxPyEndAllowThreads(__tstate);
39839 if (PyErr_Occurred()) SWIG_fail;
39840 }
39841 resultobj = SWIG_Py_Void();
39842 return resultobj;
39843 fail:
39844 return NULL;
39845 }
39846
39847
39848 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39849 PyObject *resultobj = 0;
39850 wxMenu *arg1 = (wxMenu *) 0 ;
39851 int arg2 ;
39852 bool result;
39853 void *argp1 = 0 ;
39854 int res1 = 0 ;
39855 int val2 ;
39856 int ecode2 = 0 ;
39857 PyObject * obj0 = 0 ;
39858 PyObject * obj1 = 0 ;
39859 char * kwnames[] = {
39860 (char *) "self",(char *) "id", NULL
39861 };
39862
39863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
39864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39865 if (!SWIG_IsOK(res1)) {
39866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
39867 }
39868 arg1 = reinterpret_cast< wxMenu * >(argp1);
39869 ecode2 = SWIG_AsVal_int(obj1, &val2);
39870 if (!SWIG_IsOK(ecode2)) {
39871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
39872 }
39873 arg2 = static_cast< int >(val2);
39874 {
39875 PyThreadState* __tstate = wxPyBeginAllowThreads();
39876 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
39877 wxPyEndAllowThreads(__tstate);
39878 if (PyErr_Occurred()) SWIG_fail;
39879 }
39880 {
39881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39882 }
39883 return resultobj;
39884 fail:
39885 return NULL;
39886 }
39887
39888
39889 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39890 PyObject *resultobj = 0;
39891 wxMenu *arg1 = (wxMenu *) 0 ;
39892 int arg2 ;
39893 wxString *arg3 = 0 ;
39894 void *argp1 = 0 ;
39895 int res1 = 0 ;
39896 int val2 ;
39897 int ecode2 = 0 ;
39898 bool temp3 = false ;
39899 PyObject * obj0 = 0 ;
39900 PyObject * obj1 = 0 ;
39901 PyObject * obj2 = 0 ;
39902 char * kwnames[] = {
39903 (char *) "self",(char *) "id",(char *) "label", NULL
39904 };
39905
39906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39908 if (!SWIG_IsOK(res1)) {
39909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
39910 }
39911 arg1 = reinterpret_cast< wxMenu * >(argp1);
39912 ecode2 = SWIG_AsVal_int(obj1, &val2);
39913 if (!SWIG_IsOK(ecode2)) {
39914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
39915 }
39916 arg2 = static_cast< int >(val2);
39917 {
39918 arg3 = wxString_in_helper(obj2);
39919 if (arg3 == NULL) SWIG_fail;
39920 temp3 = true;
39921 }
39922 {
39923 PyThreadState* __tstate = wxPyBeginAllowThreads();
39924 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
39925 wxPyEndAllowThreads(__tstate);
39926 if (PyErr_Occurred()) SWIG_fail;
39927 }
39928 resultobj = SWIG_Py_Void();
39929 {
39930 if (temp3)
39931 delete arg3;
39932 }
39933 return resultobj;
39934 fail:
39935 {
39936 if (temp3)
39937 delete arg3;
39938 }
39939 return NULL;
39940 }
39941
39942
39943 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39944 PyObject *resultobj = 0;
39945 wxMenu *arg1 = (wxMenu *) 0 ;
39946 int arg2 ;
39947 wxString result;
39948 void *argp1 = 0 ;
39949 int res1 = 0 ;
39950 int val2 ;
39951 int ecode2 = 0 ;
39952 PyObject * obj0 = 0 ;
39953 PyObject * obj1 = 0 ;
39954 char * kwnames[] = {
39955 (char *) "self",(char *) "id", NULL
39956 };
39957
39958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
39959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39960 if (!SWIG_IsOK(res1)) {
39961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
39962 }
39963 arg1 = reinterpret_cast< wxMenu * >(argp1);
39964 ecode2 = SWIG_AsVal_int(obj1, &val2);
39965 if (!SWIG_IsOK(ecode2)) {
39966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
39967 }
39968 arg2 = static_cast< int >(val2);
39969 {
39970 PyThreadState* __tstate = wxPyBeginAllowThreads();
39971 result = ((wxMenu const *)arg1)->GetLabel(arg2);
39972 wxPyEndAllowThreads(__tstate);
39973 if (PyErr_Occurred()) SWIG_fail;
39974 }
39975 {
39976 #if wxUSE_UNICODE
39977 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
39978 #else
39979 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
39980 #endif
39981 }
39982 return resultobj;
39983 fail:
39984 return NULL;
39985 }
39986
39987
39988 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39989 PyObject *resultobj = 0;
39990 wxMenu *arg1 = (wxMenu *) 0 ;
39991 int arg2 ;
39992 wxString *arg3 = 0 ;
39993 void *argp1 = 0 ;
39994 int res1 = 0 ;
39995 int val2 ;
39996 int ecode2 = 0 ;
39997 bool temp3 = false ;
39998 PyObject * obj0 = 0 ;
39999 PyObject * obj1 = 0 ;
40000 PyObject * obj2 = 0 ;
40001 char * kwnames[] = {
40002 (char *) "self",(char *) "id",(char *) "helpString", NULL
40003 };
40004
40005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40007 if (!SWIG_IsOK(res1)) {
40008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40009 }
40010 arg1 = reinterpret_cast< wxMenu * >(argp1);
40011 ecode2 = SWIG_AsVal_int(obj1, &val2);
40012 if (!SWIG_IsOK(ecode2)) {
40013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40014 }
40015 arg2 = static_cast< int >(val2);
40016 {
40017 arg3 = wxString_in_helper(obj2);
40018 if (arg3 == NULL) SWIG_fail;
40019 temp3 = true;
40020 }
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 resultobj = SWIG_Py_Void();
40028 {
40029 if (temp3)
40030 delete arg3;
40031 }
40032 return resultobj;
40033 fail:
40034 {
40035 if (temp3)
40036 delete arg3;
40037 }
40038 return NULL;
40039 }
40040
40041
40042 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj = 0;
40044 wxMenu *arg1 = (wxMenu *) 0 ;
40045 int arg2 ;
40046 wxString result;
40047 void *argp1 = 0 ;
40048 int res1 = 0 ;
40049 int val2 ;
40050 int ecode2 = 0 ;
40051 PyObject * obj0 = 0 ;
40052 PyObject * obj1 = 0 ;
40053 char * kwnames[] = {
40054 (char *) "self",(char *) "id", NULL
40055 };
40056
40057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40059 if (!SWIG_IsOK(res1)) {
40060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40061 }
40062 arg1 = reinterpret_cast< wxMenu * >(argp1);
40063 ecode2 = SWIG_AsVal_int(obj1, &val2);
40064 if (!SWIG_IsOK(ecode2)) {
40065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40066 }
40067 arg2 = static_cast< int >(val2);
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40071 wxPyEndAllowThreads(__tstate);
40072 if (PyErr_Occurred()) SWIG_fail;
40073 }
40074 {
40075 #if wxUSE_UNICODE
40076 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40077 #else
40078 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40079 #endif
40080 }
40081 return resultobj;
40082 fail:
40083 return NULL;
40084 }
40085
40086
40087 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40088 PyObject *resultobj = 0;
40089 wxMenu *arg1 = (wxMenu *) 0 ;
40090 wxString *arg2 = 0 ;
40091 void *argp1 = 0 ;
40092 int res1 = 0 ;
40093 bool temp2 = false ;
40094 PyObject * obj0 = 0 ;
40095 PyObject * obj1 = 0 ;
40096 char * kwnames[] = {
40097 (char *) "self",(char *) "title", NULL
40098 };
40099
40100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40102 if (!SWIG_IsOK(res1)) {
40103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40104 }
40105 arg1 = reinterpret_cast< wxMenu * >(argp1);
40106 {
40107 arg2 = wxString_in_helper(obj1);
40108 if (arg2 == NULL) SWIG_fail;
40109 temp2 = true;
40110 }
40111 {
40112 PyThreadState* __tstate = wxPyBeginAllowThreads();
40113 (arg1)->SetTitle((wxString const &)*arg2);
40114 wxPyEndAllowThreads(__tstate);
40115 if (PyErr_Occurred()) SWIG_fail;
40116 }
40117 resultobj = SWIG_Py_Void();
40118 {
40119 if (temp2)
40120 delete arg2;
40121 }
40122 return resultobj;
40123 fail:
40124 {
40125 if (temp2)
40126 delete arg2;
40127 }
40128 return NULL;
40129 }
40130
40131
40132 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40133 PyObject *resultobj = 0;
40134 wxMenu *arg1 = (wxMenu *) 0 ;
40135 wxString result;
40136 void *argp1 = 0 ;
40137 int res1 = 0 ;
40138 PyObject *swig_obj[1] ;
40139
40140 if (!args) SWIG_fail;
40141 swig_obj[0] = args;
40142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40143 if (!SWIG_IsOK(res1)) {
40144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40145 }
40146 arg1 = reinterpret_cast< wxMenu * >(argp1);
40147 {
40148 PyThreadState* __tstate = wxPyBeginAllowThreads();
40149 result = ((wxMenu const *)arg1)->GetTitle();
40150 wxPyEndAllowThreads(__tstate);
40151 if (PyErr_Occurred()) SWIG_fail;
40152 }
40153 {
40154 #if wxUSE_UNICODE
40155 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40156 #else
40157 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40158 #endif
40159 }
40160 return resultobj;
40161 fail:
40162 return NULL;
40163 }
40164
40165
40166 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40167 PyObject *resultobj = 0;
40168 wxMenu *arg1 = (wxMenu *) 0 ;
40169 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40170 void *argp1 = 0 ;
40171 int res1 = 0 ;
40172 void *argp2 = 0 ;
40173 int res2 = 0 ;
40174 PyObject * obj0 = 0 ;
40175 PyObject * obj1 = 0 ;
40176 char * kwnames[] = {
40177 (char *) "self",(char *) "handler", NULL
40178 };
40179
40180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40182 if (!SWIG_IsOK(res1)) {
40183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40184 }
40185 arg1 = reinterpret_cast< wxMenu * >(argp1);
40186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40187 if (!SWIG_IsOK(res2)) {
40188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40189 }
40190 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40191 {
40192 PyThreadState* __tstate = wxPyBeginAllowThreads();
40193 (arg1)->SetEventHandler(arg2);
40194 wxPyEndAllowThreads(__tstate);
40195 if (PyErr_Occurred()) SWIG_fail;
40196 }
40197 resultobj = SWIG_Py_Void();
40198 return resultobj;
40199 fail:
40200 return NULL;
40201 }
40202
40203
40204 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40205 PyObject *resultobj = 0;
40206 wxMenu *arg1 = (wxMenu *) 0 ;
40207 wxEvtHandler *result = 0 ;
40208 void *argp1 = 0 ;
40209 int res1 = 0 ;
40210 PyObject *swig_obj[1] ;
40211
40212 if (!args) SWIG_fail;
40213 swig_obj[0] = args;
40214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40215 if (!SWIG_IsOK(res1)) {
40216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40217 }
40218 arg1 = reinterpret_cast< wxMenu * >(argp1);
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40222 wxPyEndAllowThreads(__tstate);
40223 if (PyErr_Occurred()) SWIG_fail;
40224 }
40225 {
40226 resultobj = wxPyMake_wxObject(result, 0);
40227 }
40228 return resultobj;
40229 fail:
40230 return NULL;
40231 }
40232
40233
40234 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40235 PyObject *resultobj = 0;
40236 wxMenu *arg1 = (wxMenu *) 0 ;
40237 wxWindow *arg2 = (wxWindow *) 0 ;
40238 void *argp1 = 0 ;
40239 int res1 = 0 ;
40240 void *argp2 = 0 ;
40241 int res2 = 0 ;
40242 PyObject * obj0 = 0 ;
40243 PyObject * obj1 = 0 ;
40244 char * kwnames[] = {
40245 (char *) "self",(char *) "win", NULL
40246 };
40247
40248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40250 if (!SWIG_IsOK(res1)) {
40251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40252 }
40253 arg1 = reinterpret_cast< wxMenu * >(argp1);
40254 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40255 if (!SWIG_IsOK(res2)) {
40256 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40257 }
40258 arg2 = reinterpret_cast< wxWindow * >(argp2);
40259 {
40260 PyThreadState* __tstate = wxPyBeginAllowThreads();
40261 (arg1)->SetInvokingWindow(arg2);
40262 wxPyEndAllowThreads(__tstate);
40263 if (PyErr_Occurred()) SWIG_fail;
40264 }
40265 resultobj = SWIG_Py_Void();
40266 return resultobj;
40267 fail:
40268 return NULL;
40269 }
40270
40271
40272 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40273 PyObject *resultobj = 0;
40274 wxMenu *arg1 = (wxMenu *) 0 ;
40275 wxWindow *result = 0 ;
40276 void *argp1 = 0 ;
40277 int res1 = 0 ;
40278 PyObject *swig_obj[1] ;
40279
40280 if (!args) SWIG_fail;
40281 swig_obj[0] = args;
40282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40283 if (!SWIG_IsOK(res1)) {
40284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40285 }
40286 arg1 = reinterpret_cast< wxMenu * >(argp1);
40287 {
40288 PyThreadState* __tstate = wxPyBeginAllowThreads();
40289 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40290 wxPyEndAllowThreads(__tstate);
40291 if (PyErr_Occurred()) SWIG_fail;
40292 }
40293 {
40294 resultobj = wxPyMake_wxObject(result, 0);
40295 }
40296 return resultobj;
40297 fail:
40298 return NULL;
40299 }
40300
40301
40302 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40303 PyObject *resultobj = 0;
40304 wxMenu *arg1 = (wxMenu *) 0 ;
40305 long result;
40306 void *argp1 = 0 ;
40307 int res1 = 0 ;
40308 PyObject *swig_obj[1] ;
40309
40310 if (!args) SWIG_fail;
40311 swig_obj[0] = args;
40312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40313 if (!SWIG_IsOK(res1)) {
40314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40315 }
40316 arg1 = reinterpret_cast< wxMenu * >(argp1);
40317 {
40318 PyThreadState* __tstate = wxPyBeginAllowThreads();
40319 result = (long)((wxMenu const *)arg1)->GetStyle();
40320 wxPyEndAllowThreads(__tstate);
40321 if (PyErr_Occurred()) SWIG_fail;
40322 }
40323 resultobj = SWIG_From_long(static_cast< long >(result));
40324 return resultobj;
40325 fail:
40326 return NULL;
40327 }
40328
40329
40330 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40331 PyObject *resultobj = 0;
40332 wxMenu *arg1 = (wxMenu *) 0 ;
40333 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40334 void *argp1 = 0 ;
40335 int res1 = 0 ;
40336 void *argp2 = 0 ;
40337 int res2 = 0 ;
40338 PyObject * obj0 = 0 ;
40339 PyObject * obj1 = 0 ;
40340 char * kwnames[] = {
40341 (char *) "self",(char *) "source", NULL
40342 };
40343
40344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40346 if (!SWIG_IsOK(res1)) {
40347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40348 }
40349 arg1 = reinterpret_cast< wxMenu * >(argp1);
40350 if (obj1) {
40351 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40352 if (!SWIG_IsOK(res2)) {
40353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40354 }
40355 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40356 }
40357 {
40358 PyThreadState* __tstate = wxPyBeginAllowThreads();
40359 (arg1)->UpdateUI(arg2);
40360 wxPyEndAllowThreads(__tstate);
40361 if (PyErr_Occurred()) SWIG_fail;
40362 }
40363 resultobj = SWIG_Py_Void();
40364 return resultobj;
40365 fail:
40366 return NULL;
40367 }
40368
40369
40370 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40371 PyObject *resultobj = 0;
40372 wxMenu *arg1 = (wxMenu *) 0 ;
40373 wxMenuBar *result = 0 ;
40374 void *argp1 = 0 ;
40375 int res1 = 0 ;
40376 PyObject *swig_obj[1] ;
40377
40378 if (!args) SWIG_fail;
40379 swig_obj[0] = args;
40380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40381 if (!SWIG_IsOK(res1)) {
40382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40383 }
40384 arg1 = reinterpret_cast< wxMenu * >(argp1);
40385 {
40386 PyThreadState* __tstate = wxPyBeginAllowThreads();
40387 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40388 wxPyEndAllowThreads(__tstate);
40389 if (PyErr_Occurred()) SWIG_fail;
40390 }
40391 {
40392 resultobj = wxPyMake_wxObject(result, (bool)0);
40393 }
40394 return resultobj;
40395 fail:
40396 return NULL;
40397 }
40398
40399
40400 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj = 0;
40402 wxMenu *arg1 = (wxMenu *) 0 ;
40403 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40404 void *argp1 = 0 ;
40405 int res1 = 0 ;
40406 void *argp2 = 0 ;
40407 int res2 = 0 ;
40408 PyObject * obj0 = 0 ;
40409 PyObject * obj1 = 0 ;
40410 char * kwnames[] = {
40411 (char *) "self",(char *) "menubar", NULL
40412 };
40413
40414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40416 if (!SWIG_IsOK(res1)) {
40417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40418 }
40419 arg1 = reinterpret_cast< wxMenu * >(argp1);
40420 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40421 if (!SWIG_IsOK(res2)) {
40422 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40423 }
40424 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40425 {
40426 PyThreadState* __tstate = wxPyBeginAllowThreads();
40427 (arg1)->Attach(arg2);
40428 wxPyEndAllowThreads(__tstate);
40429 if (PyErr_Occurred()) SWIG_fail;
40430 }
40431 resultobj = SWIG_Py_Void();
40432 return resultobj;
40433 fail:
40434 return NULL;
40435 }
40436
40437
40438 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40439 PyObject *resultobj = 0;
40440 wxMenu *arg1 = (wxMenu *) 0 ;
40441 void *argp1 = 0 ;
40442 int res1 = 0 ;
40443 PyObject *swig_obj[1] ;
40444
40445 if (!args) SWIG_fail;
40446 swig_obj[0] = args;
40447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40448 if (!SWIG_IsOK(res1)) {
40449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40450 }
40451 arg1 = reinterpret_cast< wxMenu * >(argp1);
40452 {
40453 PyThreadState* __tstate = wxPyBeginAllowThreads();
40454 (arg1)->Detach();
40455 wxPyEndAllowThreads(__tstate);
40456 if (PyErr_Occurred()) SWIG_fail;
40457 }
40458 resultobj = SWIG_Py_Void();
40459 return resultobj;
40460 fail:
40461 return NULL;
40462 }
40463
40464
40465 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40466 PyObject *resultobj = 0;
40467 wxMenu *arg1 = (wxMenu *) 0 ;
40468 bool result;
40469 void *argp1 = 0 ;
40470 int res1 = 0 ;
40471 PyObject *swig_obj[1] ;
40472
40473 if (!args) SWIG_fail;
40474 swig_obj[0] = args;
40475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40476 if (!SWIG_IsOK(res1)) {
40477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40478 }
40479 arg1 = reinterpret_cast< wxMenu * >(argp1);
40480 {
40481 PyThreadState* __tstate = wxPyBeginAllowThreads();
40482 result = (bool)((wxMenu const *)arg1)->IsAttached();
40483 wxPyEndAllowThreads(__tstate);
40484 if (PyErr_Occurred()) SWIG_fail;
40485 }
40486 {
40487 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40488 }
40489 return resultobj;
40490 fail:
40491 return NULL;
40492 }
40493
40494
40495 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40496 PyObject *resultobj = 0;
40497 wxMenu *arg1 = (wxMenu *) 0 ;
40498 wxMenu *arg2 = (wxMenu *) 0 ;
40499 void *argp1 = 0 ;
40500 int res1 = 0 ;
40501 void *argp2 = 0 ;
40502 int res2 = 0 ;
40503 PyObject * obj0 = 0 ;
40504 PyObject * obj1 = 0 ;
40505 char * kwnames[] = {
40506 (char *) "self",(char *) "parent", NULL
40507 };
40508
40509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40511 if (!SWIG_IsOK(res1)) {
40512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40513 }
40514 arg1 = reinterpret_cast< wxMenu * >(argp1);
40515 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40516 if (!SWIG_IsOK(res2)) {
40517 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40518 }
40519 arg2 = reinterpret_cast< wxMenu * >(argp2);
40520 {
40521 PyThreadState* __tstate = wxPyBeginAllowThreads();
40522 (arg1)->SetParent(arg2);
40523 wxPyEndAllowThreads(__tstate);
40524 if (PyErr_Occurred()) SWIG_fail;
40525 }
40526 resultobj = SWIG_Py_Void();
40527 return resultobj;
40528 fail:
40529 return NULL;
40530 }
40531
40532
40533 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40534 PyObject *resultobj = 0;
40535 wxMenu *arg1 = (wxMenu *) 0 ;
40536 wxMenu *result = 0 ;
40537 void *argp1 = 0 ;
40538 int res1 = 0 ;
40539 PyObject *swig_obj[1] ;
40540
40541 if (!args) SWIG_fail;
40542 swig_obj[0] = args;
40543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40544 if (!SWIG_IsOK(res1)) {
40545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40546 }
40547 arg1 = reinterpret_cast< wxMenu * >(argp1);
40548 {
40549 PyThreadState* __tstate = wxPyBeginAllowThreads();
40550 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40551 wxPyEndAllowThreads(__tstate);
40552 if (PyErr_Occurred()) SWIG_fail;
40553 }
40554 {
40555 resultobj = wxPyMake_wxObject(result, 0);
40556 }
40557 return resultobj;
40558 fail:
40559 return NULL;
40560 }
40561
40562
40563 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40564 PyObject *obj;
40565 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40566 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40567 return SWIG_Py_Void();
40568 }
40569
40570 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40571 return SWIG_Python_InitShadowInstance(args);
40572 }
40573
40574 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40575 PyObject *resultobj = 0;
40576 long arg1 = (long) 0 ;
40577 wxMenuBar *result = 0 ;
40578 long val1 ;
40579 int ecode1 = 0 ;
40580 PyObject * obj0 = 0 ;
40581 char * kwnames[] = {
40582 (char *) "style", NULL
40583 };
40584
40585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40586 if (obj0) {
40587 ecode1 = SWIG_AsVal_long(obj0, &val1);
40588 if (!SWIG_IsOK(ecode1)) {
40589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40590 }
40591 arg1 = static_cast< long >(val1);
40592 }
40593 {
40594 if (!wxPyCheckForApp()) SWIG_fail;
40595 PyThreadState* __tstate = wxPyBeginAllowThreads();
40596 result = (wxMenuBar *)new wxMenuBar(arg1);
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40601 return resultobj;
40602 fail:
40603 return NULL;
40604 }
40605
40606
40607 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40608 PyObject *resultobj = 0;
40609 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40610 wxMenu *arg2 = (wxMenu *) 0 ;
40611 wxString *arg3 = 0 ;
40612 bool result;
40613 void *argp1 = 0 ;
40614 int res1 = 0 ;
40615 void *argp2 = 0 ;
40616 int res2 = 0 ;
40617 bool temp3 = false ;
40618 PyObject * obj0 = 0 ;
40619 PyObject * obj1 = 0 ;
40620 PyObject * obj2 = 0 ;
40621 char * kwnames[] = {
40622 (char *) "self",(char *) "menu",(char *) "title", NULL
40623 };
40624
40625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40627 if (!SWIG_IsOK(res1)) {
40628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40629 }
40630 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40631 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40632 if (!SWIG_IsOK(res2)) {
40633 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40634 }
40635 arg2 = reinterpret_cast< wxMenu * >(argp2);
40636 {
40637 arg3 = wxString_in_helper(obj2);
40638 if (arg3 == NULL) SWIG_fail;
40639 temp3 = true;
40640 }
40641 {
40642 PyThreadState* __tstate = wxPyBeginAllowThreads();
40643 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40644 wxPyEndAllowThreads(__tstate);
40645 if (PyErr_Occurred()) SWIG_fail;
40646 }
40647 {
40648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40649 }
40650 {
40651 if (temp3)
40652 delete arg3;
40653 }
40654 return resultobj;
40655 fail:
40656 {
40657 if (temp3)
40658 delete arg3;
40659 }
40660 return NULL;
40661 }
40662
40663
40664 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40665 PyObject *resultobj = 0;
40666 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40667 size_t arg2 ;
40668 wxMenu *arg3 = (wxMenu *) 0 ;
40669 wxString *arg4 = 0 ;
40670 bool result;
40671 void *argp1 = 0 ;
40672 int res1 = 0 ;
40673 size_t val2 ;
40674 int ecode2 = 0 ;
40675 void *argp3 = 0 ;
40676 int res3 = 0 ;
40677 bool temp4 = false ;
40678 PyObject * obj0 = 0 ;
40679 PyObject * obj1 = 0 ;
40680 PyObject * obj2 = 0 ;
40681 PyObject * obj3 = 0 ;
40682 char * kwnames[] = {
40683 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40684 };
40685
40686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40688 if (!SWIG_IsOK(res1)) {
40689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40690 }
40691 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40692 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40693 if (!SWIG_IsOK(ecode2)) {
40694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40695 }
40696 arg2 = static_cast< size_t >(val2);
40697 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40698 if (!SWIG_IsOK(res3)) {
40699 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40700 }
40701 arg3 = reinterpret_cast< wxMenu * >(argp3);
40702 {
40703 arg4 = wxString_in_helper(obj3);
40704 if (arg4 == NULL) SWIG_fail;
40705 temp4 = true;
40706 }
40707 {
40708 PyThreadState* __tstate = wxPyBeginAllowThreads();
40709 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40710 wxPyEndAllowThreads(__tstate);
40711 if (PyErr_Occurred()) SWIG_fail;
40712 }
40713 {
40714 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40715 }
40716 {
40717 if (temp4)
40718 delete arg4;
40719 }
40720 return resultobj;
40721 fail:
40722 {
40723 if (temp4)
40724 delete arg4;
40725 }
40726 return NULL;
40727 }
40728
40729
40730 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40731 PyObject *resultobj = 0;
40732 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40733 size_t result;
40734 void *argp1 = 0 ;
40735 int res1 = 0 ;
40736 PyObject *swig_obj[1] ;
40737
40738 if (!args) SWIG_fail;
40739 swig_obj[0] = args;
40740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40741 if (!SWIG_IsOK(res1)) {
40742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40743 }
40744 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40745 {
40746 PyThreadState* __tstate = wxPyBeginAllowThreads();
40747 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40752 return resultobj;
40753 fail:
40754 return NULL;
40755 }
40756
40757
40758 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40759 PyObject *resultobj = 0;
40760 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40761 size_t arg2 ;
40762 wxMenu *result = 0 ;
40763 void *argp1 = 0 ;
40764 int res1 = 0 ;
40765 size_t val2 ;
40766 int ecode2 = 0 ;
40767 PyObject * obj0 = 0 ;
40768 PyObject * obj1 = 0 ;
40769 char * kwnames[] = {
40770 (char *) "self",(char *) "pos", NULL
40771 };
40772
40773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
40774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40775 if (!SWIG_IsOK(res1)) {
40776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40777 }
40778 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40779 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40780 if (!SWIG_IsOK(ecode2)) {
40781 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
40782 }
40783 arg2 = static_cast< size_t >(val2);
40784 {
40785 PyThreadState* __tstate = wxPyBeginAllowThreads();
40786 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
40787 wxPyEndAllowThreads(__tstate);
40788 if (PyErr_Occurred()) SWIG_fail;
40789 }
40790 {
40791 resultobj = wxPyMake_wxObject(result, 0);
40792 }
40793 return resultobj;
40794 fail:
40795 return NULL;
40796 }
40797
40798
40799 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40800 PyObject *resultobj = 0;
40801 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40802 size_t arg2 ;
40803 wxMenu *arg3 = (wxMenu *) 0 ;
40804 wxString *arg4 = 0 ;
40805 wxMenu *result = 0 ;
40806 void *argp1 = 0 ;
40807 int res1 = 0 ;
40808 size_t val2 ;
40809 int ecode2 = 0 ;
40810 void *argp3 = 0 ;
40811 int res3 = 0 ;
40812 bool temp4 = false ;
40813 PyObject * obj0 = 0 ;
40814 PyObject * obj1 = 0 ;
40815 PyObject * obj2 = 0 ;
40816 PyObject * obj3 = 0 ;
40817 char * kwnames[] = {
40818 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40819 };
40820
40821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40823 if (!SWIG_IsOK(res1)) {
40824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40825 }
40826 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40827 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40828 if (!SWIG_IsOK(ecode2)) {
40829 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
40830 }
40831 arg2 = static_cast< size_t >(val2);
40832 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40833 if (!SWIG_IsOK(res3)) {
40834 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
40835 }
40836 arg3 = reinterpret_cast< wxMenu * >(argp3);
40837 {
40838 arg4 = wxString_in_helper(obj3);
40839 if (arg4 == NULL) SWIG_fail;
40840 temp4 = true;
40841 }
40842 {
40843 PyThreadState* __tstate = wxPyBeginAllowThreads();
40844 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
40845 wxPyEndAllowThreads(__tstate);
40846 if (PyErr_Occurred()) SWIG_fail;
40847 }
40848 {
40849 resultobj = wxPyMake_wxObject(result, 0);
40850 }
40851 {
40852 if (temp4)
40853 delete arg4;
40854 }
40855 return resultobj;
40856 fail:
40857 {
40858 if (temp4)
40859 delete arg4;
40860 }
40861 return NULL;
40862 }
40863
40864
40865 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40866 PyObject *resultobj = 0;
40867 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40868 size_t arg2 ;
40869 wxMenu *result = 0 ;
40870 void *argp1 = 0 ;
40871 int res1 = 0 ;
40872 size_t val2 ;
40873 int ecode2 = 0 ;
40874 PyObject * obj0 = 0 ;
40875 PyObject * obj1 = 0 ;
40876 char * kwnames[] = {
40877 (char *) "self",(char *) "pos", NULL
40878 };
40879
40880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
40881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40882 if (!SWIG_IsOK(res1)) {
40883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40884 }
40885 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40886 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40887 if (!SWIG_IsOK(ecode2)) {
40888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
40889 }
40890 arg2 = static_cast< size_t >(val2);
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 result = (wxMenu *)(arg1)->Remove(arg2);
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = wxPyMake_wxObject(result, 0);
40899 }
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40907 PyObject *resultobj = 0;
40908 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40909 size_t arg2 ;
40910 bool arg3 ;
40911 void *argp1 = 0 ;
40912 int res1 = 0 ;
40913 size_t val2 ;
40914 int ecode2 = 0 ;
40915 bool val3 ;
40916 int ecode3 = 0 ;
40917 PyObject * obj0 = 0 ;
40918 PyObject * obj1 = 0 ;
40919 PyObject * obj2 = 0 ;
40920 char * kwnames[] = {
40921 (char *) "self",(char *) "pos",(char *) "enable", NULL
40922 };
40923
40924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40926 if (!SWIG_IsOK(res1)) {
40927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40928 }
40929 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40930 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40931 if (!SWIG_IsOK(ecode2)) {
40932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
40933 }
40934 arg2 = static_cast< size_t >(val2);
40935 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40936 if (!SWIG_IsOK(ecode3)) {
40937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
40938 }
40939 arg3 = static_cast< bool >(val3);
40940 {
40941 PyThreadState* __tstate = wxPyBeginAllowThreads();
40942 (arg1)->EnableTop(arg2,arg3);
40943 wxPyEndAllowThreads(__tstate);
40944 if (PyErr_Occurred()) SWIG_fail;
40945 }
40946 resultobj = SWIG_Py_Void();
40947 return resultobj;
40948 fail:
40949 return NULL;
40950 }
40951
40952
40953 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40954 PyObject *resultobj = 0;
40955 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40956 size_t arg2 ;
40957 bool result;
40958 void *argp1 = 0 ;
40959 int res1 = 0 ;
40960 size_t val2 ;
40961 int ecode2 = 0 ;
40962 PyObject * obj0 = 0 ;
40963 PyObject * obj1 = 0 ;
40964 char * kwnames[] = {
40965 (char *) "self",(char *) "pos", NULL
40966 };
40967
40968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
40969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40970 if (!SWIG_IsOK(res1)) {
40971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40972 }
40973 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40974 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40975 if (!SWIG_IsOK(ecode2)) {
40976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
40977 }
40978 arg2 = static_cast< size_t >(val2);
40979 {
40980 PyThreadState* __tstate = wxPyBeginAllowThreads();
40981 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
40982 wxPyEndAllowThreads(__tstate);
40983 if (PyErr_Occurred()) SWIG_fail;
40984 }
40985 {
40986 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40987 }
40988 return resultobj;
40989 fail:
40990 return NULL;
40991 }
40992
40993
40994 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40995 PyObject *resultobj = 0;
40996 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40997 size_t arg2 ;
40998 wxString *arg3 = 0 ;
40999 void *argp1 = 0 ;
41000 int res1 = 0 ;
41001 size_t val2 ;
41002 int ecode2 = 0 ;
41003 bool temp3 = false ;
41004 PyObject * obj0 = 0 ;
41005 PyObject * obj1 = 0 ;
41006 PyObject * obj2 = 0 ;
41007 char * kwnames[] = {
41008 (char *) "self",(char *) "pos",(char *) "label", NULL
41009 };
41010
41011 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41012 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41013 if (!SWIG_IsOK(res1)) {
41014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41015 }
41016 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41017 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41018 if (!SWIG_IsOK(ecode2)) {
41019 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41020 }
41021 arg2 = static_cast< size_t >(val2);
41022 {
41023 arg3 = wxString_in_helper(obj2);
41024 if (arg3 == NULL) SWIG_fail;
41025 temp3 = true;
41026 }
41027 {
41028 PyThreadState* __tstate = wxPyBeginAllowThreads();
41029 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41030 wxPyEndAllowThreads(__tstate);
41031 if (PyErr_Occurred()) SWIG_fail;
41032 }
41033 resultobj = SWIG_Py_Void();
41034 {
41035 if (temp3)
41036 delete arg3;
41037 }
41038 return resultobj;
41039 fail:
41040 {
41041 if (temp3)
41042 delete arg3;
41043 }
41044 return NULL;
41045 }
41046
41047
41048 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41049 PyObject *resultobj = 0;
41050 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41051 size_t arg2 ;
41052 wxString result;
41053 void *argp1 = 0 ;
41054 int res1 = 0 ;
41055 size_t val2 ;
41056 int ecode2 = 0 ;
41057 PyObject * obj0 = 0 ;
41058 PyObject * obj1 = 0 ;
41059 char * kwnames[] = {
41060 (char *) "self",(char *) "pos", NULL
41061 };
41062
41063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41065 if (!SWIG_IsOK(res1)) {
41066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41067 }
41068 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41069 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41070 if (!SWIG_IsOK(ecode2)) {
41071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41072 }
41073 arg2 = static_cast< size_t >(val2);
41074 {
41075 PyThreadState* __tstate = wxPyBeginAllowThreads();
41076 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41077 wxPyEndAllowThreads(__tstate);
41078 if (PyErr_Occurred()) SWIG_fail;
41079 }
41080 {
41081 #if wxUSE_UNICODE
41082 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41083 #else
41084 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41085 #endif
41086 }
41087 return resultobj;
41088 fail:
41089 return NULL;
41090 }
41091
41092
41093 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41094 PyObject *resultobj = 0;
41095 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41096 wxString *arg2 = 0 ;
41097 wxString *arg3 = 0 ;
41098 int result;
41099 void *argp1 = 0 ;
41100 int res1 = 0 ;
41101 bool temp2 = false ;
41102 bool temp3 = false ;
41103 PyObject * obj0 = 0 ;
41104 PyObject * obj1 = 0 ;
41105 PyObject * obj2 = 0 ;
41106 char * kwnames[] = {
41107 (char *) "self",(char *) "menu",(char *) "item", NULL
41108 };
41109
41110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41112 if (!SWIG_IsOK(res1)) {
41113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41114 }
41115 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41116 {
41117 arg2 = wxString_in_helper(obj1);
41118 if (arg2 == NULL) SWIG_fail;
41119 temp2 = true;
41120 }
41121 {
41122 arg3 = wxString_in_helper(obj2);
41123 if (arg3 == NULL) SWIG_fail;
41124 temp3 = true;
41125 }
41126 {
41127 PyThreadState* __tstate = wxPyBeginAllowThreads();
41128 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41129 wxPyEndAllowThreads(__tstate);
41130 if (PyErr_Occurred()) SWIG_fail;
41131 }
41132 resultobj = SWIG_From_int(static_cast< int >(result));
41133 {
41134 if (temp2)
41135 delete arg2;
41136 }
41137 {
41138 if (temp3)
41139 delete arg3;
41140 }
41141 return resultobj;
41142 fail:
41143 {
41144 if (temp2)
41145 delete arg2;
41146 }
41147 {
41148 if (temp3)
41149 delete arg3;
41150 }
41151 return NULL;
41152 }
41153
41154
41155 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41156 PyObject *resultobj = 0;
41157 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41158 int arg2 ;
41159 wxMenuItem *result = 0 ;
41160 void *argp1 = 0 ;
41161 int res1 = 0 ;
41162 int val2 ;
41163 int ecode2 = 0 ;
41164 PyObject * obj0 = 0 ;
41165 PyObject * obj1 = 0 ;
41166 char * kwnames[] = {
41167 (char *) "self",(char *) "id", NULL
41168 };
41169
41170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41172 if (!SWIG_IsOK(res1)) {
41173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41174 }
41175 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41176 ecode2 = SWIG_AsVal_int(obj1, &val2);
41177 if (!SWIG_IsOK(ecode2)) {
41178 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41179 }
41180 arg2 = static_cast< int >(val2);
41181 {
41182 PyThreadState* __tstate = wxPyBeginAllowThreads();
41183 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41184 wxPyEndAllowThreads(__tstate);
41185 if (PyErr_Occurred()) SWIG_fail;
41186 }
41187 {
41188 resultobj = wxPyMake_wxObject(result, (bool)0);
41189 }
41190 return resultobj;
41191 fail:
41192 return NULL;
41193 }
41194
41195
41196 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41197 PyObject *resultobj = 0;
41198 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41199 wxString *arg2 = 0 ;
41200 int result;
41201 void *argp1 = 0 ;
41202 int res1 = 0 ;
41203 bool temp2 = false ;
41204 PyObject * obj0 = 0 ;
41205 PyObject * obj1 = 0 ;
41206 char * kwnames[] = {
41207 (char *) "self",(char *) "title", NULL
41208 };
41209
41210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41212 if (!SWIG_IsOK(res1)) {
41213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41214 }
41215 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41216 {
41217 arg2 = wxString_in_helper(obj1);
41218 if (arg2 == NULL) SWIG_fail;
41219 temp2 = true;
41220 }
41221 {
41222 PyThreadState* __tstate = wxPyBeginAllowThreads();
41223 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41224 wxPyEndAllowThreads(__tstate);
41225 if (PyErr_Occurred()) SWIG_fail;
41226 }
41227 resultobj = SWIG_From_int(static_cast< int >(result));
41228 {
41229 if (temp2)
41230 delete arg2;
41231 }
41232 return resultobj;
41233 fail:
41234 {
41235 if (temp2)
41236 delete arg2;
41237 }
41238 return NULL;
41239 }
41240
41241
41242 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41243 PyObject *resultobj = 0;
41244 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41245 int arg2 ;
41246 bool arg3 ;
41247 void *argp1 = 0 ;
41248 int res1 = 0 ;
41249 int val2 ;
41250 int ecode2 = 0 ;
41251 bool val3 ;
41252 int ecode3 = 0 ;
41253 PyObject * obj0 = 0 ;
41254 PyObject * obj1 = 0 ;
41255 PyObject * obj2 = 0 ;
41256 char * kwnames[] = {
41257 (char *) "self",(char *) "id",(char *) "enable", NULL
41258 };
41259
41260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41262 if (!SWIG_IsOK(res1)) {
41263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41264 }
41265 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41266 ecode2 = SWIG_AsVal_int(obj1, &val2);
41267 if (!SWIG_IsOK(ecode2)) {
41268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41269 }
41270 arg2 = static_cast< int >(val2);
41271 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41272 if (!SWIG_IsOK(ecode3)) {
41273 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41274 }
41275 arg3 = static_cast< bool >(val3);
41276 {
41277 PyThreadState* __tstate = wxPyBeginAllowThreads();
41278 (arg1)->Enable(arg2,arg3);
41279 wxPyEndAllowThreads(__tstate);
41280 if (PyErr_Occurred()) SWIG_fail;
41281 }
41282 resultobj = SWIG_Py_Void();
41283 return resultobj;
41284 fail:
41285 return NULL;
41286 }
41287
41288
41289 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41290 PyObject *resultobj = 0;
41291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41292 int arg2 ;
41293 bool arg3 ;
41294 void *argp1 = 0 ;
41295 int res1 = 0 ;
41296 int val2 ;
41297 int ecode2 = 0 ;
41298 bool val3 ;
41299 int ecode3 = 0 ;
41300 PyObject * obj0 = 0 ;
41301 PyObject * obj1 = 0 ;
41302 PyObject * obj2 = 0 ;
41303 char * kwnames[] = {
41304 (char *) "self",(char *) "id",(char *) "check", NULL
41305 };
41306
41307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41309 if (!SWIG_IsOK(res1)) {
41310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41311 }
41312 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41313 ecode2 = SWIG_AsVal_int(obj1, &val2);
41314 if (!SWIG_IsOK(ecode2)) {
41315 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41316 }
41317 arg2 = static_cast< int >(val2);
41318 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41319 if (!SWIG_IsOK(ecode3)) {
41320 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41321 }
41322 arg3 = static_cast< bool >(val3);
41323 {
41324 PyThreadState* __tstate = wxPyBeginAllowThreads();
41325 (arg1)->Check(arg2,arg3);
41326 wxPyEndAllowThreads(__tstate);
41327 if (PyErr_Occurred()) SWIG_fail;
41328 }
41329 resultobj = SWIG_Py_Void();
41330 return resultobj;
41331 fail:
41332 return NULL;
41333 }
41334
41335
41336 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41337 PyObject *resultobj = 0;
41338 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41339 int arg2 ;
41340 bool result;
41341 void *argp1 = 0 ;
41342 int res1 = 0 ;
41343 int val2 ;
41344 int ecode2 = 0 ;
41345 PyObject * obj0 = 0 ;
41346 PyObject * obj1 = 0 ;
41347 char * kwnames[] = {
41348 (char *) "self",(char *) "id", NULL
41349 };
41350
41351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41353 if (!SWIG_IsOK(res1)) {
41354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41355 }
41356 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41357 ecode2 = SWIG_AsVal_int(obj1, &val2);
41358 if (!SWIG_IsOK(ecode2)) {
41359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41360 }
41361 arg2 = static_cast< int >(val2);
41362 {
41363 PyThreadState* __tstate = wxPyBeginAllowThreads();
41364 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41365 wxPyEndAllowThreads(__tstate);
41366 if (PyErr_Occurred()) SWIG_fail;
41367 }
41368 {
41369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41370 }
41371 return resultobj;
41372 fail:
41373 return NULL;
41374 }
41375
41376
41377 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41378 PyObject *resultobj = 0;
41379 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41380 int arg2 ;
41381 bool result;
41382 void *argp1 = 0 ;
41383 int res1 = 0 ;
41384 int val2 ;
41385 int ecode2 = 0 ;
41386 PyObject * obj0 = 0 ;
41387 PyObject * obj1 = 0 ;
41388 char * kwnames[] = {
41389 (char *) "self",(char *) "id", NULL
41390 };
41391
41392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41394 if (!SWIG_IsOK(res1)) {
41395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41396 }
41397 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41398 ecode2 = SWIG_AsVal_int(obj1, &val2);
41399 if (!SWIG_IsOK(ecode2)) {
41400 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41401 }
41402 arg2 = static_cast< int >(val2);
41403 {
41404 PyThreadState* __tstate = wxPyBeginAllowThreads();
41405 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41406 wxPyEndAllowThreads(__tstate);
41407 if (PyErr_Occurred()) SWIG_fail;
41408 }
41409 {
41410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41411 }
41412 return resultobj;
41413 fail:
41414 return NULL;
41415 }
41416
41417
41418 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj = 0;
41420 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41421 int arg2 ;
41422 wxString *arg3 = 0 ;
41423 void *argp1 = 0 ;
41424 int res1 = 0 ;
41425 int val2 ;
41426 int ecode2 = 0 ;
41427 bool temp3 = false ;
41428 PyObject * obj0 = 0 ;
41429 PyObject * obj1 = 0 ;
41430 PyObject * obj2 = 0 ;
41431 char * kwnames[] = {
41432 (char *) "self",(char *) "id",(char *) "label", NULL
41433 };
41434
41435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41437 if (!SWIG_IsOK(res1)) {
41438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41439 }
41440 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41441 ecode2 = SWIG_AsVal_int(obj1, &val2);
41442 if (!SWIG_IsOK(ecode2)) {
41443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41444 }
41445 arg2 = static_cast< int >(val2);
41446 {
41447 arg3 = wxString_in_helper(obj2);
41448 if (arg3 == NULL) SWIG_fail;
41449 temp3 = true;
41450 }
41451 {
41452 PyThreadState* __tstate = wxPyBeginAllowThreads();
41453 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41454 wxPyEndAllowThreads(__tstate);
41455 if (PyErr_Occurred()) SWIG_fail;
41456 }
41457 resultobj = SWIG_Py_Void();
41458 {
41459 if (temp3)
41460 delete arg3;
41461 }
41462 return resultobj;
41463 fail:
41464 {
41465 if (temp3)
41466 delete arg3;
41467 }
41468 return NULL;
41469 }
41470
41471
41472 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41473 PyObject *resultobj = 0;
41474 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41475 int arg2 ;
41476 wxString result;
41477 void *argp1 = 0 ;
41478 int res1 = 0 ;
41479 int val2 ;
41480 int ecode2 = 0 ;
41481 PyObject * obj0 = 0 ;
41482 PyObject * obj1 = 0 ;
41483 char * kwnames[] = {
41484 (char *) "self",(char *) "id", NULL
41485 };
41486
41487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41489 if (!SWIG_IsOK(res1)) {
41490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41491 }
41492 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41493 ecode2 = SWIG_AsVal_int(obj1, &val2);
41494 if (!SWIG_IsOK(ecode2)) {
41495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41496 }
41497 arg2 = static_cast< int >(val2);
41498 {
41499 PyThreadState* __tstate = wxPyBeginAllowThreads();
41500 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41501 wxPyEndAllowThreads(__tstate);
41502 if (PyErr_Occurred()) SWIG_fail;
41503 }
41504 {
41505 #if wxUSE_UNICODE
41506 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41507 #else
41508 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41509 #endif
41510 }
41511 return resultobj;
41512 fail:
41513 return NULL;
41514 }
41515
41516
41517 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41518 PyObject *resultobj = 0;
41519 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41520 int arg2 ;
41521 wxString *arg3 = 0 ;
41522 void *argp1 = 0 ;
41523 int res1 = 0 ;
41524 int val2 ;
41525 int ecode2 = 0 ;
41526 bool temp3 = false ;
41527 PyObject * obj0 = 0 ;
41528 PyObject * obj1 = 0 ;
41529 PyObject * obj2 = 0 ;
41530 char * kwnames[] = {
41531 (char *) "self",(char *) "id",(char *) "helpString", NULL
41532 };
41533
41534 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41535 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41536 if (!SWIG_IsOK(res1)) {
41537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41538 }
41539 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41540 ecode2 = SWIG_AsVal_int(obj1, &val2);
41541 if (!SWIG_IsOK(ecode2)) {
41542 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41543 }
41544 arg2 = static_cast< int >(val2);
41545 {
41546 arg3 = wxString_in_helper(obj2);
41547 if (arg3 == NULL) SWIG_fail;
41548 temp3 = true;
41549 }
41550 {
41551 PyThreadState* __tstate = wxPyBeginAllowThreads();
41552 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41553 wxPyEndAllowThreads(__tstate);
41554 if (PyErr_Occurred()) SWIG_fail;
41555 }
41556 resultobj = SWIG_Py_Void();
41557 {
41558 if (temp3)
41559 delete arg3;
41560 }
41561 return resultobj;
41562 fail:
41563 {
41564 if (temp3)
41565 delete arg3;
41566 }
41567 return NULL;
41568 }
41569
41570
41571 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41572 PyObject *resultobj = 0;
41573 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41574 int arg2 ;
41575 wxString result;
41576 void *argp1 = 0 ;
41577 int res1 = 0 ;
41578 int val2 ;
41579 int ecode2 = 0 ;
41580 PyObject * obj0 = 0 ;
41581 PyObject * obj1 = 0 ;
41582 char * kwnames[] = {
41583 (char *) "self",(char *) "id", NULL
41584 };
41585
41586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41588 if (!SWIG_IsOK(res1)) {
41589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41590 }
41591 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41592 ecode2 = SWIG_AsVal_int(obj1, &val2);
41593 if (!SWIG_IsOK(ecode2)) {
41594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41595 }
41596 arg2 = static_cast< int >(val2);
41597 {
41598 PyThreadState* __tstate = wxPyBeginAllowThreads();
41599 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41600 wxPyEndAllowThreads(__tstate);
41601 if (PyErr_Occurred()) SWIG_fail;
41602 }
41603 {
41604 #if wxUSE_UNICODE
41605 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41606 #else
41607 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41608 #endif
41609 }
41610 return resultobj;
41611 fail:
41612 return NULL;
41613 }
41614
41615
41616 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41617 PyObject *resultobj = 0;
41618 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41619 wxFrame *result = 0 ;
41620 void *argp1 = 0 ;
41621 int res1 = 0 ;
41622 PyObject *swig_obj[1] ;
41623
41624 if (!args) SWIG_fail;
41625 swig_obj[0] = args;
41626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41627 if (!SWIG_IsOK(res1)) {
41628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41629 }
41630 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41631 {
41632 PyThreadState* __tstate = wxPyBeginAllowThreads();
41633 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41634 wxPyEndAllowThreads(__tstate);
41635 if (PyErr_Occurred()) SWIG_fail;
41636 }
41637 {
41638 resultobj = wxPyMake_wxObject(result, (bool)0);
41639 }
41640 return resultobj;
41641 fail:
41642 return NULL;
41643 }
41644
41645
41646 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41647 PyObject *resultobj = 0;
41648 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41649 bool result;
41650 void *argp1 = 0 ;
41651 int res1 = 0 ;
41652 PyObject *swig_obj[1] ;
41653
41654 if (!args) SWIG_fail;
41655 swig_obj[0] = args;
41656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41657 if (!SWIG_IsOK(res1)) {
41658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41659 }
41660 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41661 {
41662 PyThreadState* __tstate = wxPyBeginAllowThreads();
41663 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41664 wxPyEndAllowThreads(__tstate);
41665 if (PyErr_Occurred()) SWIG_fail;
41666 }
41667 {
41668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41669 }
41670 return resultobj;
41671 fail:
41672 return NULL;
41673 }
41674
41675
41676 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41677 PyObject *resultobj = 0;
41678 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41679 wxFrame *arg2 = (wxFrame *) 0 ;
41680 void *argp1 = 0 ;
41681 int res1 = 0 ;
41682 void *argp2 = 0 ;
41683 int res2 = 0 ;
41684 PyObject * obj0 = 0 ;
41685 PyObject * obj1 = 0 ;
41686 char * kwnames[] = {
41687 (char *) "self",(char *) "frame", NULL
41688 };
41689
41690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41692 if (!SWIG_IsOK(res1)) {
41693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41694 }
41695 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41696 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41697 if (!SWIG_IsOK(res2)) {
41698 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41699 }
41700 arg2 = reinterpret_cast< wxFrame * >(argp2);
41701 {
41702 PyThreadState* __tstate = wxPyBeginAllowThreads();
41703 (arg1)->Attach(arg2);
41704 wxPyEndAllowThreads(__tstate);
41705 if (PyErr_Occurred()) SWIG_fail;
41706 }
41707 resultobj = SWIG_Py_Void();
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41715 PyObject *resultobj = 0;
41716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41717 void *argp1 = 0 ;
41718 int res1 = 0 ;
41719 PyObject *swig_obj[1] ;
41720
41721 if (!args) SWIG_fail;
41722 swig_obj[0] = args;
41723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41724 if (!SWIG_IsOK(res1)) {
41725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41726 }
41727 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41728 {
41729 PyThreadState* __tstate = wxPyBeginAllowThreads();
41730 (arg1)->Detach();
41731 wxPyEndAllowThreads(__tstate);
41732 if (PyErr_Occurred()) SWIG_fail;
41733 }
41734 resultobj = SWIG_Py_Void();
41735 return resultobj;
41736 fail:
41737 return NULL;
41738 }
41739
41740
41741 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41742 PyObject *resultobj = 0;
41743 bool arg1 ;
41744 bool val1 ;
41745 int ecode1 = 0 ;
41746 PyObject * obj0 = 0 ;
41747 char * kwnames[] = {
41748 (char *) "enable", NULL
41749 };
41750
41751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41752 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41753 if (!SWIG_IsOK(ecode1)) {
41754 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41755 }
41756 arg1 = static_cast< bool >(val1);
41757 {
41758 PyThreadState* __tstate = wxPyBeginAllowThreads();
41759 wxMenuBar_SetAutoWindowMenu(arg1);
41760 wxPyEndAllowThreads(__tstate);
41761 if (PyErr_Occurred()) SWIG_fail;
41762 }
41763 resultobj = SWIG_Py_Void();
41764 return resultobj;
41765 fail:
41766 return NULL;
41767 }
41768
41769
41770 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41771 PyObject *resultobj = 0;
41772 bool result;
41773
41774 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
41775 {
41776 PyThreadState* __tstate = wxPyBeginAllowThreads();
41777 result = (bool)wxMenuBar_GetAutoWindowMenu();
41778 wxPyEndAllowThreads(__tstate);
41779 if (PyErr_Occurred()) SWIG_fail;
41780 }
41781 {
41782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41783 }
41784 return resultobj;
41785 fail:
41786 return NULL;
41787 }
41788
41789
41790 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41791 PyObject *obj;
41792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41793 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
41794 return SWIG_Py_Void();
41795 }
41796
41797 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41798 return SWIG_Python_InitShadowInstance(args);
41799 }
41800
41801 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41802 PyObject *resultobj = 0;
41803 wxMenu *arg1 = (wxMenu *) NULL ;
41804 int arg2 = (int) wxID_ANY ;
41805 wxString const &arg3_defvalue = wxPyEmptyString ;
41806 wxString *arg3 = (wxString *) &arg3_defvalue ;
41807 wxString const &arg4_defvalue = wxPyEmptyString ;
41808 wxString *arg4 = (wxString *) &arg4_defvalue ;
41809 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41810 wxMenu *arg6 = (wxMenu *) NULL ;
41811 wxMenuItem *result = 0 ;
41812 void *argp1 = 0 ;
41813 int res1 = 0 ;
41814 int val2 ;
41815 int ecode2 = 0 ;
41816 bool temp3 = false ;
41817 bool temp4 = false ;
41818 int val5 ;
41819 int ecode5 = 0 ;
41820 void *argp6 = 0 ;
41821 int res6 = 0 ;
41822 PyObject * obj0 = 0 ;
41823 PyObject * obj1 = 0 ;
41824 PyObject * obj2 = 0 ;
41825 PyObject * obj3 = 0 ;
41826 PyObject * obj4 = 0 ;
41827 PyObject * obj5 = 0 ;
41828 char * kwnames[] = {
41829 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
41830 };
41831
41832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
41833 if (obj0) {
41834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41835 if (!SWIG_IsOK(res1)) {
41836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
41837 }
41838 arg1 = reinterpret_cast< wxMenu * >(argp1);
41839 }
41840 if (obj1) {
41841 ecode2 = SWIG_AsVal_int(obj1, &val2);
41842 if (!SWIG_IsOK(ecode2)) {
41843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
41844 }
41845 arg2 = static_cast< int >(val2);
41846 }
41847 if (obj2) {
41848 {
41849 arg3 = wxString_in_helper(obj2);
41850 if (arg3 == NULL) SWIG_fail;
41851 temp3 = true;
41852 }
41853 }
41854 if (obj3) {
41855 {
41856 arg4 = wxString_in_helper(obj3);
41857 if (arg4 == NULL) SWIG_fail;
41858 temp4 = true;
41859 }
41860 }
41861 if (obj4) {
41862 ecode5 = SWIG_AsVal_int(obj4, &val5);
41863 if (!SWIG_IsOK(ecode5)) {
41864 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
41865 }
41866 arg5 = static_cast< wxItemKind >(val5);
41867 }
41868 if (obj5) {
41869 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
41870 if (!SWIG_IsOK(res6)) {
41871 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
41872 }
41873 arg6 = reinterpret_cast< wxMenu * >(argp6);
41874 }
41875 {
41876 PyThreadState* __tstate = wxPyBeginAllowThreads();
41877 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
41878 wxPyEndAllowThreads(__tstate);
41879 if (PyErr_Occurred()) SWIG_fail;
41880 }
41881 {
41882 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
41883 }
41884 {
41885 if (temp3)
41886 delete arg3;
41887 }
41888 {
41889 if (temp4)
41890 delete arg4;
41891 }
41892 return resultobj;
41893 fail:
41894 {
41895 if (temp3)
41896 delete arg3;
41897 }
41898 {
41899 if (temp4)
41900 delete arg4;
41901 }
41902 return NULL;
41903 }
41904
41905
41906 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41907 PyObject *resultobj = 0;
41908 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41909 void *argp1 = 0 ;
41910 int res1 = 0 ;
41911 PyObject *swig_obj[1] ;
41912
41913 if (!args) SWIG_fail;
41914 swig_obj[0] = args;
41915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
41916 if (!SWIG_IsOK(res1)) {
41917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41918 }
41919 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41920 {
41921 PyThreadState* __tstate = wxPyBeginAllowThreads();
41922 delete arg1;
41923
41924 wxPyEndAllowThreads(__tstate);
41925 if (PyErr_Occurred()) SWIG_fail;
41926 }
41927 resultobj = SWIG_Py_Void();
41928 return resultobj;
41929 fail:
41930 return NULL;
41931 }
41932
41933
41934 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41935 PyObject *resultobj = 0;
41936 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41937 wxMenu *result = 0 ;
41938 void *argp1 = 0 ;
41939 int res1 = 0 ;
41940 PyObject *swig_obj[1] ;
41941
41942 if (!args) SWIG_fail;
41943 swig_obj[0] = args;
41944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41945 if (!SWIG_IsOK(res1)) {
41946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
41947 }
41948 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41949 {
41950 PyThreadState* __tstate = wxPyBeginAllowThreads();
41951 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
41952 wxPyEndAllowThreads(__tstate);
41953 if (PyErr_Occurred()) SWIG_fail;
41954 }
41955 {
41956 resultobj = wxPyMake_wxObject(result, 0);
41957 }
41958 return resultobj;
41959 fail:
41960 return NULL;
41961 }
41962
41963
41964 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41965 PyObject *resultobj = 0;
41966 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
41967 wxMenu *arg2 = (wxMenu *) 0 ;
41968 void *argp1 = 0 ;
41969 int res1 = 0 ;
41970 void *argp2 = 0 ;
41971 int res2 = 0 ;
41972 PyObject * obj0 = 0 ;
41973 PyObject * obj1 = 0 ;
41974 char * kwnames[] = {
41975 (char *) "self",(char *) "menu", NULL
41976 };
41977
41978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
41980 if (!SWIG_IsOK(res1)) {
41981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
41982 }
41983 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
41984 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41985 if (!SWIG_IsOK(res2)) {
41986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
41987 }
41988 arg2 = reinterpret_cast< wxMenu * >(argp2);
41989 {
41990 PyThreadState* __tstate = wxPyBeginAllowThreads();
41991 (arg1)->SetMenu(arg2);
41992 wxPyEndAllowThreads(__tstate);
41993 if (PyErr_Occurred()) SWIG_fail;
41994 }
41995 resultobj = SWIG_Py_Void();
41996 return resultobj;
41997 fail:
41998 return NULL;
41999 }
42000
42001
42002 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42003 PyObject *resultobj = 0;
42004 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42005 int arg2 ;
42006 void *argp1 = 0 ;
42007 int res1 = 0 ;
42008 int val2 ;
42009 int ecode2 = 0 ;
42010 PyObject * obj0 = 0 ;
42011 PyObject * obj1 = 0 ;
42012 char * kwnames[] = {
42013 (char *) "self",(char *) "id", NULL
42014 };
42015
42016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42018 if (!SWIG_IsOK(res1)) {
42019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42020 }
42021 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42022 ecode2 = SWIG_AsVal_int(obj1, &val2);
42023 if (!SWIG_IsOK(ecode2)) {
42024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42025 }
42026 arg2 = static_cast< int >(val2);
42027 {
42028 PyThreadState* __tstate = wxPyBeginAllowThreads();
42029 (arg1)->SetId(arg2);
42030 wxPyEndAllowThreads(__tstate);
42031 if (PyErr_Occurred()) SWIG_fail;
42032 }
42033 resultobj = SWIG_Py_Void();
42034 return resultobj;
42035 fail:
42036 return NULL;
42037 }
42038
42039
42040 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42041 PyObject *resultobj = 0;
42042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42043 int result;
42044 void *argp1 = 0 ;
42045 int res1 = 0 ;
42046 PyObject *swig_obj[1] ;
42047
42048 if (!args) SWIG_fail;
42049 swig_obj[0] = args;
42050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42051 if (!SWIG_IsOK(res1)) {
42052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42053 }
42054 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42055 {
42056 PyThreadState* __tstate = wxPyBeginAllowThreads();
42057 result = (int)((wxMenuItem const *)arg1)->GetId();
42058 wxPyEndAllowThreads(__tstate);
42059 if (PyErr_Occurred()) SWIG_fail;
42060 }
42061 resultobj = SWIG_From_int(static_cast< int >(result));
42062 return resultobj;
42063 fail:
42064 return NULL;
42065 }
42066
42067
42068 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42069 PyObject *resultobj = 0;
42070 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42071 bool result;
42072 void *argp1 = 0 ;
42073 int res1 = 0 ;
42074 PyObject *swig_obj[1] ;
42075
42076 if (!args) SWIG_fail;
42077 swig_obj[0] = args;
42078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42079 if (!SWIG_IsOK(res1)) {
42080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42081 }
42082 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42083 {
42084 PyThreadState* __tstate = wxPyBeginAllowThreads();
42085 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42086 wxPyEndAllowThreads(__tstate);
42087 if (PyErr_Occurred()) SWIG_fail;
42088 }
42089 {
42090 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42091 }
42092 return resultobj;
42093 fail:
42094 return NULL;
42095 }
42096
42097
42098 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42099 PyObject *resultobj = 0;
42100 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42101 wxString *arg2 = 0 ;
42102 void *argp1 = 0 ;
42103 int res1 = 0 ;
42104 bool temp2 = false ;
42105 PyObject * obj0 = 0 ;
42106 PyObject * obj1 = 0 ;
42107 char * kwnames[] = {
42108 (char *) "self",(char *) "str", NULL
42109 };
42110
42111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42113 if (!SWIG_IsOK(res1)) {
42114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42115 }
42116 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42117 {
42118 arg2 = wxString_in_helper(obj1);
42119 if (arg2 == NULL) SWIG_fail;
42120 temp2 = true;
42121 }
42122 {
42123 PyThreadState* __tstate = wxPyBeginAllowThreads();
42124 (arg1)->SetText((wxString const &)*arg2);
42125 wxPyEndAllowThreads(__tstate);
42126 if (PyErr_Occurred()) SWIG_fail;
42127 }
42128 resultobj = SWIG_Py_Void();
42129 {
42130 if (temp2)
42131 delete arg2;
42132 }
42133 return resultobj;
42134 fail:
42135 {
42136 if (temp2)
42137 delete arg2;
42138 }
42139 return NULL;
42140 }
42141
42142
42143 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42144 PyObject *resultobj = 0;
42145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42146 wxString result;
42147 void *argp1 = 0 ;
42148 int res1 = 0 ;
42149 PyObject *swig_obj[1] ;
42150
42151 if (!args) SWIG_fail;
42152 swig_obj[0] = args;
42153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42154 if (!SWIG_IsOK(res1)) {
42155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42156 }
42157 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42158 {
42159 PyThreadState* __tstate = wxPyBeginAllowThreads();
42160 result = ((wxMenuItem const *)arg1)->GetLabel();
42161 wxPyEndAllowThreads(__tstate);
42162 if (PyErr_Occurred()) SWIG_fail;
42163 }
42164 {
42165 #if wxUSE_UNICODE
42166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42167 #else
42168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42169 #endif
42170 }
42171 return resultobj;
42172 fail:
42173 return NULL;
42174 }
42175
42176
42177 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42178 PyObject *resultobj = 0;
42179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42180 wxString *result = 0 ;
42181 void *argp1 = 0 ;
42182 int res1 = 0 ;
42183 PyObject *swig_obj[1] ;
42184
42185 if (!args) SWIG_fail;
42186 swig_obj[0] = args;
42187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42188 if (!SWIG_IsOK(res1)) {
42189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42190 }
42191 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42192 {
42193 PyThreadState* __tstate = wxPyBeginAllowThreads();
42194 {
42195 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42196 result = (wxString *) &_result_ref;
42197 }
42198 wxPyEndAllowThreads(__tstate);
42199 if (PyErr_Occurred()) SWIG_fail;
42200 }
42201 {
42202 #if wxUSE_UNICODE
42203 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42204 #else
42205 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42206 #endif
42207 }
42208 return resultobj;
42209 fail:
42210 return NULL;
42211 }
42212
42213
42214 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42215 PyObject *resultobj = 0;
42216 wxString *arg1 = 0 ;
42217 wxString result;
42218 bool temp1 = false ;
42219 PyObject * obj0 = 0 ;
42220 char * kwnames[] = {
42221 (char *) "text", NULL
42222 };
42223
42224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42225 {
42226 arg1 = wxString_in_helper(obj0);
42227 if (arg1 == NULL) SWIG_fail;
42228 temp1 = true;
42229 }
42230 {
42231 PyThreadState* __tstate = wxPyBeginAllowThreads();
42232 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42233 wxPyEndAllowThreads(__tstate);
42234 if (PyErr_Occurred()) SWIG_fail;
42235 }
42236 {
42237 #if wxUSE_UNICODE
42238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42239 #else
42240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42241 #endif
42242 }
42243 {
42244 if (temp1)
42245 delete arg1;
42246 }
42247 return resultobj;
42248 fail:
42249 {
42250 if (temp1)
42251 delete arg1;
42252 }
42253 return NULL;
42254 }
42255
42256
42257 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42258 PyObject *resultobj = 0;
42259 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42260 wxItemKind result;
42261 void *argp1 = 0 ;
42262 int res1 = 0 ;
42263 PyObject *swig_obj[1] ;
42264
42265 if (!args) SWIG_fail;
42266 swig_obj[0] = args;
42267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42268 if (!SWIG_IsOK(res1)) {
42269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42270 }
42271 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42272 {
42273 PyThreadState* __tstate = wxPyBeginAllowThreads();
42274 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42275 wxPyEndAllowThreads(__tstate);
42276 if (PyErr_Occurred()) SWIG_fail;
42277 }
42278 resultobj = SWIG_From_int(static_cast< int >(result));
42279 return resultobj;
42280 fail:
42281 return NULL;
42282 }
42283
42284
42285 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42286 PyObject *resultobj = 0;
42287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42288 wxItemKind arg2 ;
42289 void *argp1 = 0 ;
42290 int res1 = 0 ;
42291 int val2 ;
42292 int ecode2 = 0 ;
42293 PyObject * obj0 = 0 ;
42294 PyObject * obj1 = 0 ;
42295 char * kwnames[] = {
42296 (char *) "self",(char *) "kind", NULL
42297 };
42298
42299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42301 if (!SWIG_IsOK(res1)) {
42302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42303 }
42304 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42305 ecode2 = SWIG_AsVal_int(obj1, &val2);
42306 if (!SWIG_IsOK(ecode2)) {
42307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42308 }
42309 arg2 = static_cast< wxItemKind >(val2);
42310 {
42311 PyThreadState* __tstate = wxPyBeginAllowThreads();
42312 (arg1)->SetKind(arg2);
42313 wxPyEndAllowThreads(__tstate);
42314 if (PyErr_Occurred()) SWIG_fail;
42315 }
42316 resultobj = SWIG_Py_Void();
42317 return resultobj;
42318 fail:
42319 return NULL;
42320 }
42321
42322
42323 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42324 PyObject *resultobj = 0;
42325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42326 bool arg2 ;
42327 void *argp1 = 0 ;
42328 int res1 = 0 ;
42329 bool val2 ;
42330 int ecode2 = 0 ;
42331 PyObject * obj0 = 0 ;
42332 PyObject * obj1 = 0 ;
42333 char * kwnames[] = {
42334 (char *) "self",(char *) "checkable", NULL
42335 };
42336
42337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42339 if (!SWIG_IsOK(res1)) {
42340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42341 }
42342 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42343 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42344 if (!SWIG_IsOK(ecode2)) {
42345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42346 }
42347 arg2 = static_cast< bool >(val2);
42348 {
42349 PyThreadState* __tstate = wxPyBeginAllowThreads();
42350 (arg1)->SetCheckable(arg2);
42351 wxPyEndAllowThreads(__tstate);
42352 if (PyErr_Occurred()) SWIG_fail;
42353 }
42354 resultobj = SWIG_Py_Void();
42355 return resultobj;
42356 fail:
42357 return NULL;
42358 }
42359
42360
42361 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42362 PyObject *resultobj = 0;
42363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42364 bool result;
42365 void *argp1 = 0 ;
42366 int res1 = 0 ;
42367 PyObject *swig_obj[1] ;
42368
42369 if (!args) SWIG_fail;
42370 swig_obj[0] = args;
42371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42372 if (!SWIG_IsOK(res1)) {
42373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42374 }
42375 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42376 {
42377 PyThreadState* __tstate = wxPyBeginAllowThreads();
42378 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 {
42383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42384 }
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42392 PyObject *resultobj = 0;
42393 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42394 bool result;
42395 void *argp1 = 0 ;
42396 int res1 = 0 ;
42397 PyObject *swig_obj[1] ;
42398
42399 if (!args) SWIG_fail;
42400 swig_obj[0] = args;
42401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42402 if (!SWIG_IsOK(res1)) {
42403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42404 }
42405 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42406 {
42407 PyThreadState* __tstate = wxPyBeginAllowThreads();
42408 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42409 wxPyEndAllowThreads(__tstate);
42410 if (PyErr_Occurred()) SWIG_fail;
42411 }
42412 {
42413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42414 }
42415 return resultobj;
42416 fail:
42417 return NULL;
42418 }
42419
42420
42421 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42422 PyObject *resultobj = 0;
42423 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42424 wxMenu *arg2 = (wxMenu *) 0 ;
42425 void *argp1 = 0 ;
42426 int res1 = 0 ;
42427 void *argp2 = 0 ;
42428 int res2 = 0 ;
42429 PyObject * obj0 = 0 ;
42430 PyObject * obj1 = 0 ;
42431 char * kwnames[] = {
42432 (char *) "self",(char *) "menu", NULL
42433 };
42434
42435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42437 if (!SWIG_IsOK(res1)) {
42438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42439 }
42440 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42442 if (!SWIG_IsOK(res2)) {
42443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42444 }
42445 arg2 = reinterpret_cast< wxMenu * >(argp2);
42446 {
42447 PyThreadState* __tstate = wxPyBeginAllowThreads();
42448 (arg1)->SetSubMenu(arg2);
42449 wxPyEndAllowThreads(__tstate);
42450 if (PyErr_Occurred()) SWIG_fail;
42451 }
42452 resultobj = SWIG_Py_Void();
42453 return resultobj;
42454 fail:
42455 return NULL;
42456 }
42457
42458
42459 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42460 PyObject *resultobj = 0;
42461 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42462 wxMenu *result = 0 ;
42463 void *argp1 = 0 ;
42464 int res1 = 0 ;
42465 PyObject *swig_obj[1] ;
42466
42467 if (!args) SWIG_fail;
42468 swig_obj[0] = args;
42469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42470 if (!SWIG_IsOK(res1)) {
42471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42472 }
42473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42474 {
42475 PyThreadState* __tstate = wxPyBeginAllowThreads();
42476 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42477 wxPyEndAllowThreads(__tstate);
42478 if (PyErr_Occurred()) SWIG_fail;
42479 }
42480 {
42481 resultobj = wxPyMake_wxObject(result, 0);
42482 }
42483 return resultobj;
42484 fail:
42485 return NULL;
42486 }
42487
42488
42489 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42490 PyObject *resultobj = 0;
42491 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42492 bool arg2 = (bool) true ;
42493 void *argp1 = 0 ;
42494 int res1 = 0 ;
42495 bool val2 ;
42496 int ecode2 = 0 ;
42497 PyObject * obj0 = 0 ;
42498 PyObject * obj1 = 0 ;
42499 char * kwnames[] = {
42500 (char *) "self",(char *) "enable", NULL
42501 };
42502
42503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42505 if (!SWIG_IsOK(res1)) {
42506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42507 }
42508 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42509 if (obj1) {
42510 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42511 if (!SWIG_IsOK(ecode2)) {
42512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42513 }
42514 arg2 = static_cast< bool >(val2);
42515 }
42516 {
42517 PyThreadState* __tstate = wxPyBeginAllowThreads();
42518 (arg1)->Enable(arg2);
42519 wxPyEndAllowThreads(__tstate);
42520 if (PyErr_Occurred()) SWIG_fail;
42521 }
42522 resultobj = SWIG_Py_Void();
42523 return resultobj;
42524 fail:
42525 return NULL;
42526 }
42527
42528
42529 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42530 PyObject *resultobj = 0;
42531 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42532 bool result;
42533 void *argp1 = 0 ;
42534 int res1 = 0 ;
42535 PyObject *swig_obj[1] ;
42536
42537 if (!args) SWIG_fail;
42538 swig_obj[0] = args;
42539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42540 if (!SWIG_IsOK(res1)) {
42541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42542 }
42543 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42544 {
42545 PyThreadState* __tstate = wxPyBeginAllowThreads();
42546 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42547 wxPyEndAllowThreads(__tstate);
42548 if (PyErr_Occurred()) SWIG_fail;
42549 }
42550 {
42551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42552 }
42553 return resultobj;
42554 fail:
42555 return NULL;
42556 }
42557
42558
42559 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42560 PyObject *resultobj = 0;
42561 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42562 bool arg2 = (bool) true ;
42563 void *argp1 = 0 ;
42564 int res1 = 0 ;
42565 bool val2 ;
42566 int ecode2 = 0 ;
42567 PyObject * obj0 = 0 ;
42568 PyObject * obj1 = 0 ;
42569 char * kwnames[] = {
42570 (char *) "self",(char *) "check", NULL
42571 };
42572
42573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42574 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42575 if (!SWIG_IsOK(res1)) {
42576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42577 }
42578 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42579 if (obj1) {
42580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42581 if (!SWIG_IsOK(ecode2)) {
42582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42583 }
42584 arg2 = static_cast< bool >(val2);
42585 }
42586 {
42587 PyThreadState* __tstate = wxPyBeginAllowThreads();
42588 (arg1)->Check(arg2);
42589 wxPyEndAllowThreads(__tstate);
42590 if (PyErr_Occurred()) SWIG_fail;
42591 }
42592 resultobj = SWIG_Py_Void();
42593 return resultobj;
42594 fail:
42595 return NULL;
42596 }
42597
42598
42599 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42600 PyObject *resultobj = 0;
42601 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42602 bool result;
42603 void *argp1 = 0 ;
42604 int res1 = 0 ;
42605 PyObject *swig_obj[1] ;
42606
42607 if (!args) SWIG_fail;
42608 swig_obj[0] = args;
42609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42610 if (!SWIG_IsOK(res1)) {
42611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42612 }
42613 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42614 {
42615 PyThreadState* __tstate = wxPyBeginAllowThreads();
42616 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42617 wxPyEndAllowThreads(__tstate);
42618 if (PyErr_Occurred()) SWIG_fail;
42619 }
42620 {
42621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42622 }
42623 return resultobj;
42624 fail:
42625 return NULL;
42626 }
42627
42628
42629 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42630 PyObject *resultobj = 0;
42631 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 PyObject *swig_obj[1] ;
42635
42636 if (!args) SWIG_fail;
42637 swig_obj[0] = args;
42638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42639 if (!SWIG_IsOK(res1)) {
42640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 (arg1)->Toggle();
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 resultobj = SWIG_Py_Void();
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42657 PyObject *resultobj = 0;
42658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42659 wxString *arg2 = 0 ;
42660 void *argp1 = 0 ;
42661 int res1 = 0 ;
42662 bool temp2 = false ;
42663 PyObject * obj0 = 0 ;
42664 PyObject * obj1 = 0 ;
42665 char * kwnames[] = {
42666 (char *) "self",(char *) "str", NULL
42667 };
42668
42669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42671 if (!SWIG_IsOK(res1)) {
42672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42673 }
42674 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42675 {
42676 arg2 = wxString_in_helper(obj1);
42677 if (arg2 == NULL) SWIG_fail;
42678 temp2 = true;
42679 }
42680 {
42681 PyThreadState* __tstate = wxPyBeginAllowThreads();
42682 (arg1)->SetHelp((wxString const &)*arg2);
42683 wxPyEndAllowThreads(__tstate);
42684 if (PyErr_Occurred()) SWIG_fail;
42685 }
42686 resultobj = SWIG_Py_Void();
42687 {
42688 if (temp2)
42689 delete arg2;
42690 }
42691 return resultobj;
42692 fail:
42693 {
42694 if (temp2)
42695 delete arg2;
42696 }
42697 return NULL;
42698 }
42699
42700
42701 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42702 PyObject *resultobj = 0;
42703 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42704 wxString *result = 0 ;
42705 void *argp1 = 0 ;
42706 int res1 = 0 ;
42707 PyObject *swig_obj[1] ;
42708
42709 if (!args) SWIG_fail;
42710 swig_obj[0] = args;
42711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42712 if (!SWIG_IsOK(res1)) {
42713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42714 }
42715 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42716 {
42717 PyThreadState* __tstate = wxPyBeginAllowThreads();
42718 {
42719 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42720 result = (wxString *) &_result_ref;
42721 }
42722 wxPyEndAllowThreads(__tstate);
42723 if (PyErr_Occurred()) SWIG_fail;
42724 }
42725 {
42726 #if wxUSE_UNICODE
42727 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42728 #else
42729 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42730 #endif
42731 }
42732 return resultobj;
42733 fail:
42734 return NULL;
42735 }
42736
42737
42738 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42739 PyObject *resultobj = 0;
42740 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42741 wxAcceleratorEntry *result = 0 ;
42742 void *argp1 = 0 ;
42743 int res1 = 0 ;
42744 PyObject *swig_obj[1] ;
42745
42746 if (!args) SWIG_fail;
42747 swig_obj[0] = args;
42748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42749 if (!SWIG_IsOK(res1)) {
42750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42751 }
42752 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42753 {
42754 PyThreadState* __tstate = wxPyBeginAllowThreads();
42755 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42756 wxPyEndAllowThreads(__tstate);
42757 if (PyErr_Occurred()) SWIG_fail;
42758 }
42759 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42760 return resultobj;
42761 fail:
42762 return NULL;
42763 }
42764
42765
42766 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42767 PyObject *resultobj = 0;
42768 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42769 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
42770 void *argp1 = 0 ;
42771 int res1 = 0 ;
42772 void *argp2 = 0 ;
42773 int res2 = 0 ;
42774 PyObject * obj0 = 0 ;
42775 PyObject * obj1 = 0 ;
42776 char * kwnames[] = {
42777 (char *) "self",(char *) "accel", NULL
42778 };
42779
42780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
42781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42782 if (!SWIG_IsOK(res1)) {
42783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42784 }
42785 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42787 if (!SWIG_IsOK(res2)) {
42788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
42789 }
42790 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
42791 {
42792 PyThreadState* __tstate = wxPyBeginAllowThreads();
42793 (arg1)->SetAccel(arg2);
42794 wxPyEndAllowThreads(__tstate);
42795 if (PyErr_Occurred()) SWIG_fail;
42796 }
42797 resultobj = SWIG_Py_Void();
42798 return resultobj;
42799 fail:
42800 return NULL;
42801 }
42802
42803
42804 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42805 PyObject *resultobj = 0;
42806 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42807 wxBitmap *arg2 = 0 ;
42808 void *argp1 = 0 ;
42809 int res1 = 0 ;
42810 void *argp2 = 0 ;
42811 int res2 = 0 ;
42812 PyObject * obj0 = 0 ;
42813 PyObject * obj1 = 0 ;
42814 char * kwnames[] = {
42815 (char *) "self",(char *) "bitmap", NULL
42816 };
42817
42818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
42819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42820 if (!SWIG_IsOK(res1)) {
42821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42822 }
42823 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
42825 if (!SWIG_IsOK(res2)) {
42826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42827 }
42828 if (!argp2) {
42829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
42830 }
42831 arg2 = reinterpret_cast< wxBitmap * >(argp2);
42832 {
42833 PyThreadState* __tstate = wxPyBeginAllowThreads();
42834 (arg1)->SetBitmap((wxBitmap const &)*arg2);
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 resultobj = SWIG_Py_Void();
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42846 PyObject *resultobj = 0;
42847 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42848 wxBitmap *result = 0 ;
42849 void *argp1 = 0 ;
42850 int res1 = 0 ;
42851 PyObject *swig_obj[1] ;
42852
42853 if (!args) SWIG_fail;
42854 swig_obj[0] = args;
42855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42856 if (!SWIG_IsOK(res1)) {
42857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42858 }
42859 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 {
42863 wxBitmap const &_result_ref = (arg1)->GetBitmap();
42864 result = (wxBitmap *) &_result_ref;
42865 }
42866 wxPyEndAllowThreads(__tstate);
42867 if (PyErr_Occurred()) SWIG_fail;
42868 }
42869 {
42870 wxBitmap* resultptr = new wxBitmap(*result);
42871 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
42872 }
42873 return resultobj;
42874 fail:
42875 return NULL;
42876 }
42877
42878
42879 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42880 PyObject *resultobj = 0;
42881 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42882 wxFont *arg2 = 0 ;
42883 void *argp1 = 0 ;
42884 int res1 = 0 ;
42885 void *argp2 = 0 ;
42886 int res2 = 0 ;
42887 PyObject * obj0 = 0 ;
42888 PyObject * obj1 = 0 ;
42889 char * kwnames[] = {
42890 (char *) "self",(char *) "font", NULL
42891 };
42892
42893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
42894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42895 if (!SWIG_IsOK(res1)) {
42896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42897 }
42898 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42899 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
42900 if (!SWIG_IsOK(res2)) {
42901 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42902 }
42903 if (!argp2) {
42904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
42905 }
42906 arg2 = reinterpret_cast< wxFont * >(argp2);
42907 {
42908 PyThreadState* __tstate = wxPyBeginAllowThreads();
42909 (arg1)->SetFont((wxFont const &)*arg2);
42910 wxPyEndAllowThreads(__tstate);
42911 if (PyErr_Occurred()) SWIG_fail;
42912 }
42913 resultobj = SWIG_Py_Void();
42914 return resultobj;
42915 fail:
42916 return NULL;
42917 }
42918
42919
42920 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42921 PyObject *resultobj = 0;
42922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42923 wxFont result;
42924 void *argp1 = 0 ;
42925 int res1 = 0 ;
42926 PyObject *swig_obj[1] ;
42927
42928 if (!args) SWIG_fail;
42929 swig_obj[0] = args;
42930 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42931 if (!SWIG_IsOK(res1)) {
42932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42933 }
42934 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42935 {
42936 PyThreadState* __tstate = wxPyBeginAllowThreads();
42937 result = (arg1)->GetFont();
42938 wxPyEndAllowThreads(__tstate);
42939 if (PyErr_Occurred()) SWIG_fail;
42940 }
42941 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
42942 return resultobj;
42943 fail:
42944 return NULL;
42945 }
42946
42947
42948 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42949 PyObject *resultobj = 0;
42950 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42951 wxColour *arg2 = 0 ;
42952 void *argp1 = 0 ;
42953 int res1 = 0 ;
42954 wxColour temp2 ;
42955 PyObject * obj0 = 0 ;
42956 PyObject * obj1 = 0 ;
42957 char * kwnames[] = {
42958 (char *) "self",(char *) "colText", NULL
42959 };
42960
42961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
42962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42963 if (!SWIG_IsOK(res1)) {
42964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42965 }
42966 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42967 {
42968 arg2 = &temp2;
42969 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
42970 }
42971 {
42972 PyThreadState* __tstate = wxPyBeginAllowThreads();
42973 (arg1)->SetTextColour((wxColour const &)*arg2);
42974 wxPyEndAllowThreads(__tstate);
42975 if (PyErr_Occurred()) SWIG_fail;
42976 }
42977 resultobj = SWIG_Py_Void();
42978 return resultobj;
42979 fail:
42980 return NULL;
42981 }
42982
42983
42984 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42985 PyObject *resultobj = 0;
42986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42987 wxColour result;
42988 void *argp1 = 0 ;
42989 int res1 = 0 ;
42990 PyObject *swig_obj[1] ;
42991
42992 if (!args) SWIG_fail;
42993 swig_obj[0] = args;
42994 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42995 if (!SWIG_IsOK(res1)) {
42996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42997 }
42998 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42999 {
43000 PyThreadState* __tstate = wxPyBeginAllowThreads();
43001 result = (arg1)->GetTextColour();
43002 wxPyEndAllowThreads(__tstate);
43003 if (PyErr_Occurred()) SWIG_fail;
43004 }
43005 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43006 return resultobj;
43007 fail:
43008 return NULL;
43009 }
43010
43011
43012 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43013 PyObject *resultobj = 0;
43014 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43015 wxColour *arg2 = 0 ;
43016 void *argp1 = 0 ;
43017 int res1 = 0 ;
43018 wxColour temp2 ;
43019 PyObject * obj0 = 0 ;
43020 PyObject * obj1 = 0 ;
43021 char * kwnames[] = {
43022 (char *) "self",(char *) "colBack", NULL
43023 };
43024
43025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43027 if (!SWIG_IsOK(res1)) {
43028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43029 }
43030 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43031 {
43032 arg2 = &temp2;
43033 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43034 }
43035 {
43036 PyThreadState* __tstate = wxPyBeginAllowThreads();
43037 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
43038 wxPyEndAllowThreads(__tstate);
43039 if (PyErr_Occurred()) SWIG_fail;
43040 }
43041 resultobj = SWIG_Py_Void();
43042 return resultobj;
43043 fail:
43044 return NULL;
43045 }
43046
43047
43048 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43049 PyObject *resultobj = 0;
43050 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43051 wxColour result;
43052 void *argp1 = 0 ;
43053 int res1 = 0 ;
43054 PyObject *swig_obj[1] ;
43055
43056 if (!args) SWIG_fail;
43057 swig_obj[0] = args;
43058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43059 if (!SWIG_IsOK(res1)) {
43060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43061 }
43062 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43063 {
43064 PyThreadState* __tstate = wxPyBeginAllowThreads();
43065 result = (arg1)->GetBackgroundColour();
43066 wxPyEndAllowThreads(__tstate);
43067 if (PyErr_Occurred()) SWIG_fail;
43068 }
43069 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43070 return resultobj;
43071 fail:
43072 return NULL;
43073 }
43074
43075
43076 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43077 PyObject *resultobj = 0;
43078 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43079 wxBitmap *arg2 = 0 ;
43080 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43081 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43082 void *argp1 = 0 ;
43083 int res1 = 0 ;
43084 void *argp2 = 0 ;
43085 int res2 = 0 ;
43086 void *argp3 = 0 ;
43087 int res3 = 0 ;
43088 PyObject * obj0 = 0 ;
43089 PyObject * obj1 = 0 ;
43090 PyObject * obj2 = 0 ;
43091 char * kwnames[] = {
43092 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43093 };
43094
43095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43097 if (!SWIG_IsOK(res1)) {
43098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43099 }
43100 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43101 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43102 if (!SWIG_IsOK(res2)) {
43103 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43104 }
43105 if (!argp2) {
43106 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43107 }
43108 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43109 if (obj2) {
43110 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43111 if (!SWIG_IsOK(res3)) {
43112 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43113 }
43114 if (!argp3) {
43115 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43116 }
43117 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43118 }
43119 {
43120 PyThreadState* __tstate = wxPyBeginAllowThreads();
43121 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43122 wxPyEndAllowThreads(__tstate);
43123 if (PyErr_Occurred()) SWIG_fail;
43124 }
43125 resultobj = SWIG_Py_Void();
43126 return resultobj;
43127 fail:
43128 return NULL;
43129 }
43130
43131
43132 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43133 PyObject *resultobj = 0;
43134 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43135 wxBitmap *arg2 = 0 ;
43136 void *argp1 = 0 ;
43137 int res1 = 0 ;
43138 void *argp2 = 0 ;
43139 int res2 = 0 ;
43140 PyObject * obj0 = 0 ;
43141 PyObject * obj1 = 0 ;
43142 char * kwnames[] = {
43143 (char *) "self",(char *) "bmpDisabled", NULL
43144 };
43145
43146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43148 if (!SWIG_IsOK(res1)) {
43149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43150 }
43151 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43152 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43153 if (!SWIG_IsOK(res2)) {
43154 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43155 }
43156 if (!argp2) {
43157 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43158 }
43159 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43160 {
43161 PyThreadState* __tstate = wxPyBeginAllowThreads();
43162 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
43163 wxPyEndAllowThreads(__tstate);
43164 if (PyErr_Occurred()) SWIG_fail;
43165 }
43166 resultobj = SWIG_Py_Void();
43167 return resultobj;
43168 fail:
43169 return NULL;
43170 }
43171
43172
43173 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43174 PyObject *resultobj = 0;
43175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43176 wxBitmap *result = 0 ;
43177 void *argp1 = 0 ;
43178 int res1 = 0 ;
43179 PyObject *swig_obj[1] ;
43180
43181 if (!args) SWIG_fail;
43182 swig_obj[0] = args;
43183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43184 if (!SWIG_IsOK(res1)) {
43185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43186 }
43187 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43188 {
43189 PyThreadState* __tstate = wxPyBeginAllowThreads();
43190 {
43191 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
43192 result = (wxBitmap *) &_result_ref;
43193 }
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 {
43198 wxBitmap* resultptr = new wxBitmap(*result);
43199 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43200 }
43201 return resultobj;
43202 fail:
43203 return NULL;
43204 }
43205
43206
43207 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43208 PyObject *resultobj = 0;
43209 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43210 int arg2 ;
43211 void *argp1 = 0 ;
43212 int res1 = 0 ;
43213 int val2 ;
43214 int ecode2 = 0 ;
43215 PyObject * obj0 = 0 ;
43216 PyObject * obj1 = 0 ;
43217 char * kwnames[] = {
43218 (char *) "self",(char *) "nWidth", NULL
43219 };
43220
43221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43223 if (!SWIG_IsOK(res1)) {
43224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43225 }
43226 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43227 ecode2 = SWIG_AsVal_int(obj1, &val2);
43228 if (!SWIG_IsOK(ecode2)) {
43229 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43230 }
43231 arg2 = static_cast< int >(val2);
43232 {
43233 PyThreadState* __tstate = wxPyBeginAllowThreads();
43234 (arg1)->SetMarginWidth(arg2);
43235 wxPyEndAllowThreads(__tstate);
43236 if (PyErr_Occurred()) SWIG_fail;
43237 }
43238 resultobj = SWIG_Py_Void();
43239 return resultobj;
43240 fail:
43241 return NULL;
43242 }
43243
43244
43245 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43246 PyObject *resultobj = 0;
43247 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43248 int result;
43249 void *argp1 = 0 ;
43250 int res1 = 0 ;
43251 PyObject *swig_obj[1] ;
43252
43253 if (!args) SWIG_fail;
43254 swig_obj[0] = args;
43255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43256 if (!SWIG_IsOK(res1)) {
43257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43258 }
43259 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 result = (int)(arg1)->GetMarginWidth();
43263 wxPyEndAllowThreads(__tstate);
43264 if (PyErr_Occurred()) SWIG_fail;
43265 }
43266 resultobj = SWIG_From_int(static_cast< int >(result));
43267 return resultobj;
43268 fail:
43269 return NULL;
43270 }
43271
43272
43273 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43274 PyObject *resultobj = 0;
43275 int result;
43276
43277 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43278 {
43279 PyThreadState* __tstate = wxPyBeginAllowThreads();
43280 result = (int)wxMenuItem::GetDefaultMarginWidth();
43281 wxPyEndAllowThreads(__tstate);
43282 if (PyErr_Occurred()) SWIG_fail;
43283 }
43284 resultobj = SWIG_From_int(static_cast< int >(result));
43285 return resultobj;
43286 fail:
43287 return NULL;
43288 }
43289
43290
43291 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43292 PyObject *resultobj = 0;
43293 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43294 bool result;
43295 void *argp1 = 0 ;
43296 int res1 = 0 ;
43297 PyObject *swig_obj[1] ;
43298
43299 if (!args) SWIG_fail;
43300 swig_obj[0] = args;
43301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43302 if (!SWIG_IsOK(res1)) {
43303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43304 }
43305 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43306 {
43307 PyThreadState* __tstate = wxPyBeginAllowThreads();
43308 result = (bool)(arg1)->IsOwnerDrawn();
43309 wxPyEndAllowThreads(__tstate);
43310 if (PyErr_Occurred()) SWIG_fail;
43311 }
43312 {
43313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43314 }
43315 return resultobj;
43316 fail:
43317 return NULL;
43318 }
43319
43320
43321 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43322 PyObject *resultobj = 0;
43323 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43324 bool arg2 = (bool) true ;
43325 void *argp1 = 0 ;
43326 int res1 = 0 ;
43327 bool val2 ;
43328 int ecode2 = 0 ;
43329 PyObject * obj0 = 0 ;
43330 PyObject * obj1 = 0 ;
43331 char * kwnames[] = {
43332 (char *) "self",(char *) "ownerDrawn", NULL
43333 };
43334
43335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43337 if (!SWIG_IsOK(res1)) {
43338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43339 }
43340 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43341 if (obj1) {
43342 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43343 if (!SWIG_IsOK(ecode2)) {
43344 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43345 }
43346 arg2 = static_cast< bool >(val2);
43347 }
43348 {
43349 PyThreadState* __tstate = wxPyBeginAllowThreads();
43350 (arg1)->SetOwnerDrawn(arg2);
43351 wxPyEndAllowThreads(__tstate);
43352 if (PyErr_Occurred()) SWIG_fail;
43353 }
43354 resultobj = SWIG_Py_Void();
43355 return resultobj;
43356 fail:
43357 return NULL;
43358 }
43359
43360
43361 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43362 PyObject *resultobj = 0;
43363 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43364 void *argp1 = 0 ;
43365 int res1 = 0 ;
43366 PyObject *swig_obj[1] ;
43367
43368 if (!args) SWIG_fail;
43369 swig_obj[0] = args;
43370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43371 if (!SWIG_IsOK(res1)) {
43372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43373 }
43374 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43375 {
43376 PyThreadState* __tstate = wxPyBeginAllowThreads();
43377 (arg1)->ResetOwnerDrawn();
43378 wxPyEndAllowThreads(__tstate);
43379 if (PyErr_Occurred()) SWIG_fail;
43380 }
43381 resultobj = SWIG_Py_Void();
43382 return resultobj;
43383 fail:
43384 return NULL;
43385 }
43386
43387
43388 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43389 PyObject *obj;
43390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43391 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43392 return SWIG_Py_Void();
43393 }
43394
43395 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43396 return SWIG_Python_InitShadowInstance(args);
43397 }
43398
43399 SWIGINTERN int ControlNameStr_set(PyObject *) {
43400 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43401 return 1;
43402 }
43403
43404
43405 SWIGINTERN PyObject *ControlNameStr_get(void) {
43406 PyObject *pyobj = 0;
43407
43408 {
43409 #if wxUSE_UNICODE
43410 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43411 #else
43412 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43413 #endif
43414 }
43415 return pyobj;
43416 }
43417
43418
43419 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43420 PyObject *resultobj = 0;
43421 wxWindow *arg1 = (wxWindow *) 0 ;
43422 int arg2 = (int) -1 ;
43423 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43424 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43425 wxSize const &arg4_defvalue = wxDefaultSize ;
43426 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43427 long arg5 = (long) 0 ;
43428 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43429 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43430 wxString const &arg7_defvalue = wxPyControlNameStr ;
43431 wxString *arg7 = (wxString *) &arg7_defvalue ;
43432 wxControl *result = 0 ;
43433 void *argp1 = 0 ;
43434 int res1 = 0 ;
43435 int val2 ;
43436 int ecode2 = 0 ;
43437 wxPoint temp3 ;
43438 wxSize temp4 ;
43439 long val5 ;
43440 int ecode5 = 0 ;
43441 void *argp6 = 0 ;
43442 int res6 = 0 ;
43443 bool temp7 = false ;
43444 PyObject * obj0 = 0 ;
43445 PyObject * obj1 = 0 ;
43446 PyObject * obj2 = 0 ;
43447 PyObject * obj3 = 0 ;
43448 PyObject * obj4 = 0 ;
43449 PyObject * obj5 = 0 ;
43450 PyObject * obj6 = 0 ;
43451 char * kwnames[] = {
43452 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43453 };
43454
43455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43457 if (!SWIG_IsOK(res1)) {
43458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43459 }
43460 arg1 = reinterpret_cast< wxWindow * >(argp1);
43461 if (obj1) {
43462 ecode2 = SWIG_AsVal_int(obj1, &val2);
43463 if (!SWIG_IsOK(ecode2)) {
43464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43465 }
43466 arg2 = static_cast< int >(val2);
43467 }
43468 if (obj2) {
43469 {
43470 arg3 = &temp3;
43471 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43472 }
43473 }
43474 if (obj3) {
43475 {
43476 arg4 = &temp4;
43477 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43478 }
43479 }
43480 if (obj4) {
43481 ecode5 = SWIG_AsVal_long(obj4, &val5);
43482 if (!SWIG_IsOK(ecode5)) {
43483 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43484 }
43485 arg5 = static_cast< long >(val5);
43486 }
43487 if (obj5) {
43488 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43489 if (!SWIG_IsOK(res6)) {
43490 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43491 }
43492 if (!argp6) {
43493 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43494 }
43495 arg6 = reinterpret_cast< wxValidator * >(argp6);
43496 }
43497 if (obj6) {
43498 {
43499 arg7 = wxString_in_helper(obj6);
43500 if (arg7 == NULL) SWIG_fail;
43501 temp7 = true;
43502 }
43503 }
43504 {
43505 if (!wxPyCheckForApp()) SWIG_fail;
43506 PyThreadState* __tstate = wxPyBeginAllowThreads();
43507 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43508 wxPyEndAllowThreads(__tstate);
43509 if (PyErr_Occurred()) SWIG_fail;
43510 }
43511 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43512 {
43513 if (temp7)
43514 delete arg7;
43515 }
43516 return resultobj;
43517 fail:
43518 {
43519 if (temp7)
43520 delete arg7;
43521 }
43522 return NULL;
43523 }
43524
43525
43526 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43527 PyObject *resultobj = 0;
43528 wxControl *result = 0 ;
43529
43530 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43531 {
43532 if (!wxPyCheckForApp()) SWIG_fail;
43533 PyThreadState* __tstate = wxPyBeginAllowThreads();
43534 result = (wxControl *)new wxControl();
43535 wxPyEndAllowThreads(__tstate);
43536 if (PyErr_Occurred()) SWIG_fail;
43537 }
43538 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43539 return resultobj;
43540 fail:
43541 return NULL;
43542 }
43543
43544
43545 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43546 PyObject *resultobj = 0;
43547 wxControl *arg1 = (wxControl *) 0 ;
43548 wxWindow *arg2 = (wxWindow *) 0 ;
43549 int arg3 = (int) -1 ;
43550 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43551 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43552 wxSize const &arg5_defvalue = wxDefaultSize ;
43553 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43554 long arg6 = (long) 0 ;
43555 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43556 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43557 wxString const &arg8_defvalue = wxPyControlNameStr ;
43558 wxString *arg8 = (wxString *) &arg8_defvalue ;
43559 bool result;
43560 void *argp1 = 0 ;
43561 int res1 = 0 ;
43562 void *argp2 = 0 ;
43563 int res2 = 0 ;
43564 int val3 ;
43565 int ecode3 = 0 ;
43566 wxPoint temp4 ;
43567 wxSize temp5 ;
43568 long val6 ;
43569 int ecode6 = 0 ;
43570 void *argp7 = 0 ;
43571 int res7 = 0 ;
43572 bool temp8 = false ;
43573 PyObject * obj0 = 0 ;
43574 PyObject * obj1 = 0 ;
43575 PyObject * obj2 = 0 ;
43576 PyObject * obj3 = 0 ;
43577 PyObject * obj4 = 0 ;
43578 PyObject * obj5 = 0 ;
43579 PyObject * obj6 = 0 ;
43580 PyObject * obj7 = 0 ;
43581 char * kwnames[] = {
43582 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43583 };
43584
43585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43587 if (!SWIG_IsOK(res1)) {
43588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43589 }
43590 arg1 = reinterpret_cast< wxControl * >(argp1);
43591 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43592 if (!SWIG_IsOK(res2)) {
43593 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43594 }
43595 arg2 = reinterpret_cast< wxWindow * >(argp2);
43596 if (obj2) {
43597 ecode3 = SWIG_AsVal_int(obj2, &val3);
43598 if (!SWIG_IsOK(ecode3)) {
43599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43600 }
43601 arg3 = static_cast< int >(val3);
43602 }
43603 if (obj3) {
43604 {
43605 arg4 = &temp4;
43606 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43607 }
43608 }
43609 if (obj4) {
43610 {
43611 arg5 = &temp5;
43612 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43613 }
43614 }
43615 if (obj5) {
43616 ecode6 = SWIG_AsVal_long(obj5, &val6);
43617 if (!SWIG_IsOK(ecode6)) {
43618 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43619 }
43620 arg6 = static_cast< long >(val6);
43621 }
43622 if (obj6) {
43623 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43624 if (!SWIG_IsOK(res7)) {
43625 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43626 }
43627 if (!argp7) {
43628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43629 }
43630 arg7 = reinterpret_cast< wxValidator * >(argp7);
43631 }
43632 if (obj7) {
43633 {
43634 arg8 = wxString_in_helper(obj7);
43635 if (arg8 == NULL) SWIG_fail;
43636 temp8 = true;
43637 }
43638 }
43639 {
43640 PyThreadState* __tstate = wxPyBeginAllowThreads();
43641 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43642 wxPyEndAllowThreads(__tstate);
43643 if (PyErr_Occurred()) SWIG_fail;
43644 }
43645 {
43646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43647 }
43648 {
43649 if (temp8)
43650 delete arg8;
43651 }
43652 return resultobj;
43653 fail:
43654 {
43655 if (temp8)
43656 delete arg8;
43657 }
43658 return NULL;
43659 }
43660
43661
43662 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43663 PyObject *resultobj = 0;
43664 wxControl *arg1 = (wxControl *) 0 ;
43665 wxCommandEvent *arg2 = 0 ;
43666 void *argp1 = 0 ;
43667 int res1 = 0 ;
43668 void *argp2 = 0 ;
43669 int res2 = 0 ;
43670 PyObject * obj0 = 0 ;
43671 PyObject * obj1 = 0 ;
43672 char * kwnames[] = {
43673 (char *) "self",(char *) "event", NULL
43674 };
43675
43676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43678 if (!SWIG_IsOK(res1)) {
43679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43680 }
43681 arg1 = reinterpret_cast< wxControl * >(argp1);
43682 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43683 if (!SWIG_IsOK(res2)) {
43684 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43685 }
43686 if (!argp2) {
43687 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43688 }
43689 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43690 {
43691 PyThreadState* __tstate = wxPyBeginAllowThreads();
43692 (arg1)->Command(*arg2);
43693 wxPyEndAllowThreads(__tstate);
43694 if (PyErr_Occurred()) SWIG_fail;
43695 }
43696 resultobj = SWIG_Py_Void();
43697 return resultobj;
43698 fail:
43699 return NULL;
43700 }
43701
43702
43703 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43704 PyObject *resultobj = 0;
43705 wxControl *arg1 = (wxControl *) 0 ;
43706 wxString result;
43707 void *argp1 = 0 ;
43708 int res1 = 0 ;
43709 PyObject *swig_obj[1] ;
43710
43711 if (!args) SWIG_fail;
43712 swig_obj[0] = args;
43713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43714 if (!SWIG_IsOK(res1)) {
43715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43716 }
43717 arg1 = reinterpret_cast< wxControl * >(argp1);
43718 {
43719 PyThreadState* __tstate = wxPyBeginAllowThreads();
43720 result = (arg1)->GetLabel();
43721 wxPyEndAllowThreads(__tstate);
43722 if (PyErr_Occurred()) SWIG_fail;
43723 }
43724 {
43725 #if wxUSE_UNICODE
43726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43727 #else
43728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43729 #endif
43730 }
43731 return resultobj;
43732 fail:
43733 return NULL;
43734 }
43735
43736
43737 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43738 PyObject *resultobj = 0;
43739 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43740 SwigValueWrapper<wxVisualAttributes > result;
43741 int val1 ;
43742 int ecode1 = 0 ;
43743 PyObject * obj0 = 0 ;
43744 char * kwnames[] = {
43745 (char *) "variant", NULL
43746 };
43747
43748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43749 if (obj0) {
43750 ecode1 = SWIG_AsVal_int(obj0, &val1);
43751 if (!SWIG_IsOK(ecode1)) {
43752 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43753 }
43754 arg1 = static_cast< wxWindowVariant >(val1);
43755 }
43756 {
43757 if (!wxPyCheckForApp()) SWIG_fail;
43758 PyThreadState* __tstate = wxPyBeginAllowThreads();
43759 result = wxControl::GetClassDefaultAttributes(arg1);
43760 wxPyEndAllowThreads(__tstate);
43761 if (PyErr_Occurred()) SWIG_fail;
43762 }
43763 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
43764 return resultobj;
43765 fail:
43766 return NULL;
43767 }
43768
43769
43770 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43771 PyObject *obj;
43772 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43773 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
43774 return SWIG_Py_Void();
43775 }
43776
43777 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43778 return SWIG_Python_InitShadowInstance(args);
43779 }
43780
43781 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43782 PyObject *resultobj = 0;
43783 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43784 wxString *arg2 = 0 ;
43785 PyObject *arg3 = (PyObject *) NULL ;
43786 int result;
43787 void *argp1 = 0 ;
43788 int res1 = 0 ;
43789 bool temp2 = false ;
43790 PyObject * obj0 = 0 ;
43791 PyObject * obj1 = 0 ;
43792 PyObject * obj2 = 0 ;
43793 char * kwnames[] = {
43794 (char *) "self",(char *) "item",(char *) "clientData", NULL
43795 };
43796
43797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43799 if (!SWIG_IsOK(res1)) {
43800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43801 }
43802 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43803 {
43804 arg2 = wxString_in_helper(obj1);
43805 if (arg2 == NULL) SWIG_fail;
43806 temp2 = true;
43807 }
43808 if (obj2) {
43809 arg3 = obj2;
43810 }
43811 {
43812 PyThreadState* __tstate = wxPyBeginAllowThreads();
43813 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
43814 wxPyEndAllowThreads(__tstate);
43815 if (PyErr_Occurred()) SWIG_fail;
43816 }
43817 resultobj = SWIG_From_int(static_cast< int >(result));
43818 {
43819 if (temp2)
43820 delete arg2;
43821 }
43822 return resultobj;
43823 fail:
43824 {
43825 if (temp2)
43826 delete arg2;
43827 }
43828 return NULL;
43829 }
43830
43831
43832 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43833 PyObject *resultobj = 0;
43834 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43835 wxArrayString *arg2 = 0 ;
43836 void *argp1 = 0 ;
43837 int res1 = 0 ;
43838 bool temp2 = false ;
43839 PyObject * obj0 = 0 ;
43840 PyObject * obj1 = 0 ;
43841 char * kwnames[] = {
43842 (char *) "self",(char *) "strings", NULL
43843 };
43844
43845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
43846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43847 if (!SWIG_IsOK(res1)) {
43848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43849 }
43850 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43851 {
43852 if (! PySequence_Check(obj1)) {
43853 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
43854 SWIG_fail;
43855 }
43856 arg2 = new wxArrayString;
43857 temp2 = true;
43858 int i, len=PySequence_Length(obj1);
43859 for (i=0; i<len; i++) {
43860 PyObject* item = PySequence_GetItem(obj1, i);
43861 wxString* s = wxString_in_helper(item);
43862 if (PyErr_Occurred()) SWIG_fail;
43863 arg2->Add(*s);
43864 delete s;
43865 Py_DECREF(item);
43866 }
43867 }
43868 {
43869 PyThreadState* __tstate = wxPyBeginAllowThreads();
43870 (arg1)->Append((wxArrayString const &)*arg2);
43871 wxPyEndAllowThreads(__tstate);
43872 if (PyErr_Occurred()) SWIG_fail;
43873 }
43874 resultobj = SWIG_Py_Void();
43875 {
43876 if (temp2) delete arg2;
43877 }
43878 return resultobj;
43879 fail:
43880 {
43881 if (temp2) delete arg2;
43882 }
43883 return NULL;
43884 }
43885
43886
43887 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43888 PyObject *resultobj = 0;
43889 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43890 wxString *arg2 = 0 ;
43891 int arg3 ;
43892 PyObject *arg4 = (PyObject *) NULL ;
43893 int result;
43894 void *argp1 = 0 ;
43895 int res1 = 0 ;
43896 bool temp2 = false ;
43897 int val3 ;
43898 int ecode3 = 0 ;
43899 PyObject * obj0 = 0 ;
43900 PyObject * obj1 = 0 ;
43901 PyObject * obj2 = 0 ;
43902 PyObject * obj3 = 0 ;
43903 char * kwnames[] = {
43904 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
43905 };
43906
43907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43909 if (!SWIG_IsOK(res1)) {
43910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43911 }
43912 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43913 {
43914 arg2 = wxString_in_helper(obj1);
43915 if (arg2 == NULL) SWIG_fail;
43916 temp2 = true;
43917 }
43918 ecode3 = SWIG_AsVal_int(obj2, &val3);
43919 if (!SWIG_IsOK(ecode3)) {
43920 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
43921 }
43922 arg3 = static_cast< int >(val3);
43923 if (obj3) {
43924 arg4 = obj3;
43925 }
43926 {
43927 PyThreadState* __tstate = wxPyBeginAllowThreads();
43928 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
43929 wxPyEndAllowThreads(__tstate);
43930 if (PyErr_Occurred()) SWIG_fail;
43931 }
43932 resultobj = SWIG_From_int(static_cast< int >(result));
43933 {
43934 if (temp2)
43935 delete arg2;
43936 }
43937 return resultobj;
43938 fail:
43939 {
43940 if (temp2)
43941 delete arg2;
43942 }
43943 return NULL;
43944 }
43945
43946
43947 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43948 PyObject *resultobj = 0;
43949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43950 void *argp1 = 0 ;
43951 int res1 = 0 ;
43952 PyObject *swig_obj[1] ;
43953
43954 if (!args) SWIG_fail;
43955 swig_obj[0] = args;
43956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43957 if (!SWIG_IsOK(res1)) {
43958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43959 }
43960 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43961 {
43962 PyThreadState* __tstate = wxPyBeginAllowThreads();
43963 (arg1)->Clear();
43964 wxPyEndAllowThreads(__tstate);
43965 if (PyErr_Occurred()) SWIG_fail;
43966 }
43967 resultobj = SWIG_Py_Void();
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj = 0;
43976 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
43977 int arg2 ;
43978 void *argp1 = 0 ;
43979 int res1 = 0 ;
43980 int val2 ;
43981 int ecode2 = 0 ;
43982 PyObject * obj0 = 0 ;
43983 PyObject * obj1 = 0 ;
43984 char * kwnames[] = {
43985 (char *) "self",(char *) "n", NULL
43986 };
43987
43988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
43990 if (!SWIG_IsOK(res1)) {
43991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
43992 }
43993 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
43994 ecode2 = SWIG_AsVal_int(obj1, &val2);
43995 if (!SWIG_IsOK(ecode2)) {
43996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
43997 }
43998 arg2 = static_cast< int >(val2);
43999 {
44000 PyThreadState* __tstate = wxPyBeginAllowThreads();
44001 (arg1)->Delete(arg2);
44002 wxPyEndAllowThreads(__tstate);
44003 if (PyErr_Occurred()) SWIG_fail;
44004 }
44005 resultobj = SWIG_Py_Void();
44006 return resultobj;
44007 fail:
44008 return NULL;
44009 }
44010
44011
44012 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44013 PyObject *resultobj = 0;
44014 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44015 int arg2 ;
44016 PyObject *result = 0 ;
44017 void *argp1 = 0 ;
44018 int res1 = 0 ;
44019 int val2 ;
44020 int ecode2 = 0 ;
44021 PyObject * obj0 = 0 ;
44022 PyObject * obj1 = 0 ;
44023 char * kwnames[] = {
44024 (char *) "self",(char *) "n", NULL
44025 };
44026
44027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44029 if (!SWIG_IsOK(res1)) {
44030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44031 }
44032 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44033 ecode2 = SWIG_AsVal_int(obj1, &val2);
44034 if (!SWIG_IsOK(ecode2)) {
44035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
44036 }
44037 arg2 = static_cast< int >(val2);
44038 {
44039 PyThreadState* __tstate = wxPyBeginAllowThreads();
44040 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44041 wxPyEndAllowThreads(__tstate);
44042 if (PyErr_Occurred()) SWIG_fail;
44043 }
44044 resultobj = result;
44045 return resultobj;
44046 fail:
44047 return NULL;
44048 }
44049
44050
44051 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44052 PyObject *resultobj = 0;
44053 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44054 int arg2 ;
44055 PyObject *arg3 = (PyObject *) 0 ;
44056 void *argp1 = 0 ;
44057 int res1 = 0 ;
44058 int val2 ;
44059 int ecode2 = 0 ;
44060 PyObject * obj0 = 0 ;
44061 PyObject * obj1 = 0 ;
44062 PyObject * obj2 = 0 ;
44063 char * kwnames[] = {
44064 (char *) "self",(char *) "n",(char *) "clientData", NULL
44065 };
44066
44067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44068 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44069 if (!SWIG_IsOK(res1)) {
44070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44071 }
44072 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44073 ecode2 = SWIG_AsVal_int(obj1, &val2);
44074 if (!SWIG_IsOK(ecode2)) {
44075 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
44076 }
44077 arg2 = static_cast< int >(val2);
44078 arg3 = obj2;
44079 {
44080 PyThreadState* __tstate = wxPyBeginAllowThreads();
44081 wxItemContainer_SetClientData(arg1,arg2,arg3);
44082 wxPyEndAllowThreads(__tstate);
44083 if (PyErr_Occurred()) SWIG_fail;
44084 }
44085 resultobj = SWIG_Py_Void();
44086 return resultobj;
44087 fail:
44088 return NULL;
44089 }
44090
44091
44092 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44093 PyObject *resultobj = 0;
44094 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44095 size_t result;
44096 void *argp1 = 0 ;
44097 int res1 = 0 ;
44098 PyObject *swig_obj[1] ;
44099
44100 if (!args) SWIG_fail;
44101 swig_obj[0] = args;
44102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44103 if (!SWIG_IsOK(res1)) {
44104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44105 }
44106 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = (size_t)((wxItemContainer const *)arg1)->GetCount();
44110 wxPyEndAllowThreads(__tstate);
44111 if (PyErr_Occurred()) SWIG_fail;
44112 }
44113 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44114 return resultobj;
44115 fail:
44116 return NULL;
44117 }
44118
44119
44120 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44121 PyObject *resultobj = 0;
44122 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44123 bool result;
44124 void *argp1 = 0 ;
44125 int res1 = 0 ;
44126 PyObject *swig_obj[1] ;
44127
44128 if (!args) SWIG_fail;
44129 swig_obj[0] = args;
44130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44131 if (!SWIG_IsOK(res1)) {
44132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44133 }
44134 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44135 {
44136 PyThreadState* __tstate = wxPyBeginAllowThreads();
44137 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 {
44142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44143 }
44144 return resultobj;
44145 fail:
44146 return NULL;
44147 }
44148
44149
44150 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44151 PyObject *resultobj = 0;
44152 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44153 int arg2 ;
44154 wxString result;
44155 void *argp1 = 0 ;
44156 int res1 = 0 ;
44157 int val2 ;
44158 int ecode2 = 0 ;
44159 PyObject * obj0 = 0 ;
44160 PyObject * obj1 = 0 ;
44161 char * kwnames[] = {
44162 (char *) "self",(char *) "n", NULL
44163 };
44164
44165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44167 if (!SWIG_IsOK(res1)) {
44168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44169 }
44170 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44171 ecode2 = SWIG_AsVal_int(obj1, &val2);
44172 if (!SWIG_IsOK(ecode2)) {
44173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
44174 }
44175 arg2 = static_cast< int >(val2);
44176 {
44177 PyThreadState* __tstate = wxPyBeginAllowThreads();
44178 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44179 wxPyEndAllowThreads(__tstate);
44180 if (PyErr_Occurred()) SWIG_fail;
44181 }
44182 {
44183 #if wxUSE_UNICODE
44184 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44185 #else
44186 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44187 #endif
44188 }
44189 return resultobj;
44190 fail:
44191 return NULL;
44192 }
44193
44194
44195 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44196 PyObject *resultobj = 0;
44197 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44198 wxArrayString result;
44199 void *argp1 = 0 ;
44200 int res1 = 0 ;
44201 PyObject *swig_obj[1] ;
44202
44203 if (!args) SWIG_fail;
44204 swig_obj[0] = args;
44205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44206 if (!SWIG_IsOK(res1)) {
44207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44208 }
44209 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44210 {
44211 PyThreadState* __tstate = wxPyBeginAllowThreads();
44212 result = ((wxItemContainer const *)arg1)->GetStrings();
44213 wxPyEndAllowThreads(__tstate);
44214 if (PyErr_Occurred()) SWIG_fail;
44215 }
44216 {
44217 resultobj = wxArrayString2PyList_helper(result);
44218 }
44219 return resultobj;
44220 fail:
44221 return NULL;
44222 }
44223
44224
44225 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44226 PyObject *resultobj = 0;
44227 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44228 int arg2 ;
44229 wxString *arg3 = 0 ;
44230 void *argp1 = 0 ;
44231 int res1 = 0 ;
44232 int val2 ;
44233 int ecode2 = 0 ;
44234 bool temp3 = false ;
44235 PyObject * obj0 = 0 ;
44236 PyObject * obj1 = 0 ;
44237 PyObject * obj2 = 0 ;
44238 char * kwnames[] = {
44239 (char *) "self",(char *) "n",(char *) "s", NULL
44240 };
44241
44242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44244 if (!SWIG_IsOK(res1)) {
44245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44246 }
44247 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44248 ecode2 = SWIG_AsVal_int(obj1, &val2);
44249 if (!SWIG_IsOK(ecode2)) {
44250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
44251 }
44252 arg2 = static_cast< int >(val2);
44253 {
44254 arg3 = wxString_in_helper(obj2);
44255 if (arg3 == NULL) SWIG_fail;
44256 temp3 = true;
44257 }
44258 {
44259 PyThreadState* __tstate = wxPyBeginAllowThreads();
44260 (arg1)->SetString(arg2,(wxString const &)*arg3);
44261 wxPyEndAllowThreads(__tstate);
44262 if (PyErr_Occurred()) SWIG_fail;
44263 }
44264 resultobj = SWIG_Py_Void();
44265 {
44266 if (temp3)
44267 delete arg3;
44268 }
44269 return resultobj;
44270 fail:
44271 {
44272 if (temp3)
44273 delete arg3;
44274 }
44275 return NULL;
44276 }
44277
44278
44279 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44280 PyObject *resultobj = 0;
44281 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44282 wxString *arg2 = 0 ;
44283 int result;
44284 void *argp1 = 0 ;
44285 int res1 = 0 ;
44286 bool temp2 = false ;
44287 PyObject * obj0 = 0 ;
44288 PyObject * obj1 = 0 ;
44289 char * kwnames[] = {
44290 (char *) "self",(char *) "s", NULL
44291 };
44292
44293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44295 if (!SWIG_IsOK(res1)) {
44296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44297 }
44298 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44299 {
44300 arg2 = wxString_in_helper(obj1);
44301 if (arg2 == NULL) SWIG_fail;
44302 temp2 = true;
44303 }
44304 {
44305 PyThreadState* __tstate = wxPyBeginAllowThreads();
44306 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44307 wxPyEndAllowThreads(__tstate);
44308 if (PyErr_Occurred()) SWIG_fail;
44309 }
44310 resultobj = SWIG_From_int(static_cast< int >(result));
44311 {
44312 if (temp2)
44313 delete arg2;
44314 }
44315 return resultobj;
44316 fail:
44317 {
44318 if (temp2)
44319 delete arg2;
44320 }
44321 return NULL;
44322 }
44323
44324
44325 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44326 PyObject *resultobj = 0;
44327 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44328 int arg2 ;
44329 void *argp1 = 0 ;
44330 int res1 = 0 ;
44331 int val2 ;
44332 int ecode2 = 0 ;
44333 PyObject * obj0 = 0 ;
44334 PyObject * obj1 = 0 ;
44335 char * kwnames[] = {
44336 (char *) "self",(char *) "n", NULL
44337 };
44338
44339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44341 if (!SWIG_IsOK(res1)) {
44342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44343 }
44344 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44345 ecode2 = SWIG_AsVal_int(obj1, &val2);
44346 if (!SWIG_IsOK(ecode2)) {
44347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44348 }
44349 arg2 = static_cast< int >(val2);
44350 {
44351 PyThreadState* __tstate = wxPyBeginAllowThreads();
44352 (arg1)->SetSelection(arg2);
44353 wxPyEndAllowThreads(__tstate);
44354 if (PyErr_Occurred()) SWIG_fail;
44355 }
44356 resultobj = SWIG_Py_Void();
44357 return resultobj;
44358 fail:
44359 return NULL;
44360 }
44361
44362
44363 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44364 PyObject *resultobj = 0;
44365 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44366 int result;
44367 void *argp1 = 0 ;
44368 int res1 = 0 ;
44369 PyObject *swig_obj[1] ;
44370
44371 if (!args) SWIG_fail;
44372 swig_obj[0] = args;
44373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44374 if (!SWIG_IsOK(res1)) {
44375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44376 }
44377 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44378 {
44379 PyThreadState* __tstate = wxPyBeginAllowThreads();
44380 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44381 wxPyEndAllowThreads(__tstate);
44382 if (PyErr_Occurred()) SWIG_fail;
44383 }
44384 resultobj = SWIG_From_int(static_cast< int >(result));
44385 return resultobj;
44386 fail:
44387 return NULL;
44388 }
44389
44390
44391 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44392 PyObject *resultobj = 0;
44393 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44394 wxString *arg2 = 0 ;
44395 bool result;
44396 void *argp1 = 0 ;
44397 int res1 = 0 ;
44398 bool temp2 = false ;
44399 PyObject * obj0 = 0 ;
44400 PyObject * obj1 = 0 ;
44401 char * kwnames[] = {
44402 (char *) "self",(char *) "s", NULL
44403 };
44404
44405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44407 if (!SWIG_IsOK(res1)) {
44408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44409 }
44410 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44411 {
44412 arg2 = wxString_in_helper(obj1);
44413 if (arg2 == NULL) SWIG_fail;
44414 temp2 = true;
44415 }
44416 {
44417 PyThreadState* __tstate = wxPyBeginAllowThreads();
44418 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44419 wxPyEndAllowThreads(__tstate);
44420 if (PyErr_Occurred()) SWIG_fail;
44421 }
44422 {
44423 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44424 }
44425 {
44426 if (temp2)
44427 delete arg2;
44428 }
44429 return resultobj;
44430 fail:
44431 {
44432 if (temp2)
44433 delete arg2;
44434 }
44435 return NULL;
44436 }
44437
44438
44439 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44440 PyObject *resultobj = 0;
44441 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44442 wxString result;
44443 void *argp1 = 0 ;
44444 int res1 = 0 ;
44445 PyObject *swig_obj[1] ;
44446
44447 if (!args) SWIG_fail;
44448 swig_obj[0] = args;
44449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44450 if (!SWIG_IsOK(res1)) {
44451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44452 }
44453 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44454 {
44455 PyThreadState* __tstate = wxPyBeginAllowThreads();
44456 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44457 wxPyEndAllowThreads(__tstate);
44458 if (PyErr_Occurred()) SWIG_fail;
44459 }
44460 {
44461 #if wxUSE_UNICODE
44462 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44463 #else
44464 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44465 #endif
44466 }
44467 return resultobj;
44468 fail:
44469 return NULL;
44470 }
44471
44472
44473 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44474 PyObject *resultobj = 0;
44475 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44476 int arg2 ;
44477 void *argp1 = 0 ;
44478 int res1 = 0 ;
44479 int val2 ;
44480 int ecode2 = 0 ;
44481 PyObject * obj0 = 0 ;
44482 PyObject * obj1 = 0 ;
44483 char * kwnames[] = {
44484 (char *) "self",(char *) "n", NULL
44485 };
44486
44487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44489 if (!SWIG_IsOK(res1)) {
44490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44491 }
44492 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44493 ecode2 = SWIG_AsVal_int(obj1, &val2);
44494 if (!SWIG_IsOK(ecode2)) {
44495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44496 }
44497 arg2 = static_cast< int >(val2);
44498 {
44499 PyThreadState* __tstate = wxPyBeginAllowThreads();
44500 (arg1)->Select(arg2);
44501 wxPyEndAllowThreads(__tstate);
44502 if (PyErr_Occurred()) SWIG_fail;
44503 }
44504 resultobj = SWIG_Py_Void();
44505 return resultobj;
44506 fail:
44507 return NULL;
44508 }
44509
44510
44511 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44512 PyObject *obj;
44513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44514 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44515 return SWIG_Py_Void();
44516 }
44517
44518 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44519 PyObject *obj;
44520 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44521 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44522 return SWIG_Py_Void();
44523 }
44524
44525 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44526 PyObject *resultobj = 0;
44527 wxSizerItem *result = 0 ;
44528
44529 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44530 {
44531 PyThreadState* __tstate = wxPyBeginAllowThreads();
44532 result = (wxSizerItem *)new wxSizerItem();
44533 wxPyEndAllowThreads(__tstate);
44534 if (PyErr_Occurred()) SWIG_fail;
44535 }
44536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44537 return resultobj;
44538 fail:
44539 return NULL;
44540 }
44541
44542
44543 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44544 PyObject *resultobj = 0;
44545 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44546 void *argp1 = 0 ;
44547 int res1 = 0 ;
44548 PyObject *swig_obj[1] ;
44549
44550 if (!args) SWIG_fail;
44551 swig_obj[0] = args;
44552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44553 if (!SWIG_IsOK(res1)) {
44554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44555 }
44556 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44557 {
44558 PyThreadState* __tstate = wxPyBeginAllowThreads();
44559 delete arg1;
44560
44561 wxPyEndAllowThreads(__tstate);
44562 if (PyErr_Occurred()) SWIG_fail;
44563 }
44564 resultobj = SWIG_Py_Void();
44565 return resultobj;
44566 fail:
44567 return NULL;
44568 }
44569
44570
44571 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44572 PyObject *resultobj = 0;
44573 wxWindow *arg1 = (wxWindow *) 0 ;
44574 int arg2 ;
44575 int arg3 ;
44576 int arg4 ;
44577 PyObject *arg5 = (PyObject *) NULL ;
44578 wxSizerItem *result = 0 ;
44579 void *argp1 = 0 ;
44580 int res1 = 0 ;
44581 int val2 ;
44582 int ecode2 = 0 ;
44583 int val3 ;
44584 int ecode3 = 0 ;
44585 int val4 ;
44586 int ecode4 = 0 ;
44587 PyObject * obj0 = 0 ;
44588 PyObject * obj1 = 0 ;
44589 PyObject * obj2 = 0 ;
44590 PyObject * obj3 = 0 ;
44591 PyObject * obj4 = 0 ;
44592 char * kwnames[] = {
44593 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44594 };
44595
44596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44598 if (!SWIG_IsOK(res1)) {
44599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44600 }
44601 arg1 = reinterpret_cast< wxWindow * >(argp1);
44602 ecode2 = SWIG_AsVal_int(obj1, &val2);
44603 if (!SWIG_IsOK(ecode2)) {
44604 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44605 }
44606 arg2 = static_cast< int >(val2);
44607 ecode3 = SWIG_AsVal_int(obj2, &val3);
44608 if (!SWIG_IsOK(ecode3)) {
44609 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44610 }
44611 arg3 = static_cast< int >(val3);
44612 ecode4 = SWIG_AsVal_int(obj3, &val4);
44613 if (!SWIG_IsOK(ecode4)) {
44614 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44615 }
44616 arg4 = static_cast< int >(val4);
44617 if (obj4) {
44618 arg5 = obj4;
44619 }
44620 {
44621 PyThreadState* __tstate = wxPyBeginAllowThreads();
44622 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44623 wxPyEndAllowThreads(__tstate);
44624 if (PyErr_Occurred()) SWIG_fail;
44625 }
44626 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44627 return resultobj;
44628 fail:
44629 return NULL;
44630 }
44631
44632
44633 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44634 PyObject *resultobj = 0;
44635 int arg1 ;
44636 int arg2 ;
44637 int arg3 ;
44638 int arg4 ;
44639 int arg5 ;
44640 PyObject *arg6 = (PyObject *) NULL ;
44641 wxSizerItem *result = 0 ;
44642 int val1 ;
44643 int ecode1 = 0 ;
44644 int val2 ;
44645 int ecode2 = 0 ;
44646 int val3 ;
44647 int ecode3 = 0 ;
44648 int val4 ;
44649 int ecode4 = 0 ;
44650 int val5 ;
44651 int ecode5 = 0 ;
44652 PyObject * obj0 = 0 ;
44653 PyObject * obj1 = 0 ;
44654 PyObject * obj2 = 0 ;
44655 PyObject * obj3 = 0 ;
44656 PyObject * obj4 = 0 ;
44657 PyObject * obj5 = 0 ;
44658 char * kwnames[] = {
44659 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44660 };
44661
44662 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44663 ecode1 = SWIG_AsVal_int(obj0, &val1);
44664 if (!SWIG_IsOK(ecode1)) {
44665 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44666 }
44667 arg1 = static_cast< int >(val1);
44668 ecode2 = SWIG_AsVal_int(obj1, &val2);
44669 if (!SWIG_IsOK(ecode2)) {
44670 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44671 }
44672 arg2 = static_cast< int >(val2);
44673 ecode3 = SWIG_AsVal_int(obj2, &val3);
44674 if (!SWIG_IsOK(ecode3)) {
44675 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44676 }
44677 arg3 = static_cast< int >(val3);
44678 ecode4 = SWIG_AsVal_int(obj3, &val4);
44679 if (!SWIG_IsOK(ecode4)) {
44680 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44681 }
44682 arg4 = static_cast< int >(val4);
44683 ecode5 = SWIG_AsVal_int(obj4, &val5);
44684 if (!SWIG_IsOK(ecode5)) {
44685 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44686 }
44687 arg5 = static_cast< int >(val5);
44688 if (obj5) {
44689 arg6 = obj5;
44690 }
44691 {
44692 PyThreadState* __tstate = wxPyBeginAllowThreads();
44693 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44694 wxPyEndAllowThreads(__tstate);
44695 if (PyErr_Occurred()) SWIG_fail;
44696 }
44697 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44698 return resultobj;
44699 fail:
44700 return NULL;
44701 }
44702
44703
44704 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44705 PyObject *resultobj = 0;
44706 wxSizer *arg1 = (wxSizer *) 0 ;
44707 int arg2 ;
44708 int arg3 ;
44709 int arg4 ;
44710 PyObject *arg5 = (PyObject *) NULL ;
44711 wxSizerItem *result = 0 ;
44712 int res1 = 0 ;
44713 int val2 ;
44714 int ecode2 = 0 ;
44715 int val3 ;
44716 int ecode3 = 0 ;
44717 int val4 ;
44718 int ecode4 = 0 ;
44719 PyObject * obj0 = 0 ;
44720 PyObject * obj1 = 0 ;
44721 PyObject * obj2 = 0 ;
44722 PyObject * obj3 = 0 ;
44723 PyObject * obj4 = 0 ;
44724 char * kwnames[] = {
44725 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44726 };
44727
44728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44729 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44730 if (!SWIG_IsOK(res1)) {
44731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44732 }
44733 ecode2 = SWIG_AsVal_int(obj1, &val2);
44734 if (!SWIG_IsOK(ecode2)) {
44735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44736 }
44737 arg2 = static_cast< int >(val2);
44738 ecode3 = SWIG_AsVal_int(obj2, &val3);
44739 if (!SWIG_IsOK(ecode3)) {
44740 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44741 }
44742 arg3 = static_cast< int >(val3);
44743 ecode4 = SWIG_AsVal_int(obj3, &val4);
44744 if (!SWIG_IsOK(ecode4)) {
44745 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44746 }
44747 arg4 = static_cast< int >(val4);
44748 if (obj4) {
44749 arg5 = obj4;
44750 }
44751 {
44752 PyThreadState* __tstate = wxPyBeginAllowThreads();
44753 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44754 wxPyEndAllowThreads(__tstate);
44755 if (PyErr_Occurred()) SWIG_fail;
44756 }
44757 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44758 return resultobj;
44759 fail:
44760 return NULL;
44761 }
44762
44763
44764 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44765 PyObject *resultobj = 0;
44766 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44767 void *argp1 = 0 ;
44768 int res1 = 0 ;
44769 PyObject *swig_obj[1] ;
44770
44771 if (!args) SWIG_fail;
44772 swig_obj[0] = args;
44773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44774 if (!SWIG_IsOK(res1)) {
44775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44776 }
44777 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44778 {
44779 PyThreadState* __tstate = wxPyBeginAllowThreads();
44780 (arg1)->DeleteWindows();
44781 wxPyEndAllowThreads(__tstate);
44782 if (PyErr_Occurred()) SWIG_fail;
44783 }
44784 resultobj = SWIG_Py_Void();
44785 return resultobj;
44786 fail:
44787 return NULL;
44788 }
44789
44790
44791 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44792 PyObject *resultobj = 0;
44793 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 PyObject *swig_obj[1] ;
44797
44798 if (!args) SWIG_fail;
44799 swig_obj[0] = args;
44800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44801 if (!SWIG_IsOK(res1)) {
44802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44803 }
44804 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44805 {
44806 PyThreadState* __tstate = wxPyBeginAllowThreads();
44807 (arg1)->DetachSizer();
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 resultobj = SWIG_Py_Void();
44812 return resultobj;
44813 fail:
44814 return NULL;
44815 }
44816
44817
44818 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44819 PyObject *resultobj = 0;
44820 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44821 wxSize result;
44822 void *argp1 = 0 ;
44823 int res1 = 0 ;
44824 PyObject *swig_obj[1] ;
44825
44826 if (!args) SWIG_fail;
44827 swig_obj[0] = args;
44828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44829 if (!SWIG_IsOK(res1)) {
44830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44831 }
44832 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44833 {
44834 PyThreadState* __tstate = wxPyBeginAllowThreads();
44835 result = (arg1)->GetSize();
44836 wxPyEndAllowThreads(__tstate);
44837 if (PyErr_Occurred()) SWIG_fail;
44838 }
44839 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44840 return resultobj;
44841 fail:
44842 return NULL;
44843 }
44844
44845
44846 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44847 PyObject *resultobj = 0;
44848 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44849 wxSize result;
44850 void *argp1 = 0 ;
44851 int res1 = 0 ;
44852 PyObject *swig_obj[1] ;
44853
44854 if (!args) SWIG_fail;
44855 swig_obj[0] = args;
44856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44857 if (!SWIG_IsOK(res1)) {
44858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44859 }
44860 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44861 {
44862 PyThreadState* __tstate = wxPyBeginAllowThreads();
44863 result = (arg1)->CalcMin();
44864 wxPyEndAllowThreads(__tstate);
44865 if (PyErr_Occurred()) SWIG_fail;
44866 }
44867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44868 return resultobj;
44869 fail:
44870 return NULL;
44871 }
44872
44873
44874 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44875 PyObject *resultobj = 0;
44876 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44877 wxPoint *arg2 = 0 ;
44878 wxSize *arg3 = 0 ;
44879 void *argp1 = 0 ;
44880 int res1 = 0 ;
44881 wxPoint temp2 ;
44882 wxSize temp3 ;
44883 PyObject * obj0 = 0 ;
44884 PyObject * obj1 = 0 ;
44885 PyObject * obj2 = 0 ;
44886 char * kwnames[] = {
44887 (char *) "self",(char *) "pos",(char *) "size", NULL
44888 };
44889
44890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44892 if (!SWIG_IsOK(res1)) {
44893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44894 }
44895 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44896 {
44897 arg2 = &temp2;
44898 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44899 }
44900 {
44901 arg3 = &temp3;
44902 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
44903 }
44904 {
44905 PyThreadState* __tstate = wxPyBeginAllowThreads();
44906 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
44907 wxPyEndAllowThreads(__tstate);
44908 if (PyErr_Occurred()) SWIG_fail;
44909 }
44910 resultobj = SWIG_Py_Void();
44911 return resultobj;
44912 fail:
44913 return NULL;
44914 }
44915
44916
44917 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44918 PyObject *resultobj = 0;
44919 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44920 wxSize result;
44921 void *argp1 = 0 ;
44922 int res1 = 0 ;
44923 PyObject *swig_obj[1] ;
44924
44925 if (!args) SWIG_fail;
44926 swig_obj[0] = args;
44927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44928 if (!SWIG_IsOK(res1)) {
44929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44930 }
44931 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44932 {
44933 PyThreadState* __tstate = wxPyBeginAllowThreads();
44934 result = (arg1)->GetMinSize();
44935 wxPyEndAllowThreads(__tstate);
44936 if (PyErr_Occurred()) SWIG_fail;
44937 }
44938 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44939 return resultobj;
44940 fail:
44941 return NULL;
44942 }
44943
44944
44945 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44946 PyObject *resultobj = 0;
44947 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44948 wxSize result;
44949 void *argp1 = 0 ;
44950 int res1 = 0 ;
44951 PyObject *swig_obj[1] ;
44952
44953 if (!args) SWIG_fail;
44954 swig_obj[0] = args;
44955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44956 if (!SWIG_IsOK(res1)) {
44957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
44958 }
44959 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44960 {
44961 PyThreadState* __tstate = wxPyBeginAllowThreads();
44962 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
44963 wxPyEndAllowThreads(__tstate);
44964 if (PyErr_Occurred()) SWIG_fail;
44965 }
44966 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
44967 return resultobj;
44968 fail:
44969 return NULL;
44970 }
44971
44972
44973 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44974 PyObject *resultobj = 0;
44975 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44976 int arg2 ;
44977 int arg3 ;
44978 void *argp1 = 0 ;
44979 int res1 = 0 ;
44980 int val2 ;
44981 int ecode2 = 0 ;
44982 int val3 ;
44983 int ecode3 = 0 ;
44984 PyObject * obj0 = 0 ;
44985 PyObject * obj1 = 0 ;
44986 PyObject * obj2 = 0 ;
44987 char * kwnames[] = {
44988 (char *) "self",(char *) "x",(char *) "y", NULL
44989 };
44990
44991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
44993 if (!SWIG_IsOK(res1)) {
44994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44995 }
44996 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44997 ecode2 = SWIG_AsVal_int(obj1, &val2);
44998 if (!SWIG_IsOK(ecode2)) {
44999 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45000 }
45001 arg2 = static_cast< int >(val2);
45002 ecode3 = SWIG_AsVal_int(obj2, &val3);
45003 if (!SWIG_IsOK(ecode3)) {
45004 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45005 }
45006 arg3 = static_cast< int >(val3);
45007 {
45008 PyThreadState* __tstate = wxPyBeginAllowThreads();
45009 (arg1)->SetInitSize(arg2,arg3);
45010 wxPyEndAllowThreads(__tstate);
45011 if (PyErr_Occurred()) SWIG_fail;
45012 }
45013 resultobj = SWIG_Py_Void();
45014 return resultobj;
45015 fail:
45016 return NULL;
45017 }
45018
45019
45020 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45021 PyObject *resultobj = 0;
45022 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45023 int arg2 ;
45024 int arg3 ;
45025 void *argp1 = 0 ;
45026 int res1 = 0 ;
45027 int val2 ;
45028 int ecode2 = 0 ;
45029 int val3 ;
45030 int ecode3 = 0 ;
45031 PyObject * obj0 = 0 ;
45032 PyObject * obj1 = 0 ;
45033 PyObject * obj2 = 0 ;
45034 char * kwnames[] = {
45035 (char *) "self",(char *) "width",(char *) "height", NULL
45036 };
45037
45038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45040 if (!SWIG_IsOK(res1)) {
45041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45042 }
45043 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45044 ecode2 = SWIG_AsVal_int(obj1, &val2);
45045 if (!SWIG_IsOK(ecode2)) {
45046 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45047 }
45048 arg2 = static_cast< int >(val2);
45049 ecode3 = SWIG_AsVal_int(obj2, &val3);
45050 if (!SWIG_IsOK(ecode3)) {
45051 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45052 }
45053 arg3 = static_cast< int >(val3);
45054 {
45055 PyThreadState* __tstate = wxPyBeginAllowThreads();
45056 (arg1)->SetRatio(arg2,arg3);
45057 wxPyEndAllowThreads(__tstate);
45058 if (PyErr_Occurred()) SWIG_fail;
45059 }
45060 resultobj = SWIG_Py_Void();
45061 return resultobj;
45062 fail:
45063 return NULL;
45064 }
45065
45066
45067 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45068 PyObject *resultobj = 0;
45069 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45070 wxSize *arg2 = 0 ;
45071 void *argp1 = 0 ;
45072 int res1 = 0 ;
45073 wxSize temp2 ;
45074 PyObject * obj0 = 0 ;
45075 PyObject * obj1 = 0 ;
45076 char * kwnames[] = {
45077 (char *) "self",(char *) "size", NULL
45078 };
45079
45080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45082 if (!SWIG_IsOK(res1)) {
45083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45084 }
45085 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45086 {
45087 arg2 = &temp2;
45088 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45089 }
45090 {
45091 PyThreadState* __tstate = wxPyBeginAllowThreads();
45092 (arg1)->SetRatio((wxSize const &)*arg2);
45093 wxPyEndAllowThreads(__tstate);
45094 if (PyErr_Occurred()) SWIG_fail;
45095 }
45096 resultobj = SWIG_Py_Void();
45097 return resultobj;
45098 fail:
45099 return NULL;
45100 }
45101
45102
45103 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45104 PyObject *resultobj = 0;
45105 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45106 float arg2 ;
45107 void *argp1 = 0 ;
45108 int res1 = 0 ;
45109 float val2 ;
45110 int ecode2 = 0 ;
45111 PyObject * obj0 = 0 ;
45112 PyObject * obj1 = 0 ;
45113 char * kwnames[] = {
45114 (char *) "self",(char *) "ratio", NULL
45115 };
45116
45117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45119 if (!SWIG_IsOK(res1)) {
45120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45121 }
45122 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45123 ecode2 = SWIG_AsVal_float(obj1, &val2);
45124 if (!SWIG_IsOK(ecode2)) {
45125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45126 }
45127 arg2 = static_cast< float >(val2);
45128 {
45129 PyThreadState* __tstate = wxPyBeginAllowThreads();
45130 (arg1)->SetRatio(arg2);
45131 wxPyEndAllowThreads(__tstate);
45132 if (PyErr_Occurred()) SWIG_fail;
45133 }
45134 resultobj = SWIG_Py_Void();
45135 return resultobj;
45136 fail:
45137 return NULL;
45138 }
45139
45140
45141 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45142 PyObject *resultobj = 0;
45143 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45144 float result;
45145 void *argp1 = 0 ;
45146 int res1 = 0 ;
45147 PyObject *swig_obj[1] ;
45148
45149 if (!args) SWIG_fail;
45150 swig_obj[0] = args;
45151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45152 if (!SWIG_IsOK(res1)) {
45153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45154 }
45155 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45156 {
45157 PyThreadState* __tstate = wxPyBeginAllowThreads();
45158 result = (float)(arg1)->GetRatio();
45159 wxPyEndAllowThreads(__tstate);
45160 if (PyErr_Occurred()) SWIG_fail;
45161 }
45162 resultobj = SWIG_From_float(static_cast< float >(result));
45163 return resultobj;
45164 fail:
45165 return NULL;
45166 }
45167
45168
45169 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45170 PyObject *resultobj = 0;
45171 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45172 wxRect result;
45173 void *argp1 = 0 ;
45174 int res1 = 0 ;
45175 PyObject *swig_obj[1] ;
45176
45177 if (!args) SWIG_fail;
45178 swig_obj[0] = args;
45179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45180 if (!SWIG_IsOK(res1)) {
45181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45182 }
45183 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45184 {
45185 PyThreadState* __tstate = wxPyBeginAllowThreads();
45186 result = (arg1)->GetRect();
45187 wxPyEndAllowThreads(__tstate);
45188 if (PyErr_Occurred()) SWIG_fail;
45189 }
45190 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45191 return resultobj;
45192 fail:
45193 return NULL;
45194 }
45195
45196
45197 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45198 PyObject *resultobj = 0;
45199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45200 bool result;
45201 void *argp1 = 0 ;
45202 int res1 = 0 ;
45203 PyObject *swig_obj[1] ;
45204
45205 if (!args) SWIG_fail;
45206 swig_obj[0] = args;
45207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45208 if (!SWIG_IsOK(res1)) {
45209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45210 }
45211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45212 {
45213 PyThreadState* __tstate = wxPyBeginAllowThreads();
45214 result = (bool)(arg1)->IsWindow();
45215 wxPyEndAllowThreads(__tstate);
45216 if (PyErr_Occurred()) SWIG_fail;
45217 }
45218 {
45219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45220 }
45221 return resultobj;
45222 fail:
45223 return NULL;
45224 }
45225
45226
45227 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45228 PyObject *resultobj = 0;
45229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45230 bool result;
45231 void *argp1 = 0 ;
45232 int res1 = 0 ;
45233 PyObject *swig_obj[1] ;
45234
45235 if (!args) SWIG_fail;
45236 swig_obj[0] = args;
45237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45238 if (!SWIG_IsOK(res1)) {
45239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45240 }
45241 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45242 {
45243 PyThreadState* __tstate = wxPyBeginAllowThreads();
45244 result = (bool)(arg1)->IsSizer();
45245 wxPyEndAllowThreads(__tstate);
45246 if (PyErr_Occurred()) SWIG_fail;
45247 }
45248 {
45249 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45250 }
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45258 PyObject *resultobj = 0;
45259 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45260 bool result;
45261 void *argp1 = 0 ;
45262 int res1 = 0 ;
45263 PyObject *swig_obj[1] ;
45264
45265 if (!args) SWIG_fail;
45266 swig_obj[0] = args;
45267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45268 if (!SWIG_IsOK(res1)) {
45269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45270 }
45271 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45272 {
45273 PyThreadState* __tstate = wxPyBeginAllowThreads();
45274 result = (bool)(arg1)->IsSpacer();
45275 wxPyEndAllowThreads(__tstate);
45276 if (PyErr_Occurred()) SWIG_fail;
45277 }
45278 {
45279 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45280 }
45281 return resultobj;
45282 fail:
45283 return NULL;
45284 }
45285
45286
45287 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45288 PyObject *resultobj = 0;
45289 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45290 int arg2 ;
45291 void *argp1 = 0 ;
45292 int res1 = 0 ;
45293 int val2 ;
45294 int ecode2 = 0 ;
45295 PyObject * obj0 = 0 ;
45296 PyObject * obj1 = 0 ;
45297 char * kwnames[] = {
45298 (char *) "self",(char *) "proportion", NULL
45299 };
45300
45301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45303 if (!SWIG_IsOK(res1)) {
45304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45305 }
45306 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45307 ecode2 = SWIG_AsVal_int(obj1, &val2);
45308 if (!SWIG_IsOK(ecode2)) {
45309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45310 }
45311 arg2 = static_cast< int >(val2);
45312 {
45313 PyThreadState* __tstate = wxPyBeginAllowThreads();
45314 (arg1)->SetProportion(arg2);
45315 wxPyEndAllowThreads(__tstate);
45316 if (PyErr_Occurred()) SWIG_fail;
45317 }
45318 resultobj = SWIG_Py_Void();
45319 return resultobj;
45320 fail:
45321 return NULL;
45322 }
45323
45324
45325 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45326 PyObject *resultobj = 0;
45327 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45328 int result;
45329 void *argp1 = 0 ;
45330 int res1 = 0 ;
45331 PyObject *swig_obj[1] ;
45332
45333 if (!args) SWIG_fail;
45334 swig_obj[0] = args;
45335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45336 if (!SWIG_IsOK(res1)) {
45337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45338 }
45339 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45340 {
45341 PyThreadState* __tstate = wxPyBeginAllowThreads();
45342 result = (int)(arg1)->GetProportion();
45343 wxPyEndAllowThreads(__tstate);
45344 if (PyErr_Occurred()) SWIG_fail;
45345 }
45346 resultobj = SWIG_From_int(static_cast< int >(result));
45347 return resultobj;
45348 fail:
45349 return NULL;
45350 }
45351
45352
45353 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45354 PyObject *resultobj = 0;
45355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45356 int arg2 ;
45357 void *argp1 = 0 ;
45358 int res1 = 0 ;
45359 int val2 ;
45360 int ecode2 = 0 ;
45361 PyObject * obj0 = 0 ;
45362 PyObject * obj1 = 0 ;
45363 char * kwnames[] = {
45364 (char *) "self",(char *) "flag", NULL
45365 };
45366
45367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45369 if (!SWIG_IsOK(res1)) {
45370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45371 }
45372 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45373 ecode2 = SWIG_AsVal_int(obj1, &val2);
45374 if (!SWIG_IsOK(ecode2)) {
45375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45376 }
45377 arg2 = static_cast< int >(val2);
45378 {
45379 PyThreadState* __tstate = wxPyBeginAllowThreads();
45380 (arg1)->SetFlag(arg2);
45381 wxPyEndAllowThreads(__tstate);
45382 if (PyErr_Occurred()) SWIG_fail;
45383 }
45384 resultobj = SWIG_Py_Void();
45385 return resultobj;
45386 fail:
45387 return NULL;
45388 }
45389
45390
45391 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45392 PyObject *resultobj = 0;
45393 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45394 int result;
45395 void *argp1 = 0 ;
45396 int res1 = 0 ;
45397 PyObject *swig_obj[1] ;
45398
45399 if (!args) SWIG_fail;
45400 swig_obj[0] = args;
45401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45402 if (!SWIG_IsOK(res1)) {
45403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45404 }
45405 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45406 {
45407 PyThreadState* __tstate = wxPyBeginAllowThreads();
45408 result = (int)(arg1)->GetFlag();
45409 wxPyEndAllowThreads(__tstate);
45410 if (PyErr_Occurred()) SWIG_fail;
45411 }
45412 resultobj = SWIG_From_int(static_cast< int >(result));
45413 return resultobj;
45414 fail:
45415 return NULL;
45416 }
45417
45418
45419 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45420 PyObject *resultobj = 0;
45421 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45422 int arg2 ;
45423 void *argp1 = 0 ;
45424 int res1 = 0 ;
45425 int val2 ;
45426 int ecode2 = 0 ;
45427 PyObject * obj0 = 0 ;
45428 PyObject * obj1 = 0 ;
45429 char * kwnames[] = {
45430 (char *) "self",(char *) "border", NULL
45431 };
45432
45433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45435 if (!SWIG_IsOK(res1)) {
45436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45437 }
45438 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45439 ecode2 = SWIG_AsVal_int(obj1, &val2);
45440 if (!SWIG_IsOK(ecode2)) {
45441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45442 }
45443 arg2 = static_cast< int >(val2);
45444 {
45445 PyThreadState* __tstate = wxPyBeginAllowThreads();
45446 (arg1)->SetBorder(arg2);
45447 wxPyEndAllowThreads(__tstate);
45448 if (PyErr_Occurred()) SWIG_fail;
45449 }
45450 resultobj = SWIG_Py_Void();
45451 return resultobj;
45452 fail:
45453 return NULL;
45454 }
45455
45456
45457 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45458 PyObject *resultobj = 0;
45459 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45460 int result;
45461 void *argp1 = 0 ;
45462 int res1 = 0 ;
45463 PyObject *swig_obj[1] ;
45464
45465 if (!args) SWIG_fail;
45466 swig_obj[0] = args;
45467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45468 if (!SWIG_IsOK(res1)) {
45469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45470 }
45471 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45472 {
45473 PyThreadState* __tstate = wxPyBeginAllowThreads();
45474 result = (int)(arg1)->GetBorder();
45475 wxPyEndAllowThreads(__tstate);
45476 if (PyErr_Occurred()) SWIG_fail;
45477 }
45478 resultobj = SWIG_From_int(static_cast< int >(result));
45479 return resultobj;
45480 fail:
45481 return NULL;
45482 }
45483
45484
45485 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45486 PyObject *resultobj = 0;
45487 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45488 wxWindow *result = 0 ;
45489 void *argp1 = 0 ;
45490 int res1 = 0 ;
45491 PyObject *swig_obj[1] ;
45492
45493 if (!args) SWIG_fail;
45494 swig_obj[0] = args;
45495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45496 if (!SWIG_IsOK(res1)) {
45497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45498 }
45499 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45500 {
45501 PyThreadState* __tstate = wxPyBeginAllowThreads();
45502 result = (wxWindow *)(arg1)->GetWindow();
45503 wxPyEndAllowThreads(__tstate);
45504 if (PyErr_Occurred()) SWIG_fail;
45505 }
45506 {
45507 resultobj = wxPyMake_wxObject(result, 0);
45508 }
45509 return resultobj;
45510 fail:
45511 return NULL;
45512 }
45513
45514
45515 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45516 PyObject *resultobj = 0;
45517 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45518 wxWindow *arg2 = (wxWindow *) 0 ;
45519 void *argp1 = 0 ;
45520 int res1 = 0 ;
45521 void *argp2 = 0 ;
45522 int res2 = 0 ;
45523 PyObject * obj0 = 0 ;
45524 PyObject * obj1 = 0 ;
45525 char * kwnames[] = {
45526 (char *) "self",(char *) "window", NULL
45527 };
45528
45529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45531 if (!SWIG_IsOK(res1)) {
45532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45533 }
45534 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45535 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45536 if (!SWIG_IsOK(res2)) {
45537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45538 }
45539 arg2 = reinterpret_cast< wxWindow * >(argp2);
45540 {
45541 PyThreadState* __tstate = wxPyBeginAllowThreads();
45542 (arg1)->SetWindow(arg2);
45543 wxPyEndAllowThreads(__tstate);
45544 if (PyErr_Occurred()) SWIG_fail;
45545 }
45546 resultobj = SWIG_Py_Void();
45547 return resultobj;
45548 fail:
45549 return NULL;
45550 }
45551
45552
45553 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45554 PyObject *resultobj = 0;
45555 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45556 wxSizer *result = 0 ;
45557 void *argp1 = 0 ;
45558 int res1 = 0 ;
45559 PyObject *swig_obj[1] ;
45560
45561 if (!args) SWIG_fail;
45562 swig_obj[0] = args;
45563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45564 if (!SWIG_IsOK(res1)) {
45565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45566 }
45567 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45568 {
45569 PyThreadState* __tstate = wxPyBeginAllowThreads();
45570 result = (wxSizer *)(arg1)->GetSizer();
45571 wxPyEndAllowThreads(__tstate);
45572 if (PyErr_Occurred()) SWIG_fail;
45573 }
45574 {
45575 resultobj = wxPyMake_wxObject(result, (bool)0);
45576 }
45577 return resultobj;
45578 fail:
45579 return NULL;
45580 }
45581
45582
45583 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45584 PyObject *resultobj = 0;
45585 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45586 wxSizer *arg2 = (wxSizer *) 0 ;
45587 void *argp1 = 0 ;
45588 int res1 = 0 ;
45589 int res2 = 0 ;
45590 PyObject * obj0 = 0 ;
45591 PyObject * obj1 = 0 ;
45592 char * kwnames[] = {
45593 (char *) "self",(char *) "sizer", NULL
45594 };
45595
45596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45598 if (!SWIG_IsOK(res1)) {
45599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45600 }
45601 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45602 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45603 if (!SWIG_IsOK(res2)) {
45604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45605 }
45606 {
45607 PyThreadState* __tstate = wxPyBeginAllowThreads();
45608 (arg1)->SetSizer(arg2);
45609 wxPyEndAllowThreads(__tstate);
45610 if (PyErr_Occurred()) SWIG_fail;
45611 }
45612 resultobj = SWIG_Py_Void();
45613 return resultobj;
45614 fail:
45615 return NULL;
45616 }
45617
45618
45619 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45620 PyObject *resultobj = 0;
45621 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45622 wxSize *result = 0 ;
45623 void *argp1 = 0 ;
45624 int res1 = 0 ;
45625 PyObject *swig_obj[1] ;
45626
45627 if (!args) SWIG_fail;
45628 swig_obj[0] = args;
45629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45630 if (!SWIG_IsOK(res1)) {
45631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45632 }
45633 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45634 {
45635 PyThreadState* __tstate = wxPyBeginAllowThreads();
45636 {
45637 wxSize const &_result_ref = (arg1)->GetSpacer();
45638 result = (wxSize *) &_result_ref;
45639 }
45640 wxPyEndAllowThreads(__tstate);
45641 if (PyErr_Occurred()) SWIG_fail;
45642 }
45643 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45644 return resultobj;
45645 fail:
45646 return NULL;
45647 }
45648
45649
45650 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45651 PyObject *resultobj = 0;
45652 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45653 wxSize *arg2 = 0 ;
45654 void *argp1 = 0 ;
45655 int res1 = 0 ;
45656 wxSize temp2 ;
45657 PyObject * obj0 = 0 ;
45658 PyObject * obj1 = 0 ;
45659 char * kwnames[] = {
45660 (char *) "self",(char *) "size", NULL
45661 };
45662
45663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45665 if (!SWIG_IsOK(res1)) {
45666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45667 }
45668 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45669 {
45670 arg2 = &temp2;
45671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45672 }
45673 {
45674 PyThreadState* __tstate = wxPyBeginAllowThreads();
45675 (arg1)->SetSpacer((wxSize const &)*arg2);
45676 wxPyEndAllowThreads(__tstate);
45677 if (PyErr_Occurred()) SWIG_fail;
45678 }
45679 resultobj = SWIG_Py_Void();
45680 return resultobj;
45681 fail:
45682 return NULL;
45683 }
45684
45685
45686 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45687 PyObject *resultobj = 0;
45688 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45689 bool arg2 ;
45690 void *argp1 = 0 ;
45691 int res1 = 0 ;
45692 bool val2 ;
45693 int ecode2 = 0 ;
45694 PyObject * obj0 = 0 ;
45695 PyObject * obj1 = 0 ;
45696 char * kwnames[] = {
45697 (char *) "self",(char *) "show", NULL
45698 };
45699
45700 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45701 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45702 if (!SWIG_IsOK(res1)) {
45703 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45704 }
45705 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45706 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45707 if (!SWIG_IsOK(ecode2)) {
45708 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45709 }
45710 arg2 = static_cast< bool >(val2);
45711 {
45712 PyThreadState* __tstate = wxPyBeginAllowThreads();
45713 (arg1)->Show(arg2);
45714 wxPyEndAllowThreads(__tstate);
45715 if (PyErr_Occurred()) SWIG_fail;
45716 }
45717 resultobj = SWIG_Py_Void();
45718 return resultobj;
45719 fail:
45720 return NULL;
45721 }
45722
45723
45724 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45725 PyObject *resultobj = 0;
45726 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45727 bool result;
45728 void *argp1 = 0 ;
45729 int res1 = 0 ;
45730 PyObject *swig_obj[1] ;
45731
45732 if (!args) SWIG_fail;
45733 swig_obj[0] = args;
45734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45735 if (!SWIG_IsOK(res1)) {
45736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45737 }
45738 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45739 {
45740 PyThreadState* __tstate = wxPyBeginAllowThreads();
45741 result = (bool)(arg1)->IsShown();
45742 wxPyEndAllowThreads(__tstate);
45743 if (PyErr_Occurred()) SWIG_fail;
45744 }
45745 {
45746 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45747 }
45748 return resultobj;
45749 fail:
45750 return NULL;
45751 }
45752
45753
45754 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45755 PyObject *resultobj = 0;
45756 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45757 wxPoint result;
45758 void *argp1 = 0 ;
45759 int res1 = 0 ;
45760 PyObject *swig_obj[1] ;
45761
45762 if (!args) SWIG_fail;
45763 swig_obj[0] = args;
45764 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45765 if (!SWIG_IsOK(res1)) {
45766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45767 }
45768 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45769 {
45770 PyThreadState* __tstate = wxPyBeginAllowThreads();
45771 result = (arg1)->GetPosition();
45772 wxPyEndAllowThreads(__tstate);
45773 if (PyErr_Occurred()) SWIG_fail;
45774 }
45775 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
45776 return resultobj;
45777 fail:
45778 return NULL;
45779 }
45780
45781
45782 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45783 PyObject *resultobj = 0;
45784 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45785 PyObject *result = 0 ;
45786 void *argp1 = 0 ;
45787 int res1 = 0 ;
45788 PyObject *swig_obj[1] ;
45789
45790 if (!args) SWIG_fail;
45791 swig_obj[0] = args;
45792 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45793 if (!SWIG_IsOK(res1)) {
45794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45795 }
45796 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45797 {
45798 PyThreadState* __tstate = wxPyBeginAllowThreads();
45799 result = (PyObject *)wxSizerItem_GetUserData(arg1);
45800 wxPyEndAllowThreads(__tstate);
45801 if (PyErr_Occurred()) SWIG_fail;
45802 }
45803 resultobj = result;
45804 return resultobj;
45805 fail:
45806 return NULL;
45807 }
45808
45809
45810 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45811 PyObject *resultobj = 0;
45812 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45813 PyObject *arg2 = (PyObject *) 0 ;
45814 void *argp1 = 0 ;
45815 int res1 = 0 ;
45816 PyObject * obj0 = 0 ;
45817 PyObject * obj1 = 0 ;
45818 char * kwnames[] = {
45819 (char *) "self",(char *) "userData", NULL
45820 };
45821
45822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
45823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45824 if (!SWIG_IsOK(res1)) {
45825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45826 }
45827 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45828 arg2 = obj1;
45829 {
45830 PyThreadState* __tstate = wxPyBeginAllowThreads();
45831 wxSizerItem_SetUserData(arg1,arg2);
45832 wxPyEndAllowThreads(__tstate);
45833 if (PyErr_Occurred()) SWIG_fail;
45834 }
45835 resultobj = SWIG_Py_Void();
45836 return resultobj;
45837 fail:
45838 return NULL;
45839 }
45840
45841
45842 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45843 PyObject *obj;
45844 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45845 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
45846 return SWIG_Py_Void();
45847 }
45848
45849 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45850 return SWIG_Python_InitShadowInstance(args);
45851 }
45852
45853 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45854 PyObject *resultobj = 0;
45855 wxSizer *arg1 = (wxSizer *) 0 ;
45856 void *argp1 = 0 ;
45857 int res1 = 0 ;
45858 PyObject *swig_obj[1] ;
45859
45860 if (!args) SWIG_fail;
45861 swig_obj[0] = args;
45862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45863 if (!SWIG_IsOK(res1)) {
45864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45865 }
45866 arg1 = reinterpret_cast< wxSizer * >(argp1);
45867 {
45868 PyThreadState* __tstate = wxPyBeginAllowThreads();
45869 delete arg1;
45870
45871 wxPyEndAllowThreads(__tstate);
45872 if (PyErr_Occurred()) SWIG_fail;
45873 }
45874 resultobj = SWIG_Py_Void();
45875 return resultobj;
45876 fail:
45877 return NULL;
45878 }
45879
45880
45881 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45882 PyObject *resultobj = 0;
45883 wxSizer *arg1 = (wxSizer *) 0 ;
45884 PyObject *arg2 = (PyObject *) 0 ;
45885 void *argp1 = 0 ;
45886 int res1 = 0 ;
45887 PyObject * obj0 = 0 ;
45888 PyObject * obj1 = 0 ;
45889 char * kwnames[] = {
45890 (char *) "self",(char *) "_self", NULL
45891 };
45892
45893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
45894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45895 if (!SWIG_IsOK(res1)) {
45896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
45897 }
45898 arg1 = reinterpret_cast< wxSizer * >(argp1);
45899 arg2 = obj1;
45900 {
45901 PyThreadState* __tstate = wxPyBeginAllowThreads();
45902 wxSizer__setOORInfo(arg1,arg2);
45903 wxPyEndAllowThreads(__tstate);
45904 if (PyErr_Occurred()) SWIG_fail;
45905 }
45906 resultobj = SWIG_Py_Void();
45907 return resultobj;
45908 fail:
45909 return NULL;
45910 }
45911
45912
45913 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45914 PyObject *resultobj = 0;
45915 wxSizer *arg1 = (wxSizer *) 0 ;
45916 PyObject *arg2 = (PyObject *) 0 ;
45917 int arg3 = (int) 0 ;
45918 int arg4 = (int) 0 ;
45919 int arg5 = (int) 0 ;
45920 PyObject *arg6 = (PyObject *) NULL ;
45921 wxSizerItem *result = 0 ;
45922 void *argp1 = 0 ;
45923 int res1 = 0 ;
45924 int val3 ;
45925 int ecode3 = 0 ;
45926 int val4 ;
45927 int ecode4 = 0 ;
45928 int val5 ;
45929 int ecode5 = 0 ;
45930 PyObject * obj0 = 0 ;
45931 PyObject * obj1 = 0 ;
45932 PyObject * obj2 = 0 ;
45933 PyObject * obj3 = 0 ;
45934 PyObject * obj4 = 0 ;
45935 PyObject * obj5 = 0 ;
45936 char * kwnames[] = {
45937 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45938 };
45939
45940 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45941 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
45942 if (!SWIG_IsOK(res1)) {
45943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
45944 }
45945 arg1 = reinterpret_cast< wxSizer * >(argp1);
45946 arg2 = obj1;
45947 if (obj2) {
45948 ecode3 = SWIG_AsVal_int(obj2, &val3);
45949 if (!SWIG_IsOK(ecode3)) {
45950 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
45951 }
45952 arg3 = static_cast< int >(val3);
45953 }
45954 if (obj3) {
45955 ecode4 = SWIG_AsVal_int(obj3, &val4);
45956 if (!SWIG_IsOK(ecode4)) {
45957 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
45958 }
45959 arg4 = static_cast< int >(val4);
45960 }
45961 if (obj4) {
45962 ecode5 = SWIG_AsVal_int(obj4, &val5);
45963 if (!SWIG_IsOK(ecode5)) {
45964 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
45965 }
45966 arg5 = static_cast< int >(val5);
45967 }
45968 if (obj5) {
45969 arg6 = obj5;
45970 }
45971 {
45972 PyThreadState* __tstate = wxPyBeginAllowThreads();
45973 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
45974 wxPyEndAllowThreads(__tstate);
45975 if (PyErr_Occurred()) SWIG_fail;
45976 }
45977 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
45978 return resultobj;
45979 fail:
45980 return NULL;
45981 }
45982
45983
45984 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45985 PyObject *resultobj = 0;
45986 wxSizer *arg1 = (wxSizer *) 0 ;
45987 int arg2 ;
45988 PyObject *arg3 = (PyObject *) 0 ;
45989 int arg4 = (int) 0 ;
45990 int arg5 = (int) 0 ;
45991 int arg6 = (int) 0 ;
45992 PyObject *arg7 = (PyObject *) NULL ;
45993 wxSizerItem *result = 0 ;
45994 void *argp1 = 0 ;
45995 int res1 = 0 ;
45996 int val2 ;
45997 int ecode2 = 0 ;
45998 int val4 ;
45999 int ecode4 = 0 ;
46000 int val5 ;
46001 int ecode5 = 0 ;
46002 int val6 ;
46003 int ecode6 = 0 ;
46004 PyObject * obj0 = 0 ;
46005 PyObject * obj1 = 0 ;
46006 PyObject * obj2 = 0 ;
46007 PyObject * obj3 = 0 ;
46008 PyObject * obj4 = 0 ;
46009 PyObject * obj5 = 0 ;
46010 PyObject * obj6 = 0 ;
46011 char * kwnames[] = {
46012 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46013 };
46014
46015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46017 if (!SWIG_IsOK(res1)) {
46018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46019 }
46020 arg1 = reinterpret_cast< wxSizer * >(argp1);
46021 ecode2 = SWIG_AsVal_int(obj1, &val2);
46022 if (!SWIG_IsOK(ecode2)) {
46023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46024 }
46025 arg2 = static_cast< int >(val2);
46026 arg3 = obj2;
46027 if (obj3) {
46028 ecode4 = SWIG_AsVal_int(obj3, &val4);
46029 if (!SWIG_IsOK(ecode4)) {
46030 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46031 }
46032 arg4 = static_cast< int >(val4);
46033 }
46034 if (obj4) {
46035 ecode5 = SWIG_AsVal_int(obj4, &val5);
46036 if (!SWIG_IsOK(ecode5)) {
46037 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46038 }
46039 arg5 = static_cast< int >(val5);
46040 }
46041 if (obj5) {
46042 ecode6 = SWIG_AsVal_int(obj5, &val6);
46043 if (!SWIG_IsOK(ecode6)) {
46044 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46045 }
46046 arg6 = static_cast< int >(val6);
46047 }
46048 if (obj6) {
46049 arg7 = obj6;
46050 }
46051 {
46052 PyThreadState* __tstate = wxPyBeginAllowThreads();
46053 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46054 wxPyEndAllowThreads(__tstate);
46055 if (PyErr_Occurred()) SWIG_fail;
46056 }
46057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46058 return resultobj;
46059 fail:
46060 return NULL;
46061 }
46062
46063
46064 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46065 PyObject *resultobj = 0;
46066 wxSizer *arg1 = (wxSizer *) 0 ;
46067 PyObject *arg2 = (PyObject *) 0 ;
46068 int arg3 = (int) 0 ;
46069 int arg4 = (int) 0 ;
46070 int arg5 = (int) 0 ;
46071 PyObject *arg6 = (PyObject *) NULL ;
46072 wxSizerItem *result = 0 ;
46073 void *argp1 = 0 ;
46074 int res1 = 0 ;
46075 int val3 ;
46076 int ecode3 = 0 ;
46077 int val4 ;
46078 int ecode4 = 0 ;
46079 int val5 ;
46080 int ecode5 = 0 ;
46081 PyObject * obj0 = 0 ;
46082 PyObject * obj1 = 0 ;
46083 PyObject * obj2 = 0 ;
46084 PyObject * obj3 = 0 ;
46085 PyObject * obj4 = 0 ;
46086 PyObject * obj5 = 0 ;
46087 char * kwnames[] = {
46088 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46089 };
46090
46091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46093 if (!SWIG_IsOK(res1)) {
46094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46095 }
46096 arg1 = reinterpret_cast< wxSizer * >(argp1);
46097 arg2 = obj1;
46098 if (obj2) {
46099 ecode3 = SWIG_AsVal_int(obj2, &val3);
46100 if (!SWIG_IsOK(ecode3)) {
46101 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46102 }
46103 arg3 = static_cast< int >(val3);
46104 }
46105 if (obj3) {
46106 ecode4 = SWIG_AsVal_int(obj3, &val4);
46107 if (!SWIG_IsOK(ecode4)) {
46108 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46109 }
46110 arg4 = static_cast< int >(val4);
46111 }
46112 if (obj4) {
46113 ecode5 = SWIG_AsVal_int(obj4, &val5);
46114 if (!SWIG_IsOK(ecode5)) {
46115 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46116 }
46117 arg5 = static_cast< int >(val5);
46118 }
46119 if (obj5) {
46120 arg6 = obj5;
46121 }
46122 {
46123 PyThreadState* __tstate = wxPyBeginAllowThreads();
46124 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46125 wxPyEndAllowThreads(__tstate);
46126 if (PyErr_Occurred()) SWIG_fail;
46127 }
46128 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46129 return resultobj;
46130 fail:
46131 return NULL;
46132 }
46133
46134
46135 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46136 PyObject *resultobj = 0;
46137 wxSizer *arg1 = (wxSizer *) 0 ;
46138 PyObject *arg2 = (PyObject *) 0 ;
46139 bool result;
46140 void *argp1 = 0 ;
46141 int res1 = 0 ;
46142 PyObject * obj0 = 0 ;
46143 PyObject * obj1 = 0 ;
46144 char * kwnames[] = {
46145 (char *) "self",(char *) "item", NULL
46146 };
46147
46148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46150 if (!SWIG_IsOK(res1)) {
46151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46152 }
46153 arg1 = reinterpret_cast< wxSizer * >(argp1);
46154 arg2 = obj1;
46155 {
46156 PyThreadState* __tstate = wxPyBeginAllowThreads();
46157 result = (bool)wxSizer_Remove(arg1,arg2);
46158 wxPyEndAllowThreads(__tstate);
46159 if (PyErr_Occurred()) SWIG_fail;
46160 }
46161 {
46162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46163 }
46164 return resultobj;
46165 fail:
46166 return NULL;
46167 }
46168
46169
46170 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46171 PyObject *resultobj = 0;
46172 wxSizer *arg1 = (wxSizer *) 0 ;
46173 PyObject *arg2 = (PyObject *) 0 ;
46174 bool result;
46175 void *argp1 = 0 ;
46176 int res1 = 0 ;
46177 PyObject * obj0 = 0 ;
46178 PyObject * obj1 = 0 ;
46179 char * kwnames[] = {
46180 (char *) "self",(char *) "item", NULL
46181 };
46182
46183 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46184 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46185 if (!SWIG_IsOK(res1)) {
46186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46187 }
46188 arg1 = reinterpret_cast< wxSizer * >(argp1);
46189 arg2 = obj1;
46190 {
46191 PyThreadState* __tstate = wxPyBeginAllowThreads();
46192 result = (bool)wxSizer_Detach(arg1,arg2);
46193 wxPyEndAllowThreads(__tstate);
46194 if (PyErr_Occurred()) SWIG_fail;
46195 }
46196 {
46197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46198 }
46199 return resultobj;
46200 fail:
46201 return NULL;
46202 }
46203
46204
46205 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46206 PyObject *resultobj = 0;
46207 wxSizer *arg1 = (wxSizer *) 0 ;
46208 PyObject *arg2 = (PyObject *) 0 ;
46209 wxSizerItem *result = 0 ;
46210 void *argp1 = 0 ;
46211 int res1 = 0 ;
46212 PyObject * obj0 = 0 ;
46213 PyObject * obj1 = 0 ;
46214 char * kwnames[] = {
46215 (char *) "self",(char *) "item", NULL
46216 };
46217
46218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46220 if (!SWIG_IsOK(res1)) {
46221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46222 }
46223 arg1 = reinterpret_cast< wxSizer * >(argp1);
46224 arg2 = obj1;
46225 {
46226 PyThreadState* __tstate = wxPyBeginAllowThreads();
46227 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46228 wxPyEndAllowThreads(__tstate);
46229 if (PyErr_Occurred()) SWIG_fail;
46230 }
46231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46232 return resultobj;
46233 fail:
46234 return NULL;
46235 }
46236
46237
46238 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46239 PyObject *resultobj = 0;
46240 wxSizer *arg1 = (wxSizer *) 0 ;
46241 PyObject *arg2 = (PyObject *) 0 ;
46242 wxSize *arg3 = 0 ;
46243 void *argp1 = 0 ;
46244 int res1 = 0 ;
46245 wxSize temp3 ;
46246 PyObject * obj0 = 0 ;
46247 PyObject * obj1 = 0 ;
46248 PyObject * obj2 = 0 ;
46249 char * kwnames[] = {
46250 (char *) "self",(char *) "item",(char *) "size", NULL
46251 };
46252
46253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46255 if (!SWIG_IsOK(res1)) {
46256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46257 }
46258 arg1 = reinterpret_cast< wxSizer * >(argp1);
46259 arg2 = obj1;
46260 {
46261 arg3 = &temp3;
46262 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46263 }
46264 {
46265 PyThreadState* __tstate = wxPyBeginAllowThreads();
46266 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46267 wxPyEndAllowThreads(__tstate);
46268 if (PyErr_Occurred()) SWIG_fail;
46269 }
46270 resultobj = SWIG_Py_Void();
46271 return resultobj;
46272 fail:
46273 return NULL;
46274 }
46275
46276
46277 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46278 PyObject *resultobj = 0;
46279 wxSizer *arg1 = (wxSizer *) 0 ;
46280 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46281 wxSizerItem *result = 0 ;
46282 void *argp1 = 0 ;
46283 int res1 = 0 ;
46284 int res2 = 0 ;
46285 PyObject * obj0 = 0 ;
46286 PyObject * obj1 = 0 ;
46287 char * kwnames[] = {
46288 (char *) "self",(char *) "item", NULL
46289 };
46290
46291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46293 if (!SWIG_IsOK(res1)) {
46294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46295 }
46296 arg1 = reinterpret_cast< wxSizer * >(argp1);
46297 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46298 if (!SWIG_IsOK(res2)) {
46299 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46300 }
46301 {
46302 PyThreadState* __tstate = wxPyBeginAllowThreads();
46303 result = (wxSizerItem *)(arg1)->Add(arg2);
46304 wxPyEndAllowThreads(__tstate);
46305 if (PyErr_Occurred()) SWIG_fail;
46306 }
46307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46308 return resultobj;
46309 fail:
46310 return NULL;
46311 }
46312
46313
46314 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46315 PyObject *resultobj = 0;
46316 wxSizer *arg1 = (wxSizer *) 0 ;
46317 size_t arg2 ;
46318 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46319 wxSizerItem *result = 0 ;
46320 void *argp1 = 0 ;
46321 int res1 = 0 ;
46322 size_t val2 ;
46323 int ecode2 = 0 ;
46324 int res3 = 0 ;
46325 PyObject * obj0 = 0 ;
46326 PyObject * obj1 = 0 ;
46327 PyObject * obj2 = 0 ;
46328 char * kwnames[] = {
46329 (char *) "self",(char *) "index",(char *) "item", NULL
46330 };
46331
46332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46334 if (!SWIG_IsOK(res1)) {
46335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46336 }
46337 arg1 = reinterpret_cast< wxSizer * >(argp1);
46338 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46339 if (!SWIG_IsOK(ecode2)) {
46340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46341 }
46342 arg2 = static_cast< size_t >(val2);
46343 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46344 if (!SWIG_IsOK(res3)) {
46345 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46346 }
46347 {
46348 PyThreadState* __tstate = wxPyBeginAllowThreads();
46349 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46350 wxPyEndAllowThreads(__tstate);
46351 if (PyErr_Occurred()) SWIG_fail;
46352 }
46353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46354 return resultobj;
46355 fail:
46356 return NULL;
46357 }
46358
46359
46360 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46361 PyObject *resultobj = 0;
46362 wxSizer *arg1 = (wxSizer *) 0 ;
46363 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46364 wxSizerItem *result = 0 ;
46365 void *argp1 = 0 ;
46366 int res1 = 0 ;
46367 int res2 = 0 ;
46368 PyObject * obj0 = 0 ;
46369 PyObject * obj1 = 0 ;
46370 char * kwnames[] = {
46371 (char *) "self",(char *) "item", NULL
46372 };
46373
46374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46376 if (!SWIG_IsOK(res1)) {
46377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46378 }
46379 arg1 = reinterpret_cast< wxSizer * >(argp1);
46380 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46381 if (!SWIG_IsOK(res2)) {
46382 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46383 }
46384 {
46385 PyThreadState* __tstate = wxPyBeginAllowThreads();
46386 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46387 wxPyEndAllowThreads(__tstate);
46388 if (PyErr_Occurred()) SWIG_fail;
46389 }
46390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46391 return resultobj;
46392 fail:
46393 return NULL;
46394 }
46395
46396
46397 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46398 PyObject *resultobj = 0;
46399 wxSizer *arg1 = (wxSizer *) 0 ;
46400 int arg2 ;
46401 int arg3 ;
46402 int arg4 ;
46403 int arg5 ;
46404 void *argp1 = 0 ;
46405 int res1 = 0 ;
46406 int val2 ;
46407 int ecode2 = 0 ;
46408 int val3 ;
46409 int ecode3 = 0 ;
46410 int val4 ;
46411 int ecode4 = 0 ;
46412 int val5 ;
46413 int ecode5 = 0 ;
46414 PyObject * obj0 = 0 ;
46415 PyObject * obj1 = 0 ;
46416 PyObject * obj2 = 0 ;
46417 PyObject * obj3 = 0 ;
46418 PyObject * obj4 = 0 ;
46419 char * kwnames[] = {
46420 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46421 };
46422
46423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46425 if (!SWIG_IsOK(res1)) {
46426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46427 }
46428 arg1 = reinterpret_cast< wxSizer * >(argp1);
46429 ecode2 = SWIG_AsVal_int(obj1, &val2);
46430 if (!SWIG_IsOK(ecode2)) {
46431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46432 }
46433 arg2 = static_cast< int >(val2);
46434 ecode3 = SWIG_AsVal_int(obj2, &val3);
46435 if (!SWIG_IsOK(ecode3)) {
46436 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46437 }
46438 arg3 = static_cast< int >(val3);
46439 ecode4 = SWIG_AsVal_int(obj3, &val4);
46440 if (!SWIG_IsOK(ecode4)) {
46441 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46442 }
46443 arg4 = static_cast< int >(val4);
46444 ecode5 = SWIG_AsVal_int(obj4, &val5);
46445 if (!SWIG_IsOK(ecode5)) {
46446 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46447 }
46448 arg5 = static_cast< int >(val5);
46449 {
46450 PyThreadState* __tstate = wxPyBeginAllowThreads();
46451 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46452 wxPyEndAllowThreads(__tstate);
46453 if (PyErr_Occurred()) SWIG_fail;
46454 }
46455 resultobj = SWIG_Py_Void();
46456 return resultobj;
46457 fail:
46458 return NULL;
46459 }
46460
46461
46462 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46463 PyObject *resultobj = 0;
46464 wxSizer *arg1 = (wxSizer *) 0 ;
46465 wxSize *arg2 = 0 ;
46466 void *argp1 = 0 ;
46467 int res1 = 0 ;
46468 wxSize temp2 ;
46469 PyObject * obj0 = 0 ;
46470 PyObject * obj1 = 0 ;
46471 char * kwnames[] = {
46472 (char *) "self",(char *) "size", NULL
46473 };
46474
46475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46477 if (!SWIG_IsOK(res1)) {
46478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46479 }
46480 arg1 = reinterpret_cast< wxSizer * >(argp1);
46481 {
46482 arg2 = &temp2;
46483 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46484 }
46485 {
46486 PyThreadState* __tstate = wxPyBeginAllowThreads();
46487 (arg1)->SetMinSize((wxSize const &)*arg2);
46488 wxPyEndAllowThreads(__tstate);
46489 if (PyErr_Occurred()) SWIG_fail;
46490 }
46491 resultobj = SWIG_Py_Void();
46492 return resultobj;
46493 fail:
46494 return NULL;
46495 }
46496
46497
46498 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46499 PyObject *resultobj = 0;
46500 wxSizer *arg1 = (wxSizer *) 0 ;
46501 wxSize result;
46502 void *argp1 = 0 ;
46503 int res1 = 0 ;
46504 PyObject *swig_obj[1] ;
46505
46506 if (!args) SWIG_fail;
46507 swig_obj[0] = args;
46508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46509 if (!SWIG_IsOK(res1)) {
46510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46511 }
46512 arg1 = reinterpret_cast< wxSizer * >(argp1);
46513 {
46514 PyThreadState* __tstate = wxPyBeginAllowThreads();
46515 result = (arg1)->GetSize();
46516 wxPyEndAllowThreads(__tstate);
46517 if (PyErr_Occurred()) SWIG_fail;
46518 }
46519 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46520 return resultobj;
46521 fail:
46522 return NULL;
46523 }
46524
46525
46526 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46527 PyObject *resultobj = 0;
46528 wxSizer *arg1 = (wxSizer *) 0 ;
46529 wxPoint result;
46530 void *argp1 = 0 ;
46531 int res1 = 0 ;
46532 PyObject *swig_obj[1] ;
46533
46534 if (!args) SWIG_fail;
46535 swig_obj[0] = args;
46536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46537 if (!SWIG_IsOK(res1)) {
46538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46539 }
46540 arg1 = reinterpret_cast< wxSizer * >(argp1);
46541 {
46542 PyThreadState* __tstate = wxPyBeginAllowThreads();
46543 result = (arg1)->GetPosition();
46544 wxPyEndAllowThreads(__tstate);
46545 if (PyErr_Occurred()) SWIG_fail;
46546 }
46547 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46548 return resultobj;
46549 fail:
46550 return NULL;
46551 }
46552
46553
46554 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46555 PyObject *resultobj = 0;
46556 wxSizer *arg1 = (wxSizer *) 0 ;
46557 wxSize result;
46558 void *argp1 = 0 ;
46559 int res1 = 0 ;
46560 PyObject *swig_obj[1] ;
46561
46562 if (!args) SWIG_fail;
46563 swig_obj[0] = args;
46564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46565 if (!SWIG_IsOK(res1)) {
46566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46567 }
46568 arg1 = reinterpret_cast< wxSizer * >(argp1);
46569 {
46570 PyThreadState* __tstate = wxPyBeginAllowThreads();
46571 result = (arg1)->GetMinSize();
46572 wxPyEndAllowThreads(__tstate);
46573 if (PyErr_Occurred()) SWIG_fail;
46574 }
46575 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46576 return resultobj;
46577 fail:
46578 return NULL;
46579 }
46580
46581
46582 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46583 PyObject *resultobj = 0;
46584 wxSizer *arg1 = (wxSizer *) 0 ;
46585 void *argp1 = 0 ;
46586 int res1 = 0 ;
46587 PyObject *swig_obj[1] ;
46588
46589 if (!args) SWIG_fail;
46590 swig_obj[0] = args;
46591 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46592 if (!SWIG_IsOK(res1)) {
46593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46594 }
46595 arg1 = reinterpret_cast< wxSizer * >(argp1);
46596 {
46597 PyThreadState* __tstate = wxPyBeginAllowThreads();
46598 (arg1)->RecalcSizes();
46599 wxPyEndAllowThreads(__tstate);
46600 if (PyErr_Occurred()) SWIG_fail;
46601 }
46602 resultobj = SWIG_Py_Void();
46603 return resultobj;
46604 fail:
46605 return NULL;
46606 }
46607
46608
46609 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46610 PyObject *resultobj = 0;
46611 wxSizer *arg1 = (wxSizer *) 0 ;
46612 wxSize result;
46613 void *argp1 = 0 ;
46614 int res1 = 0 ;
46615 PyObject *swig_obj[1] ;
46616
46617 if (!args) SWIG_fail;
46618 swig_obj[0] = args;
46619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46620 if (!SWIG_IsOK(res1)) {
46621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46622 }
46623 arg1 = reinterpret_cast< wxSizer * >(argp1);
46624 {
46625 PyThreadState* __tstate = wxPyBeginAllowThreads();
46626 result = (arg1)->CalcMin();
46627 wxPyEndAllowThreads(__tstate);
46628 if (PyErr_Occurred()) SWIG_fail;
46629 }
46630 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46631 return resultobj;
46632 fail:
46633 return NULL;
46634 }
46635
46636
46637 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46638 PyObject *resultobj = 0;
46639 wxSizer *arg1 = (wxSizer *) 0 ;
46640 void *argp1 = 0 ;
46641 int res1 = 0 ;
46642 PyObject *swig_obj[1] ;
46643
46644 if (!args) SWIG_fail;
46645 swig_obj[0] = args;
46646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46647 if (!SWIG_IsOK(res1)) {
46648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46649 }
46650 arg1 = reinterpret_cast< wxSizer * >(argp1);
46651 {
46652 PyThreadState* __tstate = wxPyBeginAllowThreads();
46653 (arg1)->Layout();
46654 wxPyEndAllowThreads(__tstate);
46655 if (PyErr_Occurred()) SWIG_fail;
46656 }
46657 resultobj = SWIG_Py_Void();
46658 return resultobj;
46659 fail:
46660 return NULL;
46661 }
46662
46663
46664 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46665 PyObject *resultobj = 0;
46666 wxSizer *arg1 = (wxSizer *) 0 ;
46667 wxWindow *arg2 = (wxWindow *) 0 ;
46668 wxSize result;
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 *) "window", NULL
46677 };
46678
46679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46681 if (!SWIG_IsOK(res1)) {
46682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46683 }
46684 arg1 = reinterpret_cast< wxSizer * >(argp1);
46685 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46686 if (!SWIG_IsOK(res2)) {
46687 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46688 }
46689 arg2 = reinterpret_cast< wxWindow * >(argp2);
46690 {
46691 PyThreadState* __tstate = wxPyBeginAllowThreads();
46692 result = (arg1)->Fit(arg2);
46693 wxPyEndAllowThreads(__tstate);
46694 if (PyErr_Occurred()) SWIG_fail;
46695 }
46696 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46697 return resultobj;
46698 fail:
46699 return NULL;
46700 }
46701
46702
46703 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46704 PyObject *resultobj = 0;
46705 wxSizer *arg1 = (wxSizer *) 0 ;
46706 wxWindow *arg2 = (wxWindow *) 0 ;
46707 void *argp1 = 0 ;
46708 int res1 = 0 ;
46709 void *argp2 = 0 ;
46710 int res2 = 0 ;
46711 PyObject * obj0 = 0 ;
46712 PyObject * obj1 = 0 ;
46713 char * kwnames[] = {
46714 (char *) "self",(char *) "window", NULL
46715 };
46716
46717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46719 if (!SWIG_IsOK(res1)) {
46720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46721 }
46722 arg1 = reinterpret_cast< wxSizer * >(argp1);
46723 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46724 if (!SWIG_IsOK(res2)) {
46725 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46726 }
46727 arg2 = reinterpret_cast< wxWindow * >(argp2);
46728 {
46729 PyThreadState* __tstate = wxPyBeginAllowThreads();
46730 (arg1)->FitInside(arg2);
46731 wxPyEndAllowThreads(__tstate);
46732 if (PyErr_Occurred()) SWIG_fail;
46733 }
46734 resultobj = SWIG_Py_Void();
46735 return resultobj;
46736 fail:
46737 return NULL;
46738 }
46739
46740
46741 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46742 PyObject *resultobj = 0;
46743 wxSizer *arg1 = (wxSizer *) 0 ;
46744 wxWindow *arg2 = (wxWindow *) 0 ;
46745 void *argp1 = 0 ;
46746 int res1 = 0 ;
46747 void *argp2 = 0 ;
46748 int res2 = 0 ;
46749 PyObject * obj0 = 0 ;
46750 PyObject * obj1 = 0 ;
46751 char * kwnames[] = {
46752 (char *) "self",(char *) "window", NULL
46753 };
46754
46755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46757 if (!SWIG_IsOK(res1)) {
46758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46759 }
46760 arg1 = reinterpret_cast< wxSizer * >(argp1);
46761 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46762 if (!SWIG_IsOK(res2)) {
46763 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46764 }
46765 arg2 = reinterpret_cast< wxWindow * >(argp2);
46766 {
46767 PyThreadState* __tstate = wxPyBeginAllowThreads();
46768 (arg1)->SetSizeHints(arg2);
46769 wxPyEndAllowThreads(__tstate);
46770 if (PyErr_Occurred()) SWIG_fail;
46771 }
46772 resultobj = SWIG_Py_Void();
46773 return resultobj;
46774 fail:
46775 return NULL;
46776 }
46777
46778
46779 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46780 PyObject *resultobj = 0;
46781 wxSizer *arg1 = (wxSizer *) 0 ;
46782 wxWindow *arg2 = (wxWindow *) 0 ;
46783 void *argp1 = 0 ;
46784 int res1 = 0 ;
46785 void *argp2 = 0 ;
46786 int res2 = 0 ;
46787 PyObject * obj0 = 0 ;
46788 PyObject * obj1 = 0 ;
46789 char * kwnames[] = {
46790 (char *) "self",(char *) "window", NULL
46791 };
46792
46793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46795 if (!SWIG_IsOK(res1)) {
46796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46797 }
46798 arg1 = reinterpret_cast< wxSizer * >(argp1);
46799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46800 if (!SWIG_IsOK(res2)) {
46801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
46802 }
46803 arg2 = reinterpret_cast< wxWindow * >(argp2);
46804 {
46805 PyThreadState* __tstate = wxPyBeginAllowThreads();
46806 (arg1)->SetVirtualSizeHints(arg2);
46807 wxPyEndAllowThreads(__tstate);
46808 if (PyErr_Occurred()) SWIG_fail;
46809 }
46810 resultobj = SWIG_Py_Void();
46811 return resultobj;
46812 fail:
46813 return NULL;
46814 }
46815
46816
46817 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46818 PyObject *resultobj = 0;
46819 wxSizer *arg1 = (wxSizer *) 0 ;
46820 bool arg2 = (bool) false ;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 bool val2 ;
46824 int ecode2 = 0 ;
46825 PyObject * obj0 = 0 ;
46826 PyObject * obj1 = 0 ;
46827 char * kwnames[] = {
46828 (char *) "self",(char *) "deleteWindows", NULL
46829 };
46830
46831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
46832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46833 if (!SWIG_IsOK(res1)) {
46834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
46835 }
46836 arg1 = reinterpret_cast< wxSizer * >(argp1);
46837 if (obj1) {
46838 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46839 if (!SWIG_IsOK(ecode2)) {
46840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
46841 }
46842 arg2 = static_cast< bool >(val2);
46843 }
46844 {
46845 PyThreadState* __tstate = wxPyBeginAllowThreads();
46846 (arg1)->Clear(arg2);
46847 wxPyEndAllowThreads(__tstate);
46848 if (PyErr_Occurred()) SWIG_fail;
46849 }
46850 resultobj = SWIG_Py_Void();
46851 return resultobj;
46852 fail:
46853 return NULL;
46854 }
46855
46856
46857 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46858 PyObject *resultobj = 0;
46859 wxSizer *arg1 = (wxSizer *) 0 ;
46860 void *argp1 = 0 ;
46861 int res1 = 0 ;
46862 PyObject *swig_obj[1] ;
46863
46864 if (!args) SWIG_fail;
46865 swig_obj[0] = args;
46866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46867 if (!SWIG_IsOK(res1)) {
46868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
46869 }
46870 arg1 = reinterpret_cast< wxSizer * >(argp1);
46871 {
46872 PyThreadState* __tstate = wxPyBeginAllowThreads();
46873 (arg1)->DeleteWindows();
46874 wxPyEndAllowThreads(__tstate);
46875 if (PyErr_Occurred()) SWIG_fail;
46876 }
46877 resultobj = SWIG_Py_Void();
46878 return resultobj;
46879 fail:
46880 return NULL;
46881 }
46882
46883
46884 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46885 PyObject *resultobj = 0;
46886 wxSizer *arg1 = (wxSizer *) 0 ;
46887 PyObject *result = 0 ;
46888 void *argp1 = 0 ;
46889 int res1 = 0 ;
46890 PyObject *swig_obj[1] ;
46891
46892 if (!args) SWIG_fail;
46893 swig_obj[0] = args;
46894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46895 if (!SWIG_IsOK(res1)) {
46896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
46897 }
46898 arg1 = reinterpret_cast< wxSizer * >(argp1);
46899 {
46900 PyThreadState* __tstate = wxPyBeginAllowThreads();
46901 result = (PyObject *)wxSizer_GetChildren(arg1);
46902 wxPyEndAllowThreads(__tstate);
46903 if (PyErr_Occurred()) SWIG_fail;
46904 }
46905 resultobj = result;
46906 return resultobj;
46907 fail:
46908 return NULL;
46909 }
46910
46911
46912 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46913 PyObject *resultobj = 0;
46914 wxSizer *arg1 = (wxSizer *) 0 ;
46915 PyObject *arg2 = (PyObject *) 0 ;
46916 bool arg3 = (bool) true ;
46917 bool arg4 = (bool) false ;
46918 bool result;
46919 void *argp1 = 0 ;
46920 int res1 = 0 ;
46921 bool val3 ;
46922 int ecode3 = 0 ;
46923 bool val4 ;
46924 int ecode4 = 0 ;
46925 PyObject * obj0 = 0 ;
46926 PyObject * obj1 = 0 ;
46927 PyObject * obj2 = 0 ;
46928 PyObject * obj3 = 0 ;
46929 char * kwnames[] = {
46930 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
46931 };
46932
46933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
46934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46935 if (!SWIG_IsOK(res1)) {
46936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
46937 }
46938 arg1 = reinterpret_cast< wxSizer * >(argp1);
46939 arg2 = obj1;
46940 if (obj2) {
46941 ecode3 = SWIG_AsVal_bool(obj2, &val3);
46942 if (!SWIG_IsOK(ecode3)) {
46943 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
46944 }
46945 arg3 = static_cast< bool >(val3);
46946 }
46947 if (obj3) {
46948 ecode4 = SWIG_AsVal_bool(obj3, &val4);
46949 if (!SWIG_IsOK(ecode4)) {
46950 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
46951 }
46952 arg4 = static_cast< bool >(val4);
46953 }
46954 {
46955 PyThreadState* __tstate = wxPyBeginAllowThreads();
46956 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
46957 wxPyEndAllowThreads(__tstate);
46958 if (PyErr_Occurred()) SWIG_fail;
46959 }
46960 {
46961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46962 }
46963 return resultobj;
46964 fail:
46965 return NULL;
46966 }
46967
46968
46969 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46970 PyObject *resultobj = 0;
46971 wxSizer *arg1 = (wxSizer *) 0 ;
46972 PyObject *arg2 = (PyObject *) 0 ;
46973 bool result;
46974 void *argp1 = 0 ;
46975 int res1 = 0 ;
46976 PyObject * obj0 = 0 ;
46977 PyObject * obj1 = 0 ;
46978 char * kwnames[] = {
46979 (char *) "self",(char *) "item", NULL
46980 };
46981
46982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
46983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46984 if (!SWIG_IsOK(res1)) {
46985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
46986 }
46987 arg1 = reinterpret_cast< wxSizer * >(argp1);
46988 arg2 = obj1;
46989 {
46990 PyThreadState* __tstate = wxPyBeginAllowThreads();
46991 result = (bool)wxSizer_IsShown(arg1,arg2);
46992 wxPyEndAllowThreads(__tstate);
46993 if (PyErr_Occurred()) SWIG_fail;
46994 }
46995 {
46996 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46997 }
46998 return resultobj;
46999 fail:
47000 return NULL;
47001 }
47002
47003
47004 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47005 PyObject *resultobj = 0;
47006 wxSizer *arg1 = (wxSizer *) 0 ;
47007 bool arg2 ;
47008 void *argp1 = 0 ;
47009 int res1 = 0 ;
47010 bool val2 ;
47011 int ecode2 = 0 ;
47012 PyObject * obj0 = 0 ;
47013 PyObject * obj1 = 0 ;
47014 char * kwnames[] = {
47015 (char *) "self",(char *) "show", NULL
47016 };
47017
47018 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47020 if (!SWIG_IsOK(res1)) {
47021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47022 }
47023 arg1 = reinterpret_cast< wxSizer * >(argp1);
47024 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47025 if (!SWIG_IsOK(ecode2)) {
47026 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47027 }
47028 arg2 = static_cast< bool >(val2);
47029 {
47030 PyThreadState* __tstate = wxPyBeginAllowThreads();
47031 (arg1)->ShowItems(arg2);
47032 wxPyEndAllowThreads(__tstate);
47033 if (PyErr_Occurred()) SWIG_fail;
47034 }
47035 resultobj = SWIG_Py_Void();
47036 return resultobj;
47037 fail:
47038 return NULL;
47039 }
47040
47041
47042 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47043 PyObject *obj;
47044 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47045 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47046 return SWIG_Py_Void();
47047 }
47048
47049 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47050 PyObject *resultobj = 0;
47051 wxPySizer *result = 0 ;
47052
47053 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47054 {
47055 PyThreadState* __tstate = wxPyBeginAllowThreads();
47056 result = (wxPySizer *)new wxPySizer();
47057 wxPyEndAllowThreads(__tstate);
47058 if (PyErr_Occurred()) SWIG_fail;
47059 }
47060 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47061 return resultobj;
47062 fail:
47063 return NULL;
47064 }
47065
47066
47067 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47068 PyObject *resultobj = 0;
47069 wxPySizer *arg1 = (wxPySizer *) 0 ;
47070 PyObject *arg2 = (PyObject *) 0 ;
47071 PyObject *arg3 = (PyObject *) 0 ;
47072 void *argp1 = 0 ;
47073 int res1 = 0 ;
47074 PyObject * obj0 = 0 ;
47075 PyObject * obj1 = 0 ;
47076 PyObject * obj2 = 0 ;
47077 char * kwnames[] = {
47078 (char *) "self",(char *) "self",(char *) "_class", NULL
47079 };
47080
47081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47083 if (!SWIG_IsOK(res1)) {
47084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47085 }
47086 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47087 arg2 = obj1;
47088 arg3 = obj2;
47089 {
47090 PyThreadState* __tstate = wxPyBeginAllowThreads();
47091 (arg1)->_setCallbackInfo(arg2,arg3);
47092 wxPyEndAllowThreads(__tstate);
47093 if (PyErr_Occurred()) SWIG_fail;
47094 }
47095 resultobj = SWIG_Py_Void();
47096 return resultobj;
47097 fail:
47098 return NULL;
47099 }
47100
47101
47102 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47103 PyObject *obj;
47104 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47105 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47106 return SWIG_Py_Void();
47107 }
47108
47109 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47110 return SWIG_Python_InitShadowInstance(args);
47111 }
47112
47113 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47114 PyObject *resultobj = 0;
47115 int arg1 = (int) wxHORIZONTAL ;
47116 wxBoxSizer *result = 0 ;
47117 int val1 ;
47118 int ecode1 = 0 ;
47119 PyObject * obj0 = 0 ;
47120 char * kwnames[] = {
47121 (char *) "orient", NULL
47122 };
47123
47124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47125 if (obj0) {
47126 ecode1 = SWIG_AsVal_int(obj0, &val1);
47127 if (!SWIG_IsOK(ecode1)) {
47128 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47129 }
47130 arg1 = static_cast< int >(val1);
47131 }
47132 {
47133 PyThreadState* __tstate = wxPyBeginAllowThreads();
47134 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47135 wxPyEndAllowThreads(__tstate);
47136 if (PyErr_Occurred()) SWIG_fail;
47137 }
47138 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47139 return resultobj;
47140 fail:
47141 return NULL;
47142 }
47143
47144
47145 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47146 PyObject *resultobj = 0;
47147 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47148 int result;
47149 void *argp1 = 0 ;
47150 int res1 = 0 ;
47151 PyObject *swig_obj[1] ;
47152
47153 if (!args) SWIG_fail;
47154 swig_obj[0] = args;
47155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47156 if (!SWIG_IsOK(res1)) {
47157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47158 }
47159 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47160 {
47161 PyThreadState* __tstate = wxPyBeginAllowThreads();
47162 result = (int)(arg1)->GetOrientation();
47163 wxPyEndAllowThreads(__tstate);
47164 if (PyErr_Occurred()) SWIG_fail;
47165 }
47166 resultobj = SWIG_From_int(static_cast< int >(result));
47167 return resultobj;
47168 fail:
47169 return NULL;
47170 }
47171
47172
47173 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47174 PyObject *resultobj = 0;
47175 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47176 int arg2 ;
47177 void *argp1 = 0 ;
47178 int res1 = 0 ;
47179 int val2 ;
47180 int ecode2 = 0 ;
47181 PyObject * obj0 = 0 ;
47182 PyObject * obj1 = 0 ;
47183 char * kwnames[] = {
47184 (char *) "self",(char *) "orient", NULL
47185 };
47186
47187 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47188 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47189 if (!SWIG_IsOK(res1)) {
47190 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47191 }
47192 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47193 ecode2 = SWIG_AsVal_int(obj1, &val2);
47194 if (!SWIG_IsOK(ecode2)) {
47195 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47196 }
47197 arg2 = static_cast< int >(val2);
47198 {
47199 PyThreadState* __tstate = wxPyBeginAllowThreads();
47200 (arg1)->SetOrientation(arg2);
47201 wxPyEndAllowThreads(__tstate);
47202 if (PyErr_Occurred()) SWIG_fail;
47203 }
47204 resultobj = SWIG_Py_Void();
47205 return resultobj;
47206 fail:
47207 return NULL;
47208 }
47209
47210
47211 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47212 PyObject *obj;
47213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47214 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47215 return SWIG_Py_Void();
47216 }
47217
47218 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47219 return SWIG_Python_InitShadowInstance(args);
47220 }
47221
47222 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47223 PyObject *resultobj = 0;
47224 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47225 int arg2 = (int) wxHORIZONTAL ;
47226 wxStaticBoxSizer *result = 0 ;
47227 void *argp1 = 0 ;
47228 int res1 = 0 ;
47229 int val2 ;
47230 int ecode2 = 0 ;
47231 PyObject * obj0 = 0 ;
47232 PyObject * obj1 = 0 ;
47233 char * kwnames[] = {
47234 (char *) "box",(char *) "orient", NULL
47235 };
47236
47237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47239 if (!SWIG_IsOK(res1)) {
47240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47241 }
47242 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47243 if (obj1) {
47244 ecode2 = SWIG_AsVal_int(obj1, &val2);
47245 if (!SWIG_IsOK(ecode2)) {
47246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47247 }
47248 arg2 = static_cast< int >(val2);
47249 }
47250 {
47251 PyThreadState* __tstate = wxPyBeginAllowThreads();
47252 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47253 wxPyEndAllowThreads(__tstate);
47254 if (PyErr_Occurred()) SWIG_fail;
47255 }
47256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47257 return resultobj;
47258 fail:
47259 return NULL;
47260 }
47261
47262
47263 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47264 PyObject *resultobj = 0;
47265 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47266 wxStaticBox *result = 0 ;
47267 void *argp1 = 0 ;
47268 int res1 = 0 ;
47269 PyObject *swig_obj[1] ;
47270
47271 if (!args) SWIG_fail;
47272 swig_obj[0] = args;
47273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47274 if (!SWIG_IsOK(res1)) {
47275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47276 }
47277 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47278 {
47279 PyThreadState* __tstate = wxPyBeginAllowThreads();
47280 result = (wxStaticBox *)(arg1)->GetStaticBox();
47281 wxPyEndAllowThreads(__tstate);
47282 if (PyErr_Occurred()) SWIG_fail;
47283 }
47284 {
47285 resultobj = wxPyMake_wxObject(result, (bool)0);
47286 }
47287 return resultobj;
47288 fail:
47289 return NULL;
47290 }
47291
47292
47293 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47294 PyObject *obj;
47295 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47296 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47297 return SWIG_Py_Void();
47298 }
47299
47300 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47301 return SWIG_Python_InitShadowInstance(args);
47302 }
47303
47304 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47305 PyObject *resultobj = 0;
47306 int arg1 = (int) 1 ;
47307 int arg2 = (int) 0 ;
47308 int arg3 = (int) 0 ;
47309 int arg4 = (int) 0 ;
47310 wxGridSizer *result = 0 ;
47311 int val1 ;
47312 int ecode1 = 0 ;
47313 int val2 ;
47314 int ecode2 = 0 ;
47315 int val3 ;
47316 int ecode3 = 0 ;
47317 int val4 ;
47318 int ecode4 = 0 ;
47319 PyObject * obj0 = 0 ;
47320 PyObject * obj1 = 0 ;
47321 PyObject * obj2 = 0 ;
47322 PyObject * obj3 = 0 ;
47323 char * kwnames[] = {
47324 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47325 };
47326
47327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47328 if (obj0) {
47329 ecode1 = SWIG_AsVal_int(obj0, &val1);
47330 if (!SWIG_IsOK(ecode1)) {
47331 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47332 }
47333 arg1 = static_cast< int >(val1);
47334 }
47335 if (obj1) {
47336 ecode2 = SWIG_AsVal_int(obj1, &val2);
47337 if (!SWIG_IsOK(ecode2)) {
47338 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47339 }
47340 arg2 = static_cast< int >(val2);
47341 }
47342 if (obj2) {
47343 ecode3 = SWIG_AsVal_int(obj2, &val3);
47344 if (!SWIG_IsOK(ecode3)) {
47345 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47346 }
47347 arg3 = static_cast< int >(val3);
47348 }
47349 if (obj3) {
47350 ecode4 = SWIG_AsVal_int(obj3, &val4);
47351 if (!SWIG_IsOK(ecode4)) {
47352 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47353 }
47354 arg4 = static_cast< int >(val4);
47355 }
47356 {
47357 PyThreadState* __tstate = wxPyBeginAllowThreads();
47358 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47359 wxPyEndAllowThreads(__tstate);
47360 if (PyErr_Occurred()) SWIG_fail;
47361 }
47362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47363 return resultobj;
47364 fail:
47365 return NULL;
47366 }
47367
47368
47369 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47370 PyObject *resultobj = 0;
47371 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47372 int arg2 ;
47373 void *argp1 = 0 ;
47374 int res1 = 0 ;
47375 int val2 ;
47376 int ecode2 = 0 ;
47377 PyObject * obj0 = 0 ;
47378 PyObject * obj1 = 0 ;
47379 char * kwnames[] = {
47380 (char *) "self",(char *) "cols", NULL
47381 };
47382
47383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47385 if (!SWIG_IsOK(res1)) {
47386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47387 }
47388 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47389 ecode2 = SWIG_AsVal_int(obj1, &val2);
47390 if (!SWIG_IsOK(ecode2)) {
47391 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47392 }
47393 arg2 = static_cast< int >(val2);
47394 {
47395 PyThreadState* __tstate = wxPyBeginAllowThreads();
47396 (arg1)->SetCols(arg2);
47397 wxPyEndAllowThreads(__tstate);
47398 if (PyErr_Occurred()) SWIG_fail;
47399 }
47400 resultobj = SWIG_Py_Void();
47401 return resultobj;
47402 fail:
47403 return NULL;
47404 }
47405
47406
47407 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47408 PyObject *resultobj = 0;
47409 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47410 int arg2 ;
47411 void *argp1 = 0 ;
47412 int res1 = 0 ;
47413 int val2 ;
47414 int ecode2 = 0 ;
47415 PyObject * obj0 = 0 ;
47416 PyObject * obj1 = 0 ;
47417 char * kwnames[] = {
47418 (char *) "self",(char *) "rows", NULL
47419 };
47420
47421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47423 if (!SWIG_IsOK(res1)) {
47424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47425 }
47426 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47427 ecode2 = SWIG_AsVal_int(obj1, &val2);
47428 if (!SWIG_IsOK(ecode2)) {
47429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47430 }
47431 arg2 = static_cast< int >(val2);
47432 {
47433 PyThreadState* __tstate = wxPyBeginAllowThreads();
47434 (arg1)->SetRows(arg2);
47435 wxPyEndAllowThreads(__tstate);
47436 if (PyErr_Occurred()) SWIG_fail;
47437 }
47438 resultobj = SWIG_Py_Void();
47439 return resultobj;
47440 fail:
47441 return NULL;
47442 }
47443
47444
47445 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47446 PyObject *resultobj = 0;
47447 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47448 int arg2 ;
47449 void *argp1 = 0 ;
47450 int res1 = 0 ;
47451 int val2 ;
47452 int ecode2 = 0 ;
47453 PyObject * obj0 = 0 ;
47454 PyObject * obj1 = 0 ;
47455 char * kwnames[] = {
47456 (char *) "self",(char *) "gap", NULL
47457 };
47458
47459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47461 if (!SWIG_IsOK(res1)) {
47462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47463 }
47464 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47465 ecode2 = SWIG_AsVal_int(obj1, &val2);
47466 if (!SWIG_IsOK(ecode2)) {
47467 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47468 }
47469 arg2 = static_cast< int >(val2);
47470 {
47471 PyThreadState* __tstate = wxPyBeginAllowThreads();
47472 (arg1)->SetVGap(arg2);
47473 wxPyEndAllowThreads(__tstate);
47474 if (PyErr_Occurred()) SWIG_fail;
47475 }
47476 resultobj = SWIG_Py_Void();
47477 return resultobj;
47478 fail:
47479 return NULL;
47480 }
47481
47482
47483 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47484 PyObject *resultobj = 0;
47485 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47486 int arg2 ;
47487 void *argp1 = 0 ;
47488 int res1 = 0 ;
47489 int val2 ;
47490 int ecode2 = 0 ;
47491 PyObject * obj0 = 0 ;
47492 PyObject * obj1 = 0 ;
47493 char * kwnames[] = {
47494 (char *) "self",(char *) "gap", NULL
47495 };
47496
47497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47499 if (!SWIG_IsOK(res1)) {
47500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47501 }
47502 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47503 ecode2 = SWIG_AsVal_int(obj1, &val2);
47504 if (!SWIG_IsOK(ecode2)) {
47505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47506 }
47507 arg2 = static_cast< int >(val2);
47508 {
47509 PyThreadState* __tstate = wxPyBeginAllowThreads();
47510 (arg1)->SetHGap(arg2);
47511 wxPyEndAllowThreads(__tstate);
47512 if (PyErr_Occurred()) SWIG_fail;
47513 }
47514 resultobj = SWIG_Py_Void();
47515 return resultobj;
47516 fail:
47517 return NULL;
47518 }
47519
47520
47521 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47522 PyObject *resultobj = 0;
47523 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47524 int result;
47525 void *argp1 = 0 ;
47526 int res1 = 0 ;
47527 PyObject *swig_obj[1] ;
47528
47529 if (!args) SWIG_fail;
47530 swig_obj[0] = args;
47531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47532 if (!SWIG_IsOK(res1)) {
47533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47534 }
47535 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47536 {
47537 PyThreadState* __tstate = wxPyBeginAllowThreads();
47538 result = (int)(arg1)->GetCols();
47539 wxPyEndAllowThreads(__tstate);
47540 if (PyErr_Occurred()) SWIG_fail;
47541 }
47542 resultobj = SWIG_From_int(static_cast< int >(result));
47543 return resultobj;
47544 fail:
47545 return NULL;
47546 }
47547
47548
47549 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47550 PyObject *resultobj = 0;
47551 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47552 int result;
47553 void *argp1 = 0 ;
47554 int res1 = 0 ;
47555 PyObject *swig_obj[1] ;
47556
47557 if (!args) SWIG_fail;
47558 swig_obj[0] = args;
47559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47560 if (!SWIG_IsOK(res1)) {
47561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47562 }
47563 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47564 {
47565 PyThreadState* __tstate = wxPyBeginAllowThreads();
47566 result = (int)(arg1)->GetRows();
47567 wxPyEndAllowThreads(__tstate);
47568 if (PyErr_Occurred()) SWIG_fail;
47569 }
47570 resultobj = SWIG_From_int(static_cast< int >(result));
47571 return resultobj;
47572 fail:
47573 return NULL;
47574 }
47575
47576
47577 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47578 PyObject *resultobj = 0;
47579 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47580 int result;
47581 void *argp1 = 0 ;
47582 int res1 = 0 ;
47583 PyObject *swig_obj[1] ;
47584
47585 if (!args) SWIG_fail;
47586 swig_obj[0] = args;
47587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47588 if (!SWIG_IsOK(res1)) {
47589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47590 }
47591 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47592 {
47593 PyThreadState* __tstate = wxPyBeginAllowThreads();
47594 result = (int)(arg1)->GetVGap();
47595 wxPyEndAllowThreads(__tstate);
47596 if (PyErr_Occurred()) SWIG_fail;
47597 }
47598 resultobj = SWIG_From_int(static_cast< int >(result));
47599 return resultobj;
47600 fail:
47601 return NULL;
47602 }
47603
47604
47605 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47606 PyObject *resultobj = 0;
47607 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47608 int result;
47609 void *argp1 = 0 ;
47610 int res1 = 0 ;
47611 PyObject *swig_obj[1] ;
47612
47613 if (!args) SWIG_fail;
47614 swig_obj[0] = args;
47615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47616 if (!SWIG_IsOK(res1)) {
47617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47618 }
47619 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47620 {
47621 PyThreadState* __tstate = wxPyBeginAllowThreads();
47622 result = (int)(arg1)->GetHGap();
47623 wxPyEndAllowThreads(__tstate);
47624 if (PyErr_Occurred()) SWIG_fail;
47625 }
47626 resultobj = SWIG_From_int(static_cast< int >(result));
47627 return resultobj;
47628 fail:
47629 return NULL;
47630 }
47631
47632
47633 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47634 PyObject *obj;
47635 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47636 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47637 return SWIG_Py_Void();
47638 }
47639
47640 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47641 return SWIG_Python_InitShadowInstance(args);
47642 }
47643
47644 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47645 PyObject *resultobj = 0;
47646 int arg1 = (int) 1 ;
47647 int arg2 = (int) 0 ;
47648 int arg3 = (int) 0 ;
47649 int arg4 = (int) 0 ;
47650 wxFlexGridSizer *result = 0 ;
47651 int val1 ;
47652 int ecode1 = 0 ;
47653 int val2 ;
47654 int ecode2 = 0 ;
47655 int val3 ;
47656 int ecode3 = 0 ;
47657 int val4 ;
47658 int ecode4 = 0 ;
47659 PyObject * obj0 = 0 ;
47660 PyObject * obj1 = 0 ;
47661 PyObject * obj2 = 0 ;
47662 PyObject * obj3 = 0 ;
47663 char * kwnames[] = {
47664 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47665 };
47666
47667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47668 if (obj0) {
47669 ecode1 = SWIG_AsVal_int(obj0, &val1);
47670 if (!SWIG_IsOK(ecode1)) {
47671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47672 }
47673 arg1 = static_cast< int >(val1);
47674 }
47675 if (obj1) {
47676 ecode2 = SWIG_AsVal_int(obj1, &val2);
47677 if (!SWIG_IsOK(ecode2)) {
47678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47679 }
47680 arg2 = static_cast< int >(val2);
47681 }
47682 if (obj2) {
47683 ecode3 = SWIG_AsVal_int(obj2, &val3);
47684 if (!SWIG_IsOK(ecode3)) {
47685 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47686 }
47687 arg3 = static_cast< int >(val3);
47688 }
47689 if (obj3) {
47690 ecode4 = SWIG_AsVal_int(obj3, &val4);
47691 if (!SWIG_IsOK(ecode4)) {
47692 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47693 }
47694 arg4 = static_cast< int >(val4);
47695 }
47696 {
47697 PyThreadState* __tstate = wxPyBeginAllowThreads();
47698 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47699 wxPyEndAllowThreads(__tstate);
47700 if (PyErr_Occurred()) SWIG_fail;
47701 }
47702 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47703 return resultobj;
47704 fail:
47705 return NULL;
47706 }
47707
47708
47709 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47710 PyObject *resultobj = 0;
47711 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47712 size_t arg2 ;
47713 int arg3 = (int) 0 ;
47714 void *argp1 = 0 ;
47715 int res1 = 0 ;
47716 size_t val2 ;
47717 int ecode2 = 0 ;
47718 int val3 ;
47719 int ecode3 = 0 ;
47720 PyObject * obj0 = 0 ;
47721 PyObject * obj1 = 0 ;
47722 PyObject * obj2 = 0 ;
47723 char * kwnames[] = {
47724 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47725 };
47726
47727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47729 if (!SWIG_IsOK(res1)) {
47730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47731 }
47732 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47733 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47734 if (!SWIG_IsOK(ecode2)) {
47735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47736 }
47737 arg2 = static_cast< size_t >(val2);
47738 if (obj2) {
47739 ecode3 = SWIG_AsVal_int(obj2, &val3);
47740 if (!SWIG_IsOK(ecode3)) {
47741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47742 }
47743 arg3 = static_cast< int >(val3);
47744 }
47745 {
47746 PyThreadState* __tstate = wxPyBeginAllowThreads();
47747 (arg1)->AddGrowableRow(arg2,arg3);
47748 wxPyEndAllowThreads(__tstate);
47749 if (PyErr_Occurred()) SWIG_fail;
47750 }
47751 resultobj = SWIG_Py_Void();
47752 return resultobj;
47753 fail:
47754 return NULL;
47755 }
47756
47757
47758 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47759 PyObject *resultobj = 0;
47760 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47761 size_t arg2 ;
47762 void *argp1 = 0 ;
47763 int res1 = 0 ;
47764 size_t val2 ;
47765 int ecode2 = 0 ;
47766 PyObject * obj0 = 0 ;
47767 PyObject * obj1 = 0 ;
47768 char * kwnames[] = {
47769 (char *) "self",(char *) "idx", NULL
47770 };
47771
47772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
47773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47774 if (!SWIG_IsOK(res1)) {
47775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47776 }
47777 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47778 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47779 if (!SWIG_IsOK(ecode2)) {
47780 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47781 }
47782 arg2 = static_cast< size_t >(val2);
47783 {
47784 PyThreadState* __tstate = wxPyBeginAllowThreads();
47785 (arg1)->RemoveGrowableRow(arg2);
47786 wxPyEndAllowThreads(__tstate);
47787 if (PyErr_Occurred()) SWIG_fail;
47788 }
47789 resultobj = SWIG_Py_Void();
47790 return resultobj;
47791 fail:
47792 return NULL;
47793 }
47794
47795
47796 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47797 PyObject *resultobj = 0;
47798 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47799 size_t arg2 ;
47800 int arg3 = (int) 0 ;
47801 void *argp1 = 0 ;
47802 int res1 = 0 ;
47803 size_t val2 ;
47804 int ecode2 = 0 ;
47805 int val3 ;
47806 int ecode3 = 0 ;
47807 PyObject * obj0 = 0 ;
47808 PyObject * obj1 = 0 ;
47809 PyObject * obj2 = 0 ;
47810 char * kwnames[] = {
47811 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47812 };
47813
47814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47816 if (!SWIG_IsOK(res1)) {
47817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47818 }
47819 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47820 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47821 if (!SWIG_IsOK(ecode2)) {
47822 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47823 }
47824 arg2 = static_cast< size_t >(val2);
47825 if (obj2) {
47826 ecode3 = SWIG_AsVal_int(obj2, &val3);
47827 if (!SWIG_IsOK(ecode3)) {
47828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
47829 }
47830 arg3 = static_cast< int >(val3);
47831 }
47832 {
47833 PyThreadState* __tstate = wxPyBeginAllowThreads();
47834 (arg1)->AddGrowableCol(arg2,arg3);
47835 wxPyEndAllowThreads(__tstate);
47836 if (PyErr_Occurred()) SWIG_fail;
47837 }
47838 resultobj = SWIG_Py_Void();
47839 return resultobj;
47840 fail:
47841 return NULL;
47842 }
47843
47844
47845 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47846 PyObject *resultobj = 0;
47847 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47848 size_t arg2 ;
47849 void *argp1 = 0 ;
47850 int res1 = 0 ;
47851 size_t val2 ;
47852 int ecode2 = 0 ;
47853 PyObject * obj0 = 0 ;
47854 PyObject * obj1 = 0 ;
47855 char * kwnames[] = {
47856 (char *) "self",(char *) "idx", NULL
47857 };
47858
47859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
47860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47861 if (!SWIG_IsOK(res1)) {
47862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47863 }
47864 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47865 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47866 if (!SWIG_IsOK(ecode2)) {
47867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
47868 }
47869 arg2 = static_cast< size_t >(val2);
47870 {
47871 PyThreadState* __tstate = wxPyBeginAllowThreads();
47872 (arg1)->RemoveGrowableCol(arg2);
47873 wxPyEndAllowThreads(__tstate);
47874 if (PyErr_Occurred()) SWIG_fail;
47875 }
47876 resultobj = SWIG_Py_Void();
47877 return resultobj;
47878 fail:
47879 return NULL;
47880 }
47881
47882
47883 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47884 PyObject *resultobj = 0;
47885 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47886 int arg2 ;
47887 void *argp1 = 0 ;
47888 int res1 = 0 ;
47889 int val2 ;
47890 int ecode2 = 0 ;
47891 PyObject * obj0 = 0 ;
47892 PyObject * obj1 = 0 ;
47893 char * kwnames[] = {
47894 (char *) "self",(char *) "direction", NULL
47895 };
47896
47897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
47898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47899 if (!SWIG_IsOK(res1)) {
47900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47901 }
47902 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47903 ecode2 = SWIG_AsVal_int(obj1, &val2);
47904 if (!SWIG_IsOK(ecode2)) {
47905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
47906 }
47907 arg2 = static_cast< int >(val2);
47908 {
47909 PyThreadState* __tstate = wxPyBeginAllowThreads();
47910 (arg1)->SetFlexibleDirection(arg2);
47911 wxPyEndAllowThreads(__tstate);
47912 if (PyErr_Occurred()) SWIG_fail;
47913 }
47914 resultobj = SWIG_Py_Void();
47915 return resultobj;
47916 fail:
47917 return NULL;
47918 }
47919
47920
47921 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47922 PyObject *resultobj = 0;
47923 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47924 int result;
47925 void *argp1 = 0 ;
47926 int res1 = 0 ;
47927 PyObject *swig_obj[1] ;
47928
47929 if (!args) SWIG_fail;
47930 swig_obj[0] = args;
47931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47932 if (!SWIG_IsOK(res1)) {
47933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47934 }
47935 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47936 {
47937 PyThreadState* __tstate = wxPyBeginAllowThreads();
47938 result = (int)(arg1)->GetFlexibleDirection();
47939 wxPyEndAllowThreads(__tstate);
47940 if (PyErr_Occurred()) SWIG_fail;
47941 }
47942 resultobj = SWIG_From_int(static_cast< int >(result));
47943 return resultobj;
47944 fail:
47945 return NULL;
47946 }
47947
47948
47949 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47950 PyObject *resultobj = 0;
47951 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47952 wxFlexSizerGrowMode arg2 ;
47953 void *argp1 = 0 ;
47954 int res1 = 0 ;
47955 int val2 ;
47956 int ecode2 = 0 ;
47957 PyObject * obj0 = 0 ;
47958 PyObject * obj1 = 0 ;
47959 char * kwnames[] = {
47960 (char *) "self",(char *) "mode", NULL
47961 };
47962
47963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
47964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47965 if (!SWIG_IsOK(res1)) {
47966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47967 }
47968 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47969 ecode2 = SWIG_AsVal_int(obj1, &val2);
47970 if (!SWIG_IsOK(ecode2)) {
47971 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
47972 }
47973 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
47974 {
47975 PyThreadState* __tstate = wxPyBeginAllowThreads();
47976 (arg1)->SetNonFlexibleGrowMode(arg2);
47977 wxPyEndAllowThreads(__tstate);
47978 if (PyErr_Occurred()) SWIG_fail;
47979 }
47980 resultobj = SWIG_Py_Void();
47981 return resultobj;
47982 fail:
47983 return NULL;
47984 }
47985
47986
47987 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47988 PyObject *resultobj = 0;
47989 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47990 wxFlexSizerGrowMode result;
47991 void *argp1 = 0 ;
47992 int res1 = 0 ;
47993 PyObject *swig_obj[1] ;
47994
47995 if (!args) SWIG_fail;
47996 swig_obj[0] = args;
47997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47998 if (!SWIG_IsOK(res1)) {
47999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48000 }
48001 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48002 {
48003 PyThreadState* __tstate = wxPyBeginAllowThreads();
48004 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48005 wxPyEndAllowThreads(__tstate);
48006 if (PyErr_Occurred()) SWIG_fail;
48007 }
48008 resultobj = SWIG_From_int(static_cast< int >(result));
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48016 PyObject *resultobj = 0;
48017 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48018 wxArrayInt *result = 0 ;
48019 void *argp1 = 0 ;
48020 int res1 = 0 ;
48021 PyObject *swig_obj[1] ;
48022
48023 if (!args) SWIG_fail;
48024 swig_obj[0] = args;
48025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48026 if (!SWIG_IsOK(res1)) {
48027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48028 }
48029 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48030 {
48031 PyThreadState* __tstate = wxPyBeginAllowThreads();
48032 {
48033 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48034 result = (wxArrayInt *) &_result_ref;
48035 }
48036 wxPyEndAllowThreads(__tstate);
48037 if (PyErr_Occurred()) SWIG_fail;
48038 }
48039 {
48040 resultobj = PyList_New(0);
48041 size_t idx;
48042 for (idx = 0; idx < result->GetCount(); idx += 1) {
48043 PyObject* val = PyInt_FromLong( result->Item(idx) );
48044 PyList_Append(resultobj, val);
48045 Py_DECREF(val);
48046 }
48047 }
48048 return resultobj;
48049 fail:
48050 return NULL;
48051 }
48052
48053
48054 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48055 PyObject *resultobj = 0;
48056 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48057 wxArrayInt *result = 0 ;
48058 void *argp1 = 0 ;
48059 int res1 = 0 ;
48060 PyObject *swig_obj[1] ;
48061
48062 if (!args) SWIG_fail;
48063 swig_obj[0] = args;
48064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48065 if (!SWIG_IsOK(res1)) {
48066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48067 }
48068 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48069 {
48070 PyThreadState* __tstate = wxPyBeginAllowThreads();
48071 {
48072 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48073 result = (wxArrayInt *) &_result_ref;
48074 }
48075 wxPyEndAllowThreads(__tstate);
48076 if (PyErr_Occurred()) SWIG_fail;
48077 }
48078 {
48079 resultobj = PyList_New(0);
48080 size_t idx;
48081 for (idx = 0; idx < result->GetCount(); idx += 1) {
48082 PyObject* val = PyInt_FromLong( result->Item(idx) );
48083 PyList_Append(resultobj, val);
48084 Py_DECREF(val);
48085 }
48086 }
48087 return resultobj;
48088 fail:
48089 return NULL;
48090 }
48091
48092
48093 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48094 PyObject *obj;
48095 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48096 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48097 return SWIG_Py_Void();
48098 }
48099
48100 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48101 return SWIG_Python_InitShadowInstance(args);
48102 }
48103
48104 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48105 PyObject *resultobj = 0;
48106 wxStdDialogButtonSizer *result = 0 ;
48107
48108 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48109 {
48110 PyThreadState* __tstate = wxPyBeginAllowThreads();
48111 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48112 wxPyEndAllowThreads(__tstate);
48113 if (PyErr_Occurred()) SWIG_fail;
48114 }
48115 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48116 return resultobj;
48117 fail:
48118 return NULL;
48119 }
48120
48121
48122 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48123 PyObject *resultobj = 0;
48124 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48125 wxButton *arg2 = (wxButton *) 0 ;
48126 void *argp1 = 0 ;
48127 int res1 = 0 ;
48128 void *argp2 = 0 ;
48129 int res2 = 0 ;
48130 PyObject * obj0 = 0 ;
48131 PyObject * obj1 = 0 ;
48132 char * kwnames[] = {
48133 (char *) "self",(char *) "button", NULL
48134 };
48135
48136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48138 if (!SWIG_IsOK(res1)) {
48139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48140 }
48141 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48142 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48143 if (!SWIG_IsOK(res2)) {
48144 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48145 }
48146 arg2 = reinterpret_cast< wxButton * >(argp2);
48147 {
48148 PyThreadState* __tstate = wxPyBeginAllowThreads();
48149 (arg1)->AddButton(arg2);
48150 wxPyEndAllowThreads(__tstate);
48151 if (PyErr_Occurred()) SWIG_fail;
48152 }
48153 resultobj = SWIG_Py_Void();
48154 return resultobj;
48155 fail:
48156 return NULL;
48157 }
48158
48159
48160 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48161 PyObject *resultobj = 0;
48162 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48163 void *argp1 = 0 ;
48164 int res1 = 0 ;
48165 PyObject *swig_obj[1] ;
48166
48167 if (!args) SWIG_fail;
48168 swig_obj[0] = args;
48169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48170 if (!SWIG_IsOK(res1)) {
48171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48172 }
48173 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48174 {
48175 PyThreadState* __tstate = wxPyBeginAllowThreads();
48176 (arg1)->Realize();
48177 wxPyEndAllowThreads(__tstate);
48178 if (PyErr_Occurred()) SWIG_fail;
48179 }
48180 resultobj = SWIG_Py_Void();
48181 return resultobj;
48182 fail:
48183 return NULL;
48184 }
48185
48186
48187 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48188 PyObject *resultobj = 0;
48189 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48190 wxButton *arg2 = (wxButton *) 0 ;
48191 void *argp1 = 0 ;
48192 int res1 = 0 ;
48193 void *argp2 = 0 ;
48194 int res2 = 0 ;
48195 PyObject * obj0 = 0 ;
48196 PyObject * obj1 = 0 ;
48197 char * kwnames[] = {
48198 (char *) "self",(char *) "button", NULL
48199 };
48200
48201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48203 if (!SWIG_IsOK(res1)) {
48204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48205 }
48206 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48208 if (!SWIG_IsOK(res2)) {
48209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48210 }
48211 arg2 = reinterpret_cast< wxButton * >(argp2);
48212 {
48213 PyThreadState* __tstate = wxPyBeginAllowThreads();
48214 (arg1)->SetAffirmativeButton(arg2);
48215 wxPyEndAllowThreads(__tstate);
48216 if (PyErr_Occurred()) SWIG_fail;
48217 }
48218 resultobj = SWIG_Py_Void();
48219 return resultobj;
48220 fail:
48221 return NULL;
48222 }
48223
48224
48225 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48226 PyObject *resultobj = 0;
48227 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48228 wxButton *arg2 = (wxButton *) 0 ;
48229 void *argp1 = 0 ;
48230 int res1 = 0 ;
48231 void *argp2 = 0 ;
48232 int res2 = 0 ;
48233 PyObject * obj0 = 0 ;
48234 PyObject * obj1 = 0 ;
48235 char * kwnames[] = {
48236 (char *) "self",(char *) "button", NULL
48237 };
48238
48239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48241 if (!SWIG_IsOK(res1)) {
48242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48243 }
48244 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48245 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48246 if (!SWIG_IsOK(res2)) {
48247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48248 }
48249 arg2 = reinterpret_cast< wxButton * >(argp2);
48250 {
48251 PyThreadState* __tstate = wxPyBeginAllowThreads();
48252 (arg1)->SetNegativeButton(arg2);
48253 wxPyEndAllowThreads(__tstate);
48254 if (PyErr_Occurred()) SWIG_fail;
48255 }
48256 resultobj = SWIG_Py_Void();
48257 return resultobj;
48258 fail:
48259 return NULL;
48260 }
48261
48262
48263 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48264 PyObject *resultobj = 0;
48265 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48266 wxButton *arg2 = (wxButton *) 0 ;
48267 void *argp1 = 0 ;
48268 int res1 = 0 ;
48269 void *argp2 = 0 ;
48270 int res2 = 0 ;
48271 PyObject * obj0 = 0 ;
48272 PyObject * obj1 = 0 ;
48273 char * kwnames[] = {
48274 (char *) "self",(char *) "button", NULL
48275 };
48276
48277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48279 if (!SWIG_IsOK(res1)) {
48280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48281 }
48282 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48283 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48284 if (!SWIG_IsOK(res2)) {
48285 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48286 }
48287 arg2 = reinterpret_cast< wxButton * >(argp2);
48288 {
48289 PyThreadState* __tstate = wxPyBeginAllowThreads();
48290 (arg1)->SetCancelButton(arg2);
48291 wxPyEndAllowThreads(__tstate);
48292 if (PyErr_Occurred()) SWIG_fail;
48293 }
48294 resultobj = SWIG_Py_Void();
48295 return resultobj;
48296 fail:
48297 return NULL;
48298 }
48299
48300
48301 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48302 PyObject *resultobj = 0;
48303 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48304 wxButton *result = 0 ;
48305 void *argp1 = 0 ;
48306 int res1 = 0 ;
48307 PyObject *swig_obj[1] ;
48308
48309 if (!args) SWIG_fail;
48310 swig_obj[0] = args;
48311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48312 if (!SWIG_IsOK(res1)) {
48313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48314 }
48315 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48316 {
48317 PyThreadState* __tstate = wxPyBeginAllowThreads();
48318 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48319 wxPyEndAllowThreads(__tstate);
48320 if (PyErr_Occurred()) SWIG_fail;
48321 }
48322 {
48323 resultobj = wxPyMake_wxObject(result, (bool)0);
48324 }
48325 return resultobj;
48326 fail:
48327 return NULL;
48328 }
48329
48330
48331 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48332 PyObject *resultobj = 0;
48333 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48334 wxButton *result = 0 ;
48335 void *argp1 = 0 ;
48336 int res1 = 0 ;
48337 PyObject *swig_obj[1] ;
48338
48339 if (!args) SWIG_fail;
48340 swig_obj[0] = args;
48341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48342 if (!SWIG_IsOK(res1)) {
48343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48344 }
48345 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48346 {
48347 PyThreadState* __tstate = wxPyBeginAllowThreads();
48348 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48349 wxPyEndAllowThreads(__tstate);
48350 if (PyErr_Occurred()) SWIG_fail;
48351 }
48352 {
48353 resultobj = wxPyMake_wxObject(result, (bool)0);
48354 }
48355 return resultobj;
48356 fail:
48357 return NULL;
48358 }
48359
48360
48361 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48362 PyObject *resultobj = 0;
48363 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48364 wxButton *result = 0 ;
48365 void *argp1 = 0 ;
48366 int res1 = 0 ;
48367 PyObject *swig_obj[1] ;
48368
48369 if (!args) SWIG_fail;
48370 swig_obj[0] = args;
48371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48372 if (!SWIG_IsOK(res1)) {
48373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48374 }
48375 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48376 {
48377 PyThreadState* __tstate = wxPyBeginAllowThreads();
48378 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48379 wxPyEndAllowThreads(__tstate);
48380 if (PyErr_Occurred()) SWIG_fail;
48381 }
48382 {
48383 resultobj = wxPyMake_wxObject(result, (bool)0);
48384 }
48385 return resultobj;
48386 fail:
48387 return NULL;
48388 }
48389
48390
48391 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48392 PyObject *resultobj = 0;
48393 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48394 wxButton *result = 0 ;
48395 void *argp1 = 0 ;
48396 int res1 = 0 ;
48397 PyObject *swig_obj[1] ;
48398
48399 if (!args) SWIG_fail;
48400 swig_obj[0] = args;
48401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48402 if (!SWIG_IsOK(res1)) {
48403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48404 }
48405 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48406 {
48407 PyThreadState* __tstate = wxPyBeginAllowThreads();
48408 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48409 wxPyEndAllowThreads(__tstate);
48410 if (PyErr_Occurred()) SWIG_fail;
48411 }
48412 {
48413 resultobj = wxPyMake_wxObject(result, (bool)0);
48414 }
48415 return resultobj;
48416 fail:
48417 return NULL;
48418 }
48419
48420
48421 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48422 PyObject *resultobj = 0;
48423 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48424 wxButton *result = 0 ;
48425 void *argp1 = 0 ;
48426 int res1 = 0 ;
48427 PyObject *swig_obj[1] ;
48428
48429 if (!args) SWIG_fail;
48430 swig_obj[0] = args;
48431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48432 if (!SWIG_IsOK(res1)) {
48433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48434 }
48435 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48436 {
48437 PyThreadState* __tstate = wxPyBeginAllowThreads();
48438 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48439 wxPyEndAllowThreads(__tstate);
48440 if (PyErr_Occurred()) SWIG_fail;
48441 }
48442 {
48443 resultobj = wxPyMake_wxObject(result, (bool)0);
48444 }
48445 return resultobj;
48446 fail:
48447 return NULL;
48448 }
48449
48450
48451 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48452 PyObject *obj;
48453 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48454 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48455 return SWIG_Py_Void();
48456 }
48457
48458 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48459 return SWIG_Python_InitShadowInstance(args);
48460 }
48461
48462 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48463 PyObject *resultobj = 0;
48464 int arg1 = (int) 0 ;
48465 int arg2 = (int) 0 ;
48466 wxGBPosition *result = 0 ;
48467 int val1 ;
48468 int ecode1 = 0 ;
48469 int val2 ;
48470 int ecode2 = 0 ;
48471 PyObject * obj0 = 0 ;
48472 PyObject * obj1 = 0 ;
48473 char * kwnames[] = {
48474 (char *) "row",(char *) "col", NULL
48475 };
48476
48477 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48478 if (obj0) {
48479 ecode1 = SWIG_AsVal_int(obj0, &val1);
48480 if (!SWIG_IsOK(ecode1)) {
48481 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48482 }
48483 arg1 = static_cast< int >(val1);
48484 }
48485 if (obj1) {
48486 ecode2 = SWIG_AsVal_int(obj1, &val2);
48487 if (!SWIG_IsOK(ecode2)) {
48488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48489 }
48490 arg2 = static_cast< int >(val2);
48491 }
48492 {
48493 PyThreadState* __tstate = wxPyBeginAllowThreads();
48494 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48495 wxPyEndAllowThreads(__tstate);
48496 if (PyErr_Occurred()) SWIG_fail;
48497 }
48498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48499 return resultobj;
48500 fail:
48501 return NULL;
48502 }
48503
48504
48505 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48506 PyObject *resultobj = 0;
48507 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48508 void *argp1 = 0 ;
48509 int res1 = 0 ;
48510 PyObject *swig_obj[1] ;
48511
48512 if (!args) SWIG_fail;
48513 swig_obj[0] = args;
48514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48515 if (!SWIG_IsOK(res1)) {
48516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48517 }
48518 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48519 {
48520 PyThreadState* __tstate = wxPyBeginAllowThreads();
48521 delete arg1;
48522
48523 wxPyEndAllowThreads(__tstate);
48524 if (PyErr_Occurred()) SWIG_fail;
48525 }
48526 resultobj = SWIG_Py_Void();
48527 return resultobj;
48528 fail:
48529 return NULL;
48530 }
48531
48532
48533 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48534 PyObject *resultobj = 0;
48535 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48536 int result;
48537 void *argp1 = 0 ;
48538 int res1 = 0 ;
48539 PyObject *swig_obj[1] ;
48540
48541 if (!args) SWIG_fail;
48542 swig_obj[0] = args;
48543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48544 if (!SWIG_IsOK(res1)) {
48545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48546 }
48547 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48548 {
48549 PyThreadState* __tstate = wxPyBeginAllowThreads();
48550 result = (int)((wxGBPosition const *)arg1)->GetRow();
48551 wxPyEndAllowThreads(__tstate);
48552 if (PyErr_Occurred()) SWIG_fail;
48553 }
48554 resultobj = SWIG_From_int(static_cast< int >(result));
48555 return resultobj;
48556 fail:
48557 return NULL;
48558 }
48559
48560
48561 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48562 PyObject *resultobj = 0;
48563 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48564 int result;
48565 void *argp1 = 0 ;
48566 int res1 = 0 ;
48567 PyObject *swig_obj[1] ;
48568
48569 if (!args) SWIG_fail;
48570 swig_obj[0] = args;
48571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48572 if (!SWIG_IsOK(res1)) {
48573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48574 }
48575 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48576 {
48577 PyThreadState* __tstate = wxPyBeginAllowThreads();
48578 result = (int)((wxGBPosition const *)arg1)->GetCol();
48579 wxPyEndAllowThreads(__tstate);
48580 if (PyErr_Occurred()) SWIG_fail;
48581 }
48582 resultobj = SWIG_From_int(static_cast< int >(result));
48583 return resultobj;
48584 fail:
48585 return NULL;
48586 }
48587
48588
48589 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48590 PyObject *resultobj = 0;
48591 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48592 int arg2 ;
48593 void *argp1 = 0 ;
48594 int res1 = 0 ;
48595 int val2 ;
48596 int ecode2 = 0 ;
48597 PyObject * obj0 = 0 ;
48598 PyObject * obj1 = 0 ;
48599 char * kwnames[] = {
48600 (char *) "self",(char *) "row", NULL
48601 };
48602
48603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48605 if (!SWIG_IsOK(res1)) {
48606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48607 }
48608 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48609 ecode2 = SWIG_AsVal_int(obj1, &val2);
48610 if (!SWIG_IsOK(ecode2)) {
48611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48612 }
48613 arg2 = static_cast< int >(val2);
48614 {
48615 PyThreadState* __tstate = wxPyBeginAllowThreads();
48616 (arg1)->SetRow(arg2);
48617 wxPyEndAllowThreads(__tstate);
48618 if (PyErr_Occurred()) SWIG_fail;
48619 }
48620 resultobj = SWIG_Py_Void();
48621 return resultobj;
48622 fail:
48623 return NULL;
48624 }
48625
48626
48627 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48628 PyObject *resultobj = 0;
48629 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48630 int arg2 ;
48631 void *argp1 = 0 ;
48632 int res1 = 0 ;
48633 int val2 ;
48634 int ecode2 = 0 ;
48635 PyObject * obj0 = 0 ;
48636 PyObject * obj1 = 0 ;
48637 char * kwnames[] = {
48638 (char *) "self",(char *) "col", NULL
48639 };
48640
48641 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48642 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48643 if (!SWIG_IsOK(res1)) {
48644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48645 }
48646 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48647 ecode2 = SWIG_AsVal_int(obj1, &val2);
48648 if (!SWIG_IsOK(ecode2)) {
48649 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48650 }
48651 arg2 = static_cast< int >(val2);
48652 {
48653 PyThreadState* __tstate = wxPyBeginAllowThreads();
48654 (arg1)->SetCol(arg2);
48655 wxPyEndAllowThreads(__tstate);
48656 if (PyErr_Occurred()) SWIG_fail;
48657 }
48658 resultobj = SWIG_Py_Void();
48659 return resultobj;
48660 fail:
48661 return NULL;
48662 }
48663
48664
48665 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48666 PyObject *resultobj = 0;
48667 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48668 wxGBPosition *arg2 = 0 ;
48669 bool result;
48670 void *argp1 = 0 ;
48671 int res1 = 0 ;
48672 wxGBPosition temp2 ;
48673 PyObject * obj0 = 0 ;
48674 PyObject * obj1 = 0 ;
48675 char * kwnames[] = {
48676 (char *) "self",(char *) "other", NULL
48677 };
48678
48679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48681 if (!SWIG_IsOK(res1)) {
48682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48683 }
48684 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48685 {
48686 arg2 = &temp2;
48687 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48688 }
48689 {
48690 PyThreadState* __tstate = wxPyBeginAllowThreads();
48691 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
48692 wxPyEndAllowThreads(__tstate);
48693 if (PyErr_Occurred()) SWIG_fail;
48694 }
48695 {
48696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48697 }
48698 return resultobj;
48699 fail:
48700 return NULL;
48701 }
48702
48703
48704 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48705 PyObject *resultobj = 0;
48706 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48707 wxGBPosition *arg2 = 0 ;
48708 bool result;
48709 void *argp1 = 0 ;
48710 int res1 = 0 ;
48711 wxGBPosition temp2 ;
48712 PyObject * obj0 = 0 ;
48713 PyObject * obj1 = 0 ;
48714 char * kwnames[] = {
48715 (char *) "self",(char *) "other", NULL
48716 };
48717
48718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48720 if (!SWIG_IsOK(res1)) {
48721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48722 }
48723 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48724 {
48725 arg2 = &temp2;
48726 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
48727 }
48728 {
48729 PyThreadState* __tstate = wxPyBeginAllowThreads();
48730 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
48731 wxPyEndAllowThreads(__tstate);
48732 if (PyErr_Occurred()) SWIG_fail;
48733 }
48734 {
48735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48736 }
48737 return resultobj;
48738 fail:
48739 return NULL;
48740 }
48741
48742
48743 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48744 PyObject *resultobj = 0;
48745 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48746 int arg2 = (int) 0 ;
48747 int arg3 = (int) 0 ;
48748 void *argp1 = 0 ;
48749 int res1 = 0 ;
48750 int val2 ;
48751 int ecode2 = 0 ;
48752 int val3 ;
48753 int ecode3 = 0 ;
48754 PyObject * obj0 = 0 ;
48755 PyObject * obj1 = 0 ;
48756 PyObject * obj2 = 0 ;
48757 char * kwnames[] = {
48758 (char *) "self",(char *) "row",(char *) "col", NULL
48759 };
48760
48761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48763 if (!SWIG_IsOK(res1)) {
48764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48765 }
48766 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48767 if (obj1) {
48768 ecode2 = SWIG_AsVal_int(obj1, &val2);
48769 if (!SWIG_IsOK(ecode2)) {
48770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48771 }
48772 arg2 = static_cast< int >(val2);
48773 }
48774 if (obj2) {
48775 ecode3 = SWIG_AsVal_int(obj2, &val3);
48776 if (!SWIG_IsOK(ecode3)) {
48777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
48778 }
48779 arg3 = static_cast< int >(val3);
48780 }
48781 {
48782 PyThreadState* __tstate = wxPyBeginAllowThreads();
48783 wxGBPosition_Set(arg1,arg2,arg3);
48784 wxPyEndAllowThreads(__tstate);
48785 if (PyErr_Occurred()) SWIG_fail;
48786 }
48787 resultobj = SWIG_Py_Void();
48788 return resultobj;
48789 fail:
48790 return NULL;
48791 }
48792
48793
48794 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48795 PyObject *resultobj = 0;
48796 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48797 PyObject *result = 0 ;
48798 void *argp1 = 0 ;
48799 int res1 = 0 ;
48800 PyObject *swig_obj[1] ;
48801
48802 if (!args) SWIG_fail;
48803 swig_obj[0] = args;
48804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48805 if (!SWIG_IsOK(res1)) {
48806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48807 }
48808 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48809 {
48810 PyThreadState* __tstate = wxPyBeginAllowThreads();
48811 result = (PyObject *)wxGBPosition_Get(arg1);
48812 wxPyEndAllowThreads(__tstate);
48813 if (PyErr_Occurred()) SWIG_fail;
48814 }
48815 resultobj = result;
48816 return resultobj;
48817 fail:
48818 return NULL;
48819 }
48820
48821
48822 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48823 PyObject *obj;
48824 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48825 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
48826 return SWIG_Py_Void();
48827 }
48828
48829 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48830 return SWIG_Python_InitShadowInstance(args);
48831 }
48832
48833 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48834 PyObject *resultobj = 0;
48835 int arg1 = (int) 1 ;
48836 int arg2 = (int) 1 ;
48837 wxGBSpan *result = 0 ;
48838 int val1 ;
48839 int ecode1 = 0 ;
48840 int val2 ;
48841 int ecode2 = 0 ;
48842 PyObject * obj0 = 0 ;
48843 PyObject * obj1 = 0 ;
48844 char * kwnames[] = {
48845 (char *) "rowspan",(char *) "colspan", NULL
48846 };
48847
48848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
48849 if (obj0) {
48850 ecode1 = SWIG_AsVal_int(obj0, &val1);
48851 if (!SWIG_IsOK(ecode1)) {
48852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
48853 }
48854 arg1 = static_cast< int >(val1);
48855 }
48856 if (obj1) {
48857 ecode2 = SWIG_AsVal_int(obj1, &val2);
48858 if (!SWIG_IsOK(ecode2)) {
48859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
48860 }
48861 arg2 = static_cast< int >(val2);
48862 }
48863 {
48864 PyThreadState* __tstate = wxPyBeginAllowThreads();
48865 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
48866 wxPyEndAllowThreads(__tstate);
48867 if (PyErr_Occurred()) SWIG_fail;
48868 }
48869 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
48870 return resultobj;
48871 fail:
48872 return NULL;
48873 }
48874
48875
48876 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48877 PyObject *resultobj = 0;
48878 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48879 void *argp1 = 0 ;
48880 int res1 = 0 ;
48881 PyObject *swig_obj[1] ;
48882
48883 if (!args) SWIG_fail;
48884 swig_obj[0] = args;
48885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
48886 if (!SWIG_IsOK(res1)) {
48887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48888 }
48889 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48890 {
48891 PyThreadState* __tstate = wxPyBeginAllowThreads();
48892 delete arg1;
48893
48894 wxPyEndAllowThreads(__tstate);
48895 if (PyErr_Occurred()) SWIG_fail;
48896 }
48897 resultobj = SWIG_Py_Void();
48898 return resultobj;
48899 fail:
48900 return NULL;
48901 }
48902
48903
48904 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48905 PyObject *resultobj = 0;
48906 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48907 int result;
48908 void *argp1 = 0 ;
48909 int res1 = 0 ;
48910 PyObject *swig_obj[1] ;
48911
48912 if (!args) SWIG_fail;
48913 swig_obj[0] = args;
48914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48915 if (!SWIG_IsOK(res1)) {
48916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48917 }
48918 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_From_int(static_cast< int >(result));
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48933 PyObject *resultobj = 0;
48934 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48935 int result;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 PyObject *swig_obj[1] ;
48939
48940 if (!args) SWIG_fail;
48941 swig_obj[0] = args;
48942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48943 if (!SWIG_IsOK(res1)) {
48944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
48945 }
48946 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48947 {
48948 PyThreadState* __tstate = wxPyBeginAllowThreads();
48949 result = (int)((wxGBSpan const *)arg1)->GetColspan();
48950 wxPyEndAllowThreads(__tstate);
48951 if (PyErr_Occurred()) SWIG_fail;
48952 }
48953 resultobj = SWIG_From_int(static_cast< int >(result));
48954 return resultobj;
48955 fail:
48956 return NULL;
48957 }
48958
48959
48960 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48961 PyObject *resultobj = 0;
48962 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
48963 int arg2 ;
48964 void *argp1 = 0 ;
48965 int res1 = 0 ;
48966 int val2 ;
48967 int ecode2 = 0 ;
48968 PyObject * obj0 = 0 ;
48969 PyObject * obj1 = 0 ;
48970 char * kwnames[] = {
48971 (char *) "self",(char *) "rowspan", NULL
48972 };
48973
48974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
48975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
48976 if (!SWIG_IsOK(res1)) {
48977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
48978 }
48979 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
48980 ecode2 = SWIG_AsVal_int(obj1, &val2);
48981 if (!SWIG_IsOK(ecode2)) {
48982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
48983 }
48984 arg2 = static_cast< int >(val2);
48985 {
48986 PyThreadState* __tstate = wxPyBeginAllowThreads();
48987 (arg1)->SetRowspan(arg2);
48988 wxPyEndAllowThreads(__tstate);
48989 if (PyErr_Occurred()) SWIG_fail;
48990 }
48991 resultobj = SWIG_Py_Void();
48992 return resultobj;
48993 fail:
48994 return NULL;
48995 }
48996
48997
48998 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48999 PyObject *resultobj = 0;
49000 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49001 int arg2 ;
49002 void *argp1 = 0 ;
49003 int res1 = 0 ;
49004 int val2 ;
49005 int ecode2 = 0 ;
49006 PyObject * obj0 = 0 ;
49007 PyObject * obj1 = 0 ;
49008 char * kwnames[] = {
49009 (char *) "self",(char *) "colspan", NULL
49010 };
49011
49012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49014 if (!SWIG_IsOK(res1)) {
49015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49016 }
49017 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49018 ecode2 = SWIG_AsVal_int(obj1, &val2);
49019 if (!SWIG_IsOK(ecode2)) {
49020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49021 }
49022 arg2 = static_cast< int >(val2);
49023 {
49024 PyThreadState* __tstate = wxPyBeginAllowThreads();
49025 (arg1)->SetColspan(arg2);
49026 wxPyEndAllowThreads(__tstate);
49027 if (PyErr_Occurred()) SWIG_fail;
49028 }
49029 resultobj = SWIG_Py_Void();
49030 return resultobj;
49031 fail:
49032 return NULL;
49033 }
49034
49035
49036 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49037 PyObject *resultobj = 0;
49038 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49039 wxGBSpan *arg2 = 0 ;
49040 bool result;
49041 void *argp1 = 0 ;
49042 int res1 = 0 ;
49043 wxGBSpan temp2 ;
49044 PyObject * obj0 = 0 ;
49045 PyObject * obj1 = 0 ;
49046 char * kwnames[] = {
49047 (char *) "self",(char *) "other", NULL
49048 };
49049
49050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49052 if (!SWIG_IsOK(res1)) {
49053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49054 }
49055 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49056 {
49057 arg2 = &temp2;
49058 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49059 }
49060 {
49061 PyThreadState* __tstate = wxPyBeginAllowThreads();
49062 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
49063 wxPyEndAllowThreads(__tstate);
49064 if (PyErr_Occurred()) SWIG_fail;
49065 }
49066 {
49067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49068 }
49069 return resultobj;
49070 fail:
49071 return NULL;
49072 }
49073
49074
49075 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49076 PyObject *resultobj = 0;
49077 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49078 wxGBSpan *arg2 = 0 ;
49079 bool result;
49080 void *argp1 = 0 ;
49081 int res1 = 0 ;
49082 wxGBSpan temp2 ;
49083 PyObject * obj0 = 0 ;
49084 PyObject * obj1 = 0 ;
49085 char * kwnames[] = {
49086 (char *) "self",(char *) "other", NULL
49087 };
49088
49089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49091 if (!SWIG_IsOK(res1)) {
49092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49093 }
49094 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49095 {
49096 arg2 = &temp2;
49097 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49098 }
49099 {
49100 PyThreadState* __tstate = wxPyBeginAllowThreads();
49101 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
49102 wxPyEndAllowThreads(__tstate);
49103 if (PyErr_Occurred()) SWIG_fail;
49104 }
49105 {
49106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49107 }
49108 return resultobj;
49109 fail:
49110 return NULL;
49111 }
49112
49113
49114 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49115 PyObject *resultobj = 0;
49116 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49117 int arg2 = (int) 1 ;
49118 int arg3 = (int) 1 ;
49119 void *argp1 = 0 ;
49120 int res1 = 0 ;
49121 int val2 ;
49122 int ecode2 = 0 ;
49123 int val3 ;
49124 int ecode3 = 0 ;
49125 PyObject * obj0 = 0 ;
49126 PyObject * obj1 = 0 ;
49127 PyObject * obj2 = 0 ;
49128 char * kwnames[] = {
49129 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49130 };
49131
49132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49134 if (!SWIG_IsOK(res1)) {
49135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49136 }
49137 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49138 if (obj1) {
49139 ecode2 = SWIG_AsVal_int(obj1, &val2);
49140 if (!SWIG_IsOK(ecode2)) {
49141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49142 }
49143 arg2 = static_cast< int >(val2);
49144 }
49145 if (obj2) {
49146 ecode3 = SWIG_AsVal_int(obj2, &val3);
49147 if (!SWIG_IsOK(ecode3)) {
49148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49149 }
49150 arg3 = static_cast< int >(val3);
49151 }
49152 {
49153 PyThreadState* __tstate = wxPyBeginAllowThreads();
49154 wxGBSpan_Set(arg1,arg2,arg3);
49155 wxPyEndAllowThreads(__tstate);
49156 if (PyErr_Occurred()) SWIG_fail;
49157 }
49158 resultobj = SWIG_Py_Void();
49159 return resultobj;
49160 fail:
49161 return NULL;
49162 }
49163
49164
49165 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49166 PyObject *resultobj = 0;
49167 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49168 PyObject *result = 0 ;
49169 void *argp1 = 0 ;
49170 int res1 = 0 ;
49171 PyObject *swig_obj[1] ;
49172
49173 if (!args) SWIG_fail;
49174 swig_obj[0] = args;
49175 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49176 if (!SWIG_IsOK(res1)) {
49177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49178 }
49179 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49180 {
49181 PyThreadState* __tstate = wxPyBeginAllowThreads();
49182 result = (PyObject *)wxGBSpan_Get(arg1);
49183 wxPyEndAllowThreads(__tstate);
49184 if (PyErr_Occurred()) SWIG_fail;
49185 }
49186 resultobj = result;
49187 return resultobj;
49188 fail:
49189 return NULL;
49190 }
49191
49192
49193 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49194 PyObject *obj;
49195 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49196 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49197 return SWIG_Py_Void();
49198 }
49199
49200 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49201 return SWIG_Python_InitShadowInstance(args);
49202 }
49203
49204 SWIGINTERN int DefaultSpan_set(PyObject *) {
49205 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49206 return 1;
49207 }
49208
49209
49210 SWIGINTERN PyObject *DefaultSpan_get(void) {
49211 PyObject *pyobj = 0;
49212
49213 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49214 return pyobj;
49215 }
49216
49217
49218 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49219 PyObject *resultobj = 0;
49220 wxGBSizerItem *result = 0 ;
49221
49222 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49223 {
49224 PyThreadState* __tstate = wxPyBeginAllowThreads();
49225 result = (wxGBSizerItem *)new wxGBSizerItem();
49226 wxPyEndAllowThreads(__tstate);
49227 if (PyErr_Occurred()) SWIG_fail;
49228 }
49229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49230 return resultobj;
49231 fail:
49232 return NULL;
49233 }
49234
49235
49236 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49237 PyObject *resultobj = 0;
49238 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49239 void *argp1 = 0 ;
49240 int res1 = 0 ;
49241 PyObject *swig_obj[1] ;
49242
49243 if (!args) SWIG_fail;
49244 swig_obj[0] = args;
49245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49246 if (!SWIG_IsOK(res1)) {
49247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49248 }
49249 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49250 {
49251 PyThreadState* __tstate = wxPyBeginAllowThreads();
49252 delete arg1;
49253
49254 wxPyEndAllowThreads(__tstate);
49255 if (PyErr_Occurred()) SWIG_fail;
49256 }
49257 resultobj = SWIG_Py_Void();
49258 return resultobj;
49259 fail:
49260 return NULL;
49261 }
49262
49263
49264 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49265 PyObject *resultobj = 0;
49266 wxWindow *arg1 = (wxWindow *) 0 ;
49267 wxGBPosition *arg2 = 0 ;
49268 wxGBSpan *arg3 = 0 ;
49269 int arg4 ;
49270 int arg5 ;
49271 PyObject *arg6 = (PyObject *) NULL ;
49272 wxGBSizerItem *result = 0 ;
49273 void *argp1 = 0 ;
49274 int res1 = 0 ;
49275 wxGBPosition temp2 ;
49276 wxGBSpan temp3 ;
49277 int val4 ;
49278 int ecode4 = 0 ;
49279 int val5 ;
49280 int ecode5 = 0 ;
49281 PyObject * obj0 = 0 ;
49282 PyObject * obj1 = 0 ;
49283 PyObject * obj2 = 0 ;
49284 PyObject * obj3 = 0 ;
49285 PyObject * obj4 = 0 ;
49286 PyObject * obj5 = 0 ;
49287 char * kwnames[] = {
49288 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49289 };
49290
49291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49293 if (!SWIG_IsOK(res1)) {
49294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49295 }
49296 arg1 = reinterpret_cast< wxWindow * >(argp1);
49297 {
49298 arg2 = &temp2;
49299 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49300 }
49301 {
49302 arg3 = &temp3;
49303 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49304 }
49305 ecode4 = SWIG_AsVal_int(obj3, &val4);
49306 if (!SWIG_IsOK(ecode4)) {
49307 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49308 }
49309 arg4 = static_cast< int >(val4);
49310 ecode5 = SWIG_AsVal_int(obj4, &val5);
49311 if (!SWIG_IsOK(ecode5)) {
49312 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49313 }
49314 arg5 = static_cast< int >(val5);
49315 if (obj5) {
49316 arg6 = obj5;
49317 }
49318 {
49319 PyThreadState* __tstate = wxPyBeginAllowThreads();
49320 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49321 wxPyEndAllowThreads(__tstate);
49322 if (PyErr_Occurred()) SWIG_fail;
49323 }
49324 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49325 return resultobj;
49326 fail:
49327 return NULL;
49328 }
49329
49330
49331 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49332 PyObject *resultobj = 0;
49333 wxSizer *arg1 = (wxSizer *) 0 ;
49334 wxGBPosition *arg2 = 0 ;
49335 wxGBSpan *arg3 = 0 ;
49336 int arg4 ;
49337 int arg5 ;
49338 PyObject *arg6 = (PyObject *) NULL ;
49339 wxGBSizerItem *result = 0 ;
49340 int res1 = 0 ;
49341 wxGBPosition temp2 ;
49342 wxGBSpan temp3 ;
49343 int val4 ;
49344 int ecode4 = 0 ;
49345 int val5 ;
49346 int ecode5 = 0 ;
49347 PyObject * obj0 = 0 ;
49348 PyObject * obj1 = 0 ;
49349 PyObject * obj2 = 0 ;
49350 PyObject * obj3 = 0 ;
49351 PyObject * obj4 = 0 ;
49352 PyObject * obj5 = 0 ;
49353 char * kwnames[] = {
49354 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49355 };
49356
49357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49358 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49359 if (!SWIG_IsOK(res1)) {
49360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49361 }
49362 {
49363 arg2 = &temp2;
49364 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49365 }
49366 {
49367 arg3 = &temp3;
49368 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49369 }
49370 ecode4 = SWIG_AsVal_int(obj3, &val4);
49371 if (!SWIG_IsOK(ecode4)) {
49372 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49373 }
49374 arg4 = static_cast< int >(val4);
49375 ecode5 = SWIG_AsVal_int(obj4, &val5);
49376 if (!SWIG_IsOK(ecode5)) {
49377 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49378 }
49379 arg5 = static_cast< int >(val5);
49380 if (obj5) {
49381 arg6 = obj5;
49382 }
49383 {
49384 PyThreadState* __tstate = wxPyBeginAllowThreads();
49385 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49386 wxPyEndAllowThreads(__tstate);
49387 if (PyErr_Occurred()) SWIG_fail;
49388 }
49389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49390 return resultobj;
49391 fail:
49392 return NULL;
49393 }
49394
49395
49396 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49397 PyObject *resultobj = 0;
49398 int arg1 ;
49399 int arg2 ;
49400 wxGBPosition *arg3 = 0 ;
49401 wxGBSpan *arg4 = 0 ;
49402 int arg5 ;
49403 int arg6 ;
49404 PyObject *arg7 = (PyObject *) NULL ;
49405 wxGBSizerItem *result = 0 ;
49406 int val1 ;
49407 int ecode1 = 0 ;
49408 int val2 ;
49409 int ecode2 = 0 ;
49410 wxGBPosition temp3 ;
49411 wxGBSpan temp4 ;
49412 int val5 ;
49413 int ecode5 = 0 ;
49414 int val6 ;
49415 int ecode6 = 0 ;
49416 PyObject * obj0 = 0 ;
49417 PyObject * obj1 = 0 ;
49418 PyObject * obj2 = 0 ;
49419 PyObject * obj3 = 0 ;
49420 PyObject * obj4 = 0 ;
49421 PyObject * obj5 = 0 ;
49422 PyObject * obj6 = 0 ;
49423 char * kwnames[] = {
49424 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49425 };
49426
49427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49428 ecode1 = SWIG_AsVal_int(obj0, &val1);
49429 if (!SWIG_IsOK(ecode1)) {
49430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49431 }
49432 arg1 = static_cast< int >(val1);
49433 ecode2 = SWIG_AsVal_int(obj1, &val2);
49434 if (!SWIG_IsOK(ecode2)) {
49435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49436 }
49437 arg2 = static_cast< int >(val2);
49438 {
49439 arg3 = &temp3;
49440 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49441 }
49442 {
49443 arg4 = &temp4;
49444 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49445 }
49446 ecode5 = SWIG_AsVal_int(obj4, &val5);
49447 if (!SWIG_IsOK(ecode5)) {
49448 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49449 }
49450 arg5 = static_cast< int >(val5);
49451 ecode6 = SWIG_AsVal_int(obj5, &val6);
49452 if (!SWIG_IsOK(ecode6)) {
49453 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49454 }
49455 arg6 = static_cast< int >(val6);
49456 if (obj6) {
49457 arg7 = obj6;
49458 }
49459 {
49460 PyThreadState* __tstate = wxPyBeginAllowThreads();
49461 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49462 wxPyEndAllowThreads(__tstate);
49463 if (PyErr_Occurred()) SWIG_fail;
49464 }
49465 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49466 return resultobj;
49467 fail:
49468 return NULL;
49469 }
49470
49471
49472 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49473 PyObject *resultobj = 0;
49474 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49475 wxGBPosition result;
49476 void *argp1 = 0 ;
49477 int res1 = 0 ;
49478 PyObject *swig_obj[1] ;
49479
49480 if (!args) SWIG_fail;
49481 swig_obj[0] = args;
49482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49483 if (!SWIG_IsOK(res1)) {
49484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49485 }
49486 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49487 {
49488 PyThreadState* __tstate = wxPyBeginAllowThreads();
49489 result = ((wxGBSizerItem const *)arg1)->GetPos();
49490 wxPyEndAllowThreads(__tstate);
49491 if (PyErr_Occurred()) SWIG_fail;
49492 }
49493 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49494 return resultobj;
49495 fail:
49496 return NULL;
49497 }
49498
49499
49500 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49501 PyObject *resultobj = 0;
49502 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49503 wxGBSpan result;
49504 void *argp1 = 0 ;
49505 int res1 = 0 ;
49506 PyObject *swig_obj[1] ;
49507
49508 if (!args) SWIG_fail;
49509 swig_obj[0] = args;
49510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49511 if (!SWIG_IsOK(res1)) {
49512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49513 }
49514 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49515 {
49516 PyThreadState* __tstate = wxPyBeginAllowThreads();
49517 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49522 return resultobj;
49523 fail:
49524 return NULL;
49525 }
49526
49527
49528 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49529 PyObject *resultobj = 0;
49530 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49531 wxGBPosition *arg2 = 0 ;
49532 bool result;
49533 void *argp1 = 0 ;
49534 int res1 = 0 ;
49535 wxGBPosition temp2 ;
49536 PyObject * obj0 = 0 ;
49537 PyObject * obj1 = 0 ;
49538 char * kwnames[] = {
49539 (char *) "self",(char *) "pos", NULL
49540 };
49541
49542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49544 if (!SWIG_IsOK(res1)) {
49545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49546 }
49547 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49548 {
49549 arg2 = &temp2;
49550 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49551 }
49552 {
49553 PyThreadState* __tstate = wxPyBeginAllowThreads();
49554 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
49555 wxPyEndAllowThreads(__tstate);
49556 if (PyErr_Occurred()) SWIG_fail;
49557 }
49558 {
49559 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49560 }
49561 return resultobj;
49562 fail:
49563 return NULL;
49564 }
49565
49566
49567 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49568 PyObject *resultobj = 0;
49569 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49570 wxGBSpan *arg2 = 0 ;
49571 bool result;
49572 void *argp1 = 0 ;
49573 int res1 = 0 ;
49574 wxGBSpan temp2 ;
49575 PyObject * obj0 = 0 ;
49576 PyObject * obj1 = 0 ;
49577 char * kwnames[] = {
49578 (char *) "self",(char *) "span", NULL
49579 };
49580
49581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49583 if (!SWIG_IsOK(res1)) {
49584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49585 }
49586 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49587 {
49588 arg2 = &temp2;
49589 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49590 }
49591 {
49592 PyThreadState* __tstate = wxPyBeginAllowThreads();
49593 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49594 wxPyEndAllowThreads(__tstate);
49595 if (PyErr_Occurred()) SWIG_fail;
49596 }
49597 {
49598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49599 }
49600 return resultobj;
49601 fail:
49602 return NULL;
49603 }
49604
49605
49606 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49607 PyObject *resultobj = 0;
49608 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49609 wxGBSizerItem *arg2 = 0 ;
49610 bool result;
49611 void *argp1 = 0 ;
49612 int res1 = 0 ;
49613 void *argp2 = 0 ;
49614 int res2 = 0 ;
49615 PyObject * obj0 = 0 ;
49616 PyObject * obj1 = 0 ;
49617 char * kwnames[] = {
49618 (char *) "self",(char *) "other", NULL
49619 };
49620
49621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49623 if (!SWIG_IsOK(res1)) {
49624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49625 }
49626 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49627 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49628 if (!SWIG_IsOK(res2)) {
49629 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49630 }
49631 if (!argp2) {
49632 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49633 }
49634 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49635 {
49636 PyThreadState* __tstate = wxPyBeginAllowThreads();
49637 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49638 wxPyEndAllowThreads(__tstate);
49639 if (PyErr_Occurred()) SWIG_fail;
49640 }
49641 {
49642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49643 }
49644 return resultobj;
49645 fail:
49646 return NULL;
49647 }
49648
49649
49650 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49651 PyObject *resultobj = 0;
49652 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49653 wxGBPosition *arg2 = 0 ;
49654 wxGBSpan *arg3 = 0 ;
49655 bool result;
49656 void *argp1 = 0 ;
49657 int res1 = 0 ;
49658 wxGBPosition temp2 ;
49659 wxGBSpan temp3 ;
49660 PyObject * obj0 = 0 ;
49661 PyObject * obj1 = 0 ;
49662 PyObject * obj2 = 0 ;
49663 char * kwnames[] = {
49664 (char *) "self",(char *) "pos",(char *) "span", NULL
49665 };
49666
49667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49669 if (!SWIG_IsOK(res1)) {
49670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49671 }
49672 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49673 {
49674 arg2 = &temp2;
49675 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49676 }
49677 {
49678 arg3 = &temp3;
49679 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49680 }
49681 {
49682 PyThreadState* __tstate = wxPyBeginAllowThreads();
49683 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49684 wxPyEndAllowThreads(__tstate);
49685 if (PyErr_Occurred()) SWIG_fail;
49686 }
49687 {
49688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49689 }
49690 return resultobj;
49691 fail:
49692 return NULL;
49693 }
49694
49695
49696 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49697 PyObject *resultobj = 0;
49698 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49699 wxGBPosition result;
49700 void *argp1 = 0 ;
49701 int res1 = 0 ;
49702 PyObject *swig_obj[1] ;
49703
49704 if (!args) SWIG_fail;
49705 swig_obj[0] = args;
49706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49707 if (!SWIG_IsOK(res1)) {
49708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49709 }
49710 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49711 {
49712 PyThreadState* __tstate = wxPyBeginAllowThreads();
49713 result = wxGBSizerItem_GetEndPos(arg1);
49714 wxPyEndAllowThreads(__tstate);
49715 if (PyErr_Occurred()) SWIG_fail;
49716 }
49717 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49718 return resultobj;
49719 fail:
49720 return NULL;
49721 }
49722
49723
49724 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49725 PyObject *resultobj = 0;
49726 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49727 wxGridBagSizer *result = 0 ;
49728 void *argp1 = 0 ;
49729 int res1 = 0 ;
49730 PyObject *swig_obj[1] ;
49731
49732 if (!args) SWIG_fail;
49733 swig_obj[0] = args;
49734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49735 if (!SWIG_IsOK(res1)) {
49736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49737 }
49738 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49739 {
49740 PyThreadState* __tstate = wxPyBeginAllowThreads();
49741 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49742 wxPyEndAllowThreads(__tstate);
49743 if (PyErr_Occurred()) SWIG_fail;
49744 }
49745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49746 return resultobj;
49747 fail:
49748 return NULL;
49749 }
49750
49751
49752 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49753 PyObject *resultobj = 0;
49754 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49755 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49756 void *argp1 = 0 ;
49757 int res1 = 0 ;
49758 void *argp2 = 0 ;
49759 int res2 = 0 ;
49760 PyObject * obj0 = 0 ;
49761 PyObject * obj1 = 0 ;
49762 char * kwnames[] = {
49763 (char *) "self",(char *) "sizer", NULL
49764 };
49765
49766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49768 if (!SWIG_IsOK(res1)) {
49769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49770 }
49771 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49773 if (!SWIG_IsOK(res2)) {
49774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49775 }
49776 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49777 {
49778 PyThreadState* __tstate = wxPyBeginAllowThreads();
49779 (arg1)->SetGBSizer(arg2);
49780 wxPyEndAllowThreads(__tstate);
49781 if (PyErr_Occurred()) SWIG_fail;
49782 }
49783 resultobj = SWIG_Py_Void();
49784 return resultobj;
49785 fail:
49786 return NULL;
49787 }
49788
49789
49790 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49791 PyObject *obj;
49792 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49793 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
49794 return SWIG_Py_Void();
49795 }
49796
49797 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49798 return SWIG_Python_InitShadowInstance(args);
49799 }
49800
49801 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49802 PyObject *resultobj = 0;
49803 int arg1 = (int) 0 ;
49804 int arg2 = (int) 0 ;
49805 wxGridBagSizer *result = 0 ;
49806 int val1 ;
49807 int ecode1 = 0 ;
49808 int val2 ;
49809 int ecode2 = 0 ;
49810 PyObject * obj0 = 0 ;
49811 PyObject * obj1 = 0 ;
49812 char * kwnames[] = {
49813 (char *) "vgap",(char *) "hgap", NULL
49814 };
49815
49816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49817 if (obj0) {
49818 ecode1 = SWIG_AsVal_int(obj0, &val1);
49819 if (!SWIG_IsOK(ecode1)) {
49820 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
49821 }
49822 arg1 = static_cast< int >(val1);
49823 }
49824 if (obj1) {
49825 ecode2 = SWIG_AsVal_int(obj1, &val2);
49826 if (!SWIG_IsOK(ecode2)) {
49827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
49828 }
49829 arg2 = static_cast< int >(val2);
49830 }
49831 {
49832 PyThreadState* __tstate = wxPyBeginAllowThreads();
49833 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
49834 wxPyEndAllowThreads(__tstate);
49835 if (PyErr_Occurred()) SWIG_fail;
49836 }
49837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
49838 return resultobj;
49839 fail:
49840 return NULL;
49841 }
49842
49843
49844 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49845 PyObject *resultobj = 0;
49846 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49847 PyObject *arg2 = (PyObject *) 0 ;
49848 wxGBPosition *arg3 = 0 ;
49849 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
49850 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
49851 int arg5 = (int) 0 ;
49852 int arg6 = (int) 0 ;
49853 PyObject *arg7 = (PyObject *) NULL ;
49854 wxGBSizerItem *result = 0 ;
49855 void *argp1 = 0 ;
49856 int res1 = 0 ;
49857 wxGBPosition temp3 ;
49858 wxGBSpan temp4 ;
49859 int val5 ;
49860 int ecode5 = 0 ;
49861 int val6 ;
49862 int ecode6 = 0 ;
49863 PyObject * obj0 = 0 ;
49864 PyObject * obj1 = 0 ;
49865 PyObject * obj2 = 0 ;
49866 PyObject * obj3 = 0 ;
49867 PyObject * obj4 = 0 ;
49868 PyObject * obj5 = 0 ;
49869 PyObject * obj6 = 0 ;
49870 char * kwnames[] = {
49871 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49872 };
49873
49874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49876 if (!SWIG_IsOK(res1)) {
49877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49878 }
49879 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49880 arg2 = obj1;
49881 {
49882 arg3 = &temp3;
49883 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49884 }
49885 if (obj3) {
49886 {
49887 arg4 = &temp4;
49888 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49889 }
49890 }
49891 if (obj4) {
49892 ecode5 = SWIG_AsVal_int(obj4, &val5);
49893 if (!SWIG_IsOK(ecode5)) {
49894 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
49895 }
49896 arg5 = static_cast< int >(val5);
49897 }
49898 if (obj5) {
49899 ecode6 = SWIG_AsVal_int(obj5, &val6);
49900 if (!SWIG_IsOK(ecode6)) {
49901 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
49902 }
49903 arg6 = static_cast< int >(val6);
49904 }
49905 if (obj6) {
49906 arg7 = obj6;
49907 }
49908 {
49909 PyThreadState* __tstate = wxPyBeginAllowThreads();
49910 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49911 wxPyEndAllowThreads(__tstate);
49912 if (PyErr_Occurred()) SWIG_fail;
49913 }
49914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49915 return resultobj;
49916 fail:
49917 return NULL;
49918 }
49919
49920
49921 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49922 PyObject *resultobj = 0;
49923 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49924 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
49925 wxGBSizerItem *result = 0 ;
49926 void *argp1 = 0 ;
49927 int res1 = 0 ;
49928 int res2 = 0 ;
49929 PyObject * obj0 = 0 ;
49930 PyObject * obj1 = 0 ;
49931 char * kwnames[] = {
49932 (char *) "self",(char *) "item", NULL
49933 };
49934
49935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
49936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49937 if (!SWIG_IsOK(res1)) {
49938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
49939 }
49940 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49941 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49942 if (!SWIG_IsOK(res2)) {
49943 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
49944 }
49945 {
49946 PyThreadState* __tstate = wxPyBeginAllowThreads();
49947 result = (wxGBSizerItem *)(arg1)->Add(arg2);
49948 wxPyEndAllowThreads(__tstate);
49949 if (PyErr_Occurred()) SWIG_fail;
49950 }
49951 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49952 return resultobj;
49953 fail:
49954 return NULL;
49955 }
49956
49957
49958 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49959 PyObject *resultobj = 0;
49960 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
49961 int arg2 ;
49962 int arg3 ;
49963 wxSize result;
49964 void *argp1 = 0 ;
49965 int res1 = 0 ;
49966 int val2 ;
49967 int ecode2 = 0 ;
49968 int val3 ;
49969 int ecode3 = 0 ;
49970 PyObject * obj0 = 0 ;
49971 PyObject * obj1 = 0 ;
49972 PyObject * obj2 = 0 ;
49973 char * kwnames[] = {
49974 (char *) "self",(char *) "row",(char *) "col", NULL
49975 };
49976
49977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49979 if (!SWIG_IsOK(res1)) {
49980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
49981 }
49982 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
49983 ecode2 = SWIG_AsVal_int(obj1, &val2);
49984 if (!SWIG_IsOK(ecode2)) {
49985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
49986 }
49987 arg2 = static_cast< int >(val2);
49988 ecode3 = SWIG_AsVal_int(obj2, &val3);
49989 if (!SWIG_IsOK(ecode3)) {
49990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
49991 }
49992 arg3 = static_cast< int >(val3);
49993 {
49994 PyThreadState* __tstate = wxPyBeginAllowThreads();
49995 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
49996 wxPyEndAllowThreads(__tstate);
49997 if (PyErr_Occurred()) SWIG_fail;
49998 }
49999 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50000 return resultobj;
50001 fail:
50002 return NULL;
50003 }
50004
50005
50006 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50007 PyObject *resultobj = 0;
50008 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50009 wxSize result;
50010 void *argp1 = 0 ;
50011 int res1 = 0 ;
50012 PyObject *swig_obj[1] ;
50013
50014 if (!args) SWIG_fail;
50015 swig_obj[0] = args;
50016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50017 if (!SWIG_IsOK(res1)) {
50018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50019 }
50020 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50021 {
50022 PyThreadState* __tstate = wxPyBeginAllowThreads();
50023 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50024 wxPyEndAllowThreads(__tstate);
50025 if (PyErr_Occurred()) SWIG_fail;
50026 }
50027 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50028 return resultobj;
50029 fail:
50030 return NULL;
50031 }
50032
50033
50034 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50035 PyObject *resultobj = 0;
50036 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50037 wxSize *arg2 = 0 ;
50038 void *argp1 = 0 ;
50039 int res1 = 0 ;
50040 wxSize temp2 ;
50041 PyObject * obj0 = 0 ;
50042 PyObject * obj1 = 0 ;
50043 char * kwnames[] = {
50044 (char *) "self",(char *) "sz", NULL
50045 };
50046
50047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50049 if (!SWIG_IsOK(res1)) {
50050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50051 }
50052 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50053 {
50054 arg2 = &temp2;
50055 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50056 }
50057 {
50058 PyThreadState* __tstate = wxPyBeginAllowThreads();
50059 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50060 wxPyEndAllowThreads(__tstate);
50061 if (PyErr_Occurred()) SWIG_fail;
50062 }
50063 resultobj = SWIG_Py_Void();
50064 return resultobj;
50065 fail:
50066 return NULL;
50067 }
50068
50069
50070 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50071 PyObject *resultobj = 0;
50072 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50073 wxWindow *arg2 = (wxWindow *) 0 ;
50074 wxGBPosition result;
50075 void *argp1 = 0 ;
50076 int res1 = 0 ;
50077 void *argp2 = 0 ;
50078 int res2 = 0 ;
50079
50080 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50082 if (!SWIG_IsOK(res1)) {
50083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50084 }
50085 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50086 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50087 if (!SWIG_IsOK(res2)) {
50088 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50089 }
50090 arg2 = reinterpret_cast< wxWindow * >(argp2);
50091 {
50092 PyThreadState* __tstate = wxPyBeginAllowThreads();
50093 result = (arg1)->GetItemPosition(arg2);
50094 wxPyEndAllowThreads(__tstate);
50095 if (PyErr_Occurred()) SWIG_fail;
50096 }
50097 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50098 return resultobj;
50099 fail:
50100 return NULL;
50101 }
50102
50103
50104 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50105 PyObject *resultobj = 0;
50106 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50107 wxSizer *arg2 = (wxSizer *) 0 ;
50108 wxGBPosition result;
50109 void *argp1 = 0 ;
50110 int res1 = 0 ;
50111 void *argp2 = 0 ;
50112 int res2 = 0 ;
50113
50114 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50116 if (!SWIG_IsOK(res1)) {
50117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50118 }
50119 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50120 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50121 if (!SWIG_IsOK(res2)) {
50122 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50123 }
50124 arg2 = reinterpret_cast< wxSizer * >(argp2);
50125 {
50126 PyThreadState* __tstate = wxPyBeginAllowThreads();
50127 result = (arg1)->GetItemPosition(arg2);
50128 wxPyEndAllowThreads(__tstate);
50129 if (PyErr_Occurred()) SWIG_fail;
50130 }
50131 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50132 return resultobj;
50133 fail:
50134 return NULL;
50135 }
50136
50137
50138 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50139 PyObject *resultobj = 0;
50140 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50141 size_t arg2 ;
50142 wxGBPosition result;
50143 void *argp1 = 0 ;
50144 int res1 = 0 ;
50145 size_t val2 ;
50146 int ecode2 = 0 ;
50147
50148 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50150 if (!SWIG_IsOK(res1)) {
50151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50152 }
50153 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50154 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50155 if (!SWIG_IsOK(ecode2)) {
50156 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50157 }
50158 arg2 = static_cast< size_t >(val2);
50159 {
50160 PyThreadState* __tstate = wxPyBeginAllowThreads();
50161 result = (arg1)->GetItemPosition(arg2);
50162 wxPyEndAllowThreads(__tstate);
50163 if (PyErr_Occurred()) SWIG_fail;
50164 }
50165 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50166 return resultobj;
50167 fail:
50168 return NULL;
50169 }
50170
50171
50172 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50173 int argc;
50174 PyObject *argv[3];
50175
50176 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50177 --argc;
50178 if (argc == 2) {
50179 int _v = 0;
50180 {
50181 void *vptr = 0;
50182 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50183 _v = SWIG_CheckState(res);
50184 }
50185 if (!_v) goto check_1;
50186 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50187 }
50188 check_1:
50189
50190 if (argc == 2) {
50191 int _v = 0;
50192 {
50193 void *vptr = 0;
50194 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50195 _v = SWIG_CheckState(res);
50196 }
50197 if (!_v) goto check_2;
50198 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50199 }
50200 check_2:
50201
50202 if (argc == 2) {
50203 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50204 }
50205
50206 fail:
50207 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50208 return NULL;
50209 }
50210
50211
50212 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50213 PyObject *resultobj = 0;
50214 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50215 wxWindow *arg2 = (wxWindow *) 0 ;
50216 wxGBPosition *arg3 = 0 ;
50217 bool result;
50218 void *argp1 = 0 ;
50219 int res1 = 0 ;
50220 void *argp2 = 0 ;
50221 int res2 = 0 ;
50222 wxGBPosition temp3 ;
50223
50224 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50226 if (!SWIG_IsOK(res1)) {
50227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50228 }
50229 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50230 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50231 if (!SWIG_IsOK(res2)) {
50232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50233 }
50234 arg2 = reinterpret_cast< wxWindow * >(argp2);
50235 {
50236 arg3 = &temp3;
50237 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50238 }
50239 {
50240 PyThreadState* __tstate = wxPyBeginAllowThreads();
50241 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50242 wxPyEndAllowThreads(__tstate);
50243 if (PyErr_Occurred()) SWIG_fail;
50244 }
50245 {
50246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50247 }
50248 return resultobj;
50249 fail:
50250 return NULL;
50251 }
50252
50253
50254 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50255 PyObject *resultobj = 0;
50256 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50257 wxSizer *arg2 = (wxSizer *) 0 ;
50258 wxGBPosition *arg3 = 0 ;
50259 bool result;
50260 void *argp1 = 0 ;
50261 int res1 = 0 ;
50262 void *argp2 = 0 ;
50263 int res2 = 0 ;
50264 wxGBPosition temp3 ;
50265
50266 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50268 if (!SWIG_IsOK(res1)) {
50269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50270 }
50271 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50272 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50273 if (!SWIG_IsOK(res2)) {
50274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50275 }
50276 arg2 = reinterpret_cast< wxSizer * >(argp2);
50277 {
50278 arg3 = &temp3;
50279 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50280 }
50281 {
50282 PyThreadState* __tstate = wxPyBeginAllowThreads();
50283 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50284 wxPyEndAllowThreads(__tstate);
50285 if (PyErr_Occurred()) SWIG_fail;
50286 }
50287 {
50288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50289 }
50290 return resultobj;
50291 fail:
50292 return NULL;
50293 }
50294
50295
50296 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50297 PyObject *resultobj = 0;
50298 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50299 size_t arg2 ;
50300 wxGBPosition *arg3 = 0 ;
50301 bool result;
50302 void *argp1 = 0 ;
50303 int res1 = 0 ;
50304 size_t val2 ;
50305 int ecode2 = 0 ;
50306 wxGBPosition temp3 ;
50307
50308 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50310 if (!SWIG_IsOK(res1)) {
50311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50312 }
50313 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50314 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50315 if (!SWIG_IsOK(ecode2)) {
50316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50317 }
50318 arg2 = static_cast< size_t >(val2);
50319 {
50320 arg3 = &temp3;
50321 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50322 }
50323 {
50324 PyThreadState* __tstate = wxPyBeginAllowThreads();
50325 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50326 wxPyEndAllowThreads(__tstate);
50327 if (PyErr_Occurred()) SWIG_fail;
50328 }
50329 {
50330 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50331 }
50332 return resultobj;
50333 fail:
50334 return NULL;
50335 }
50336
50337
50338 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50339 int argc;
50340 PyObject *argv[4];
50341
50342 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50343 --argc;
50344 if (argc == 3) {
50345 int _v = 0;
50346 {
50347 void *vptr = 0;
50348 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50349 _v = SWIG_CheckState(res);
50350 }
50351 if (!_v) goto check_1;
50352 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50353 }
50354 check_1:
50355
50356 if (argc == 3) {
50357 int _v = 0;
50358 {
50359 void *vptr = 0;
50360 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50361 _v = SWIG_CheckState(res);
50362 }
50363 if (!_v) goto check_2;
50364 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50365 }
50366 check_2:
50367
50368 if (argc == 3) {
50369 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50370 }
50371
50372 fail:
50373 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50374 return NULL;
50375 }
50376
50377
50378 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50379 PyObject *resultobj = 0;
50380 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50381 wxWindow *arg2 = (wxWindow *) 0 ;
50382 wxGBSpan result;
50383 void *argp1 = 0 ;
50384 int res1 = 0 ;
50385 void *argp2 = 0 ;
50386 int res2 = 0 ;
50387
50388 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50390 if (!SWIG_IsOK(res1)) {
50391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50392 }
50393 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50394 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50395 if (!SWIG_IsOK(res2)) {
50396 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50397 }
50398 arg2 = reinterpret_cast< wxWindow * >(argp2);
50399 {
50400 PyThreadState* __tstate = wxPyBeginAllowThreads();
50401 result = (arg1)->GetItemSpan(arg2);
50402 wxPyEndAllowThreads(__tstate);
50403 if (PyErr_Occurred()) SWIG_fail;
50404 }
50405 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50406 return resultobj;
50407 fail:
50408 return NULL;
50409 }
50410
50411
50412 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50413 PyObject *resultobj = 0;
50414 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50415 wxSizer *arg2 = (wxSizer *) 0 ;
50416 wxGBSpan result;
50417 void *argp1 = 0 ;
50418 int res1 = 0 ;
50419 void *argp2 = 0 ;
50420 int res2 = 0 ;
50421
50422 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50424 if (!SWIG_IsOK(res1)) {
50425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50426 }
50427 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50428 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50429 if (!SWIG_IsOK(res2)) {
50430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50431 }
50432 arg2 = reinterpret_cast< wxSizer * >(argp2);
50433 {
50434 PyThreadState* __tstate = wxPyBeginAllowThreads();
50435 result = (arg1)->GetItemSpan(arg2);
50436 wxPyEndAllowThreads(__tstate);
50437 if (PyErr_Occurred()) SWIG_fail;
50438 }
50439 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50440 return resultobj;
50441 fail:
50442 return NULL;
50443 }
50444
50445
50446 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50447 PyObject *resultobj = 0;
50448 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50449 size_t arg2 ;
50450 wxGBSpan result;
50451 void *argp1 = 0 ;
50452 int res1 = 0 ;
50453 size_t val2 ;
50454 int ecode2 = 0 ;
50455
50456 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50458 if (!SWIG_IsOK(res1)) {
50459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50460 }
50461 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50462 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50463 if (!SWIG_IsOK(ecode2)) {
50464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50465 }
50466 arg2 = static_cast< size_t >(val2);
50467 {
50468 PyThreadState* __tstate = wxPyBeginAllowThreads();
50469 result = (arg1)->GetItemSpan(arg2);
50470 wxPyEndAllowThreads(__tstate);
50471 if (PyErr_Occurred()) SWIG_fail;
50472 }
50473 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50474 return resultobj;
50475 fail:
50476 return NULL;
50477 }
50478
50479
50480 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50481 int argc;
50482 PyObject *argv[3];
50483
50484 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50485 --argc;
50486 if (argc == 2) {
50487 int _v = 0;
50488 {
50489 void *vptr = 0;
50490 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50491 _v = SWIG_CheckState(res);
50492 }
50493 if (!_v) goto check_1;
50494 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50495 }
50496 check_1:
50497
50498 if (argc == 2) {
50499 int _v = 0;
50500 {
50501 void *vptr = 0;
50502 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50503 _v = SWIG_CheckState(res);
50504 }
50505 if (!_v) goto check_2;
50506 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50507 }
50508 check_2:
50509
50510 if (argc == 2) {
50511 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50512 }
50513
50514 fail:
50515 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50516 return NULL;
50517 }
50518
50519
50520 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50521 PyObject *resultobj = 0;
50522 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50523 wxWindow *arg2 = (wxWindow *) 0 ;
50524 wxGBSpan *arg3 = 0 ;
50525 bool result;
50526 void *argp1 = 0 ;
50527 int res1 = 0 ;
50528 void *argp2 = 0 ;
50529 int res2 = 0 ;
50530 wxGBSpan temp3 ;
50531
50532 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50534 if (!SWIG_IsOK(res1)) {
50535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50536 }
50537 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50538 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50539 if (!SWIG_IsOK(res2)) {
50540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50541 }
50542 arg2 = reinterpret_cast< wxWindow * >(argp2);
50543 {
50544 arg3 = &temp3;
50545 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50546 }
50547 {
50548 PyThreadState* __tstate = wxPyBeginAllowThreads();
50549 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50550 wxPyEndAllowThreads(__tstate);
50551 if (PyErr_Occurred()) SWIG_fail;
50552 }
50553 {
50554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50555 }
50556 return resultobj;
50557 fail:
50558 return NULL;
50559 }
50560
50561
50562 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50563 PyObject *resultobj = 0;
50564 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50565 wxSizer *arg2 = (wxSizer *) 0 ;
50566 wxGBSpan *arg3 = 0 ;
50567 bool result;
50568 void *argp1 = 0 ;
50569 int res1 = 0 ;
50570 void *argp2 = 0 ;
50571 int res2 = 0 ;
50572 wxGBSpan temp3 ;
50573
50574 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50576 if (!SWIG_IsOK(res1)) {
50577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50578 }
50579 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50580 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50581 if (!SWIG_IsOK(res2)) {
50582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50583 }
50584 arg2 = reinterpret_cast< wxSizer * >(argp2);
50585 {
50586 arg3 = &temp3;
50587 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50588 }
50589 {
50590 PyThreadState* __tstate = wxPyBeginAllowThreads();
50591 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50592 wxPyEndAllowThreads(__tstate);
50593 if (PyErr_Occurred()) SWIG_fail;
50594 }
50595 {
50596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50597 }
50598 return resultobj;
50599 fail:
50600 return NULL;
50601 }
50602
50603
50604 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50605 PyObject *resultobj = 0;
50606 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50607 size_t arg2 ;
50608 wxGBSpan *arg3 = 0 ;
50609 bool result;
50610 void *argp1 = 0 ;
50611 int res1 = 0 ;
50612 size_t val2 ;
50613 int ecode2 = 0 ;
50614 wxGBSpan temp3 ;
50615
50616 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50618 if (!SWIG_IsOK(res1)) {
50619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50620 }
50621 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50622 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50623 if (!SWIG_IsOK(ecode2)) {
50624 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50625 }
50626 arg2 = static_cast< size_t >(val2);
50627 {
50628 arg3 = &temp3;
50629 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50630 }
50631 {
50632 PyThreadState* __tstate = wxPyBeginAllowThreads();
50633 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50634 wxPyEndAllowThreads(__tstate);
50635 if (PyErr_Occurred()) SWIG_fail;
50636 }
50637 {
50638 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50639 }
50640 return resultobj;
50641 fail:
50642 return NULL;
50643 }
50644
50645
50646 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50647 int argc;
50648 PyObject *argv[4];
50649
50650 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50651 --argc;
50652 if (argc == 3) {
50653 int _v = 0;
50654 {
50655 void *vptr = 0;
50656 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50657 _v = SWIG_CheckState(res);
50658 }
50659 if (!_v) goto check_1;
50660 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50661 }
50662 check_1:
50663
50664 if (argc == 3) {
50665 int _v = 0;
50666 {
50667 void *vptr = 0;
50668 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50669 _v = SWIG_CheckState(res);
50670 }
50671 if (!_v) goto check_2;
50672 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50673 }
50674 check_2:
50675
50676 if (argc == 3) {
50677 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50678 }
50679
50680 fail:
50681 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50682 return NULL;
50683 }
50684
50685
50686 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50687 PyObject *resultobj = 0;
50688 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50689 wxWindow *arg2 = (wxWindow *) 0 ;
50690 wxGBSizerItem *result = 0 ;
50691 void *argp1 = 0 ;
50692 int res1 = 0 ;
50693 void *argp2 = 0 ;
50694 int res2 = 0 ;
50695
50696 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50698 if (!SWIG_IsOK(res1)) {
50699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50700 }
50701 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50702 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50703 if (!SWIG_IsOK(res2)) {
50704 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50705 }
50706 arg2 = reinterpret_cast< wxWindow * >(argp2);
50707 {
50708 PyThreadState* __tstate = wxPyBeginAllowThreads();
50709 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50710 wxPyEndAllowThreads(__tstate);
50711 if (PyErr_Occurred()) SWIG_fail;
50712 }
50713 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50714 return resultobj;
50715 fail:
50716 return NULL;
50717 }
50718
50719
50720 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50721 PyObject *resultobj = 0;
50722 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50723 wxSizer *arg2 = (wxSizer *) 0 ;
50724 wxGBSizerItem *result = 0 ;
50725 void *argp1 = 0 ;
50726 int res1 = 0 ;
50727 void *argp2 = 0 ;
50728 int res2 = 0 ;
50729
50730 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50731 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50732 if (!SWIG_IsOK(res1)) {
50733 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50734 }
50735 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50736 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50737 if (!SWIG_IsOK(res2)) {
50738 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50739 }
50740 arg2 = reinterpret_cast< wxSizer * >(argp2);
50741 {
50742 PyThreadState* __tstate = wxPyBeginAllowThreads();
50743 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50744 wxPyEndAllowThreads(__tstate);
50745 if (PyErr_Occurred()) SWIG_fail;
50746 }
50747 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50748 return resultobj;
50749 fail:
50750 return NULL;
50751 }
50752
50753
50754 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50755 int argc;
50756 PyObject *argv[3];
50757
50758 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50759 --argc;
50760 if (argc == 2) {
50761 int _v = 0;
50762 {
50763 void *vptr = 0;
50764 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50765 _v = SWIG_CheckState(res);
50766 }
50767 if (!_v) goto check_1;
50768 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50769 }
50770 check_1:
50771
50772 if (argc == 2) {
50773 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50774 }
50775
50776 fail:
50777 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50778 return NULL;
50779 }
50780
50781
50782 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50783 PyObject *resultobj = 0;
50784 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50785 wxGBPosition *arg2 = 0 ;
50786 wxGBSizerItem *result = 0 ;
50787 void *argp1 = 0 ;
50788 int res1 = 0 ;
50789 wxGBPosition temp2 ;
50790 PyObject * obj0 = 0 ;
50791 PyObject * obj1 = 0 ;
50792 char * kwnames[] = {
50793 (char *) "self",(char *) "pos", NULL
50794 };
50795
50796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
50797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50798 if (!SWIG_IsOK(res1)) {
50799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50800 }
50801 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50802 {
50803 arg2 = &temp2;
50804 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50805 }
50806 {
50807 PyThreadState* __tstate = wxPyBeginAllowThreads();
50808 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
50809 wxPyEndAllowThreads(__tstate);
50810 if (PyErr_Occurred()) SWIG_fail;
50811 }
50812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50813 return resultobj;
50814 fail:
50815 return NULL;
50816 }
50817
50818
50819 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50820 PyObject *resultobj = 0;
50821 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50822 wxPoint *arg2 = 0 ;
50823 wxGBSizerItem *result = 0 ;
50824 void *argp1 = 0 ;
50825 int res1 = 0 ;
50826 wxPoint temp2 ;
50827 PyObject * obj0 = 0 ;
50828 PyObject * obj1 = 0 ;
50829 char * kwnames[] = {
50830 (char *) "self",(char *) "pt", NULL
50831 };
50832
50833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
50834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50835 if (!SWIG_IsOK(res1)) {
50836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50837 }
50838 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50839 {
50840 arg2 = &temp2;
50841 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
50842 }
50843 {
50844 PyThreadState* __tstate = wxPyBeginAllowThreads();
50845 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
50846 wxPyEndAllowThreads(__tstate);
50847 if (PyErr_Occurred()) SWIG_fail;
50848 }
50849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50850 return resultobj;
50851 fail:
50852 return NULL;
50853 }
50854
50855
50856 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50857 PyObject *resultobj = 0;
50858 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50859 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50860 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
50861 bool result;
50862 void *argp1 = 0 ;
50863 int res1 = 0 ;
50864 void *argp2 = 0 ;
50865 int res2 = 0 ;
50866 void *argp3 = 0 ;
50867 int res3 = 0 ;
50868 PyObject * obj0 = 0 ;
50869 PyObject * obj1 = 0 ;
50870 PyObject * obj2 = 0 ;
50871 char * kwnames[] = {
50872 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
50873 };
50874
50875 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50876 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50877 if (!SWIG_IsOK(res1)) {
50878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50879 }
50880 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50881 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50882 if (!SWIG_IsOK(res2)) {
50883 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50884 }
50885 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50886 if (obj2) {
50887 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50888 if (!SWIG_IsOK(res3)) {
50889 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
50890 }
50891 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
50892 }
50893 {
50894 PyThreadState* __tstate = wxPyBeginAllowThreads();
50895 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
50896 wxPyEndAllowThreads(__tstate);
50897 if (PyErr_Occurred()) SWIG_fail;
50898 }
50899 {
50900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50901 }
50902 return resultobj;
50903 fail:
50904 return NULL;
50905 }
50906
50907
50908 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50909 PyObject *resultobj = 0;
50910 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50911 wxGBPosition *arg2 = 0 ;
50912 wxGBSpan *arg3 = 0 ;
50913 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
50914 bool result;
50915 void *argp1 = 0 ;
50916 int res1 = 0 ;
50917 wxGBPosition temp2 ;
50918 wxGBSpan temp3 ;
50919 void *argp4 = 0 ;
50920 int res4 = 0 ;
50921 PyObject * obj0 = 0 ;
50922 PyObject * obj1 = 0 ;
50923 PyObject * obj2 = 0 ;
50924 PyObject * obj3 = 0 ;
50925 char * kwnames[] = {
50926 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
50927 };
50928
50929 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50930 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50931 if (!SWIG_IsOK(res1)) {
50932 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50933 }
50934 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50935 {
50936 arg2 = &temp2;
50937 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50938 }
50939 {
50940 arg3 = &temp3;
50941 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50942 }
50943 if (obj3) {
50944 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50945 if (!SWIG_IsOK(res4)) {
50946 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
50947 }
50948 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
50949 }
50950 {
50951 PyThreadState* __tstate = wxPyBeginAllowThreads();
50952 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
50953 wxPyEndAllowThreads(__tstate);
50954 if (PyErr_Occurred()) SWIG_fail;
50955 }
50956 {
50957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50958 }
50959 return resultobj;
50960 fail:
50961 return NULL;
50962 }
50963
50964
50965 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50966 PyObject *obj;
50967 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50968 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
50969 return SWIG_Py_Void();
50970 }
50971
50972 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50973 return SWIG_Python_InitShadowInstance(args);
50974 }
50975
50976 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50977 PyObject *resultobj = 0;
50978 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
50979 wxRelationship arg2 ;
50980 wxWindow *arg3 = (wxWindow *) 0 ;
50981 wxEdge arg4 ;
50982 int arg5 = (int) 0 ;
50983 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
50984 void *argp1 = 0 ;
50985 int res1 = 0 ;
50986 int val2 ;
50987 int ecode2 = 0 ;
50988 void *argp3 = 0 ;
50989 int res3 = 0 ;
50990 int val4 ;
50991 int ecode4 = 0 ;
50992 int val5 ;
50993 int ecode5 = 0 ;
50994 int val6 ;
50995 int ecode6 = 0 ;
50996 PyObject * obj0 = 0 ;
50997 PyObject * obj1 = 0 ;
50998 PyObject * obj2 = 0 ;
50999 PyObject * obj3 = 0 ;
51000 PyObject * obj4 = 0 ;
51001 PyObject * obj5 = 0 ;
51002 char * kwnames[] = {
51003 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51004 };
51005
51006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51008 if (!SWIG_IsOK(res1)) {
51009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51010 }
51011 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51012 ecode2 = SWIG_AsVal_int(obj1, &val2);
51013 if (!SWIG_IsOK(ecode2)) {
51014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51015 }
51016 arg2 = static_cast< wxRelationship >(val2);
51017 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51018 if (!SWIG_IsOK(res3)) {
51019 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51020 }
51021 arg3 = reinterpret_cast< wxWindow * >(argp3);
51022 ecode4 = SWIG_AsVal_int(obj3, &val4);
51023 if (!SWIG_IsOK(ecode4)) {
51024 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51025 }
51026 arg4 = static_cast< wxEdge >(val4);
51027 if (obj4) {
51028 ecode5 = SWIG_AsVal_int(obj4, &val5);
51029 if (!SWIG_IsOK(ecode5)) {
51030 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51031 }
51032 arg5 = static_cast< int >(val5);
51033 }
51034 if (obj5) {
51035 ecode6 = SWIG_AsVal_int(obj5, &val6);
51036 if (!SWIG_IsOK(ecode6)) {
51037 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51038 }
51039 arg6 = static_cast< int >(val6);
51040 }
51041 {
51042 PyThreadState* __tstate = wxPyBeginAllowThreads();
51043 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51044 wxPyEndAllowThreads(__tstate);
51045 if (PyErr_Occurred()) SWIG_fail;
51046 }
51047 resultobj = SWIG_Py_Void();
51048 return resultobj;
51049 fail:
51050 return NULL;
51051 }
51052
51053
51054 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51055 PyObject *resultobj = 0;
51056 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51057 wxWindow *arg2 = (wxWindow *) 0 ;
51058 int arg3 = (int) 0 ;
51059 void *argp1 = 0 ;
51060 int res1 = 0 ;
51061 void *argp2 = 0 ;
51062 int res2 = 0 ;
51063 int val3 ;
51064 int ecode3 = 0 ;
51065 PyObject * obj0 = 0 ;
51066 PyObject * obj1 = 0 ;
51067 PyObject * obj2 = 0 ;
51068 char * kwnames[] = {
51069 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51070 };
51071
51072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51074 if (!SWIG_IsOK(res1)) {
51075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51076 }
51077 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51078 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51079 if (!SWIG_IsOK(res2)) {
51080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51081 }
51082 arg2 = reinterpret_cast< wxWindow * >(argp2);
51083 if (obj2) {
51084 ecode3 = SWIG_AsVal_int(obj2, &val3);
51085 if (!SWIG_IsOK(ecode3)) {
51086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51087 }
51088 arg3 = static_cast< int >(val3);
51089 }
51090 {
51091 PyThreadState* __tstate = wxPyBeginAllowThreads();
51092 (arg1)->LeftOf(arg2,arg3);
51093 wxPyEndAllowThreads(__tstate);
51094 if (PyErr_Occurred()) SWIG_fail;
51095 }
51096 resultobj = SWIG_Py_Void();
51097 return resultobj;
51098 fail:
51099 return NULL;
51100 }
51101
51102
51103 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51104 PyObject *resultobj = 0;
51105 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51106 wxWindow *arg2 = (wxWindow *) 0 ;
51107 int arg3 = (int) 0 ;
51108 void *argp1 = 0 ;
51109 int res1 = 0 ;
51110 void *argp2 = 0 ;
51111 int res2 = 0 ;
51112 int val3 ;
51113 int ecode3 = 0 ;
51114 PyObject * obj0 = 0 ;
51115 PyObject * obj1 = 0 ;
51116 PyObject * obj2 = 0 ;
51117 char * kwnames[] = {
51118 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51119 };
51120
51121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51123 if (!SWIG_IsOK(res1)) {
51124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51125 }
51126 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51127 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51128 if (!SWIG_IsOK(res2)) {
51129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51130 }
51131 arg2 = reinterpret_cast< wxWindow * >(argp2);
51132 if (obj2) {
51133 ecode3 = SWIG_AsVal_int(obj2, &val3);
51134 if (!SWIG_IsOK(ecode3)) {
51135 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51136 }
51137 arg3 = static_cast< int >(val3);
51138 }
51139 {
51140 PyThreadState* __tstate = wxPyBeginAllowThreads();
51141 (arg1)->RightOf(arg2,arg3);
51142 wxPyEndAllowThreads(__tstate);
51143 if (PyErr_Occurred()) SWIG_fail;
51144 }
51145 resultobj = SWIG_Py_Void();
51146 return resultobj;
51147 fail:
51148 return NULL;
51149 }
51150
51151
51152 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51153 PyObject *resultobj = 0;
51154 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51155 wxWindow *arg2 = (wxWindow *) 0 ;
51156 int arg3 = (int) 0 ;
51157 void *argp1 = 0 ;
51158 int res1 = 0 ;
51159 void *argp2 = 0 ;
51160 int res2 = 0 ;
51161 int val3 ;
51162 int ecode3 = 0 ;
51163 PyObject * obj0 = 0 ;
51164 PyObject * obj1 = 0 ;
51165 PyObject * obj2 = 0 ;
51166 char * kwnames[] = {
51167 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51168 };
51169
51170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51172 if (!SWIG_IsOK(res1)) {
51173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51174 }
51175 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51176 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51177 if (!SWIG_IsOK(res2)) {
51178 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51179 }
51180 arg2 = reinterpret_cast< wxWindow * >(argp2);
51181 if (obj2) {
51182 ecode3 = SWIG_AsVal_int(obj2, &val3);
51183 if (!SWIG_IsOK(ecode3)) {
51184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51185 }
51186 arg3 = static_cast< int >(val3);
51187 }
51188 {
51189 PyThreadState* __tstate = wxPyBeginAllowThreads();
51190 (arg1)->Above(arg2,arg3);
51191 wxPyEndAllowThreads(__tstate);
51192 if (PyErr_Occurred()) SWIG_fail;
51193 }
51194 resultobj = SWIG_Py_Void();
51195 return resultobj;
51196 fail:
51197 return NULL;
51198 }
51199
51200
51201 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51202 PyObject *resultobj = 0;
51203 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51204 wxWindow *arg2 = (wxWindow *) 0 ;
51205 int arg3 = (int) 0 ;
51206 void *argp1 = 0 ;
51207 int res1 = 0 ;
51208 void *argp2 = 0 ;
51209 int res2 = 0 ;
51210 int val3 ;
51211 int ecode3 = 0 ;
51212 PyObject * obj0 = 0 ;
51213 PyObject * obj1 = 0 ;
51214 PyObject * obj2 = 0 ;
51215 char * kwnames[] = {
51216 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51217 };
51218
51219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51221 if (!SWIG_IsOK(res1)) {
51222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51223 }
51224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51225 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51226 if (!SWIG_IsOK(res2)) {
51227 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51228 }
51229 arg2 = reinterpret_cast< wxWindow * >(argp2);
51230 if (obj2) {
51231 ecode3 = SWIG_AsVal_int(obj2, &val3);
51232 if (!SWIG_IsOK(ecode3)) {
51233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51234 }
51235 arg3 = static_cast< int >(val3);
51236 }
51237 {
51238 PyThreadState* __tstate = wxPyBeginAllowThreads();
51239 (arg1)->Below(arg2,arg3);
51240 wxPyEndAllowThreads(__tstate);
51241 if (PyErr_Occurred()) SWIG_fail;
51242 }
51243 resultobj = SWIG_Py_Void();
51244 return resultobj;
51245 fail:
51246 return NULL;
51247 }
51248
51249
51250 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51251 PyObject *resultobj = 0;
51252 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51253 wxWindow *arg2 = (wxWindow *) 0 ;
51254 wxEdge arg3 ;
51255 int arg4 = (int) 0 ;
51256 void *argp1 = 0 ;
51257 int res1 = 0 ;
51258 void *argp2 = 0 ;
51259 int res2 = 0 ;
51260 int val3 ;
51261 int ecode3 = 0 ;
51262 int val4 ;
51263 int ecode4 = 0 ;
51264 PyObject * obj0 = 0 ;
51265 PyObject * obj1 = 0 ;
51266 PyObject * obj2 = 0 ;
51267 PyObject * obj3 = 0 ;
51268 char * kwnames[] = {
51269 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51270 };
51271
51272 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51273 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51274 if (!SWIG_IsOK(res1)) {
51275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51276 }
51277 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51278 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51279 if (!SWIG_IsOK(res2)) {
51280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51281 }
51282 arg2 = reinterpret_cast< wxWindow * >(argp2);
51283 ecode3 = SWIG_AsVal_int(obj2, &val3);
51284 if (!SWIG_IsOK(ecode3)) {
51285 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51286 }
51287 arg3 = static_cast< wxEdge >(val3);
51288 if (obj3) {
51289 ecode4 = SWIG_AsVal_int(obj3, &val4);
51290 if (!SWIG_IsOK(ecode4)) {
51291 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51292 }
51293 arg4 = static_cast< int >(val4);
51294 }
51295 {
51296 PyThreadState* __tstate = wxPyBeginAllowThreads();
51297 (arg1)->SameAs(arg2,arg3,arg4);
51298 wxPyEndAllowThreads(__tstate);
51299 if (PyErr_Occurred()) SWIG_fail;
51300 }
51301 resultobj = SWIG_Py_Void();
51302 return resultobj;
51303 fail:
51304 return NULL;
51305 }
51306
51307
51308 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51309 PyObject *resultobj = 0;
51310 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51311 wxWindow *arg2 = (wxWindow *) 0 ;
51312 wxEdge arg3 ;
51313 int arg4 ;
51314 void *argp1 = 0 ;
51315 int res1 = 0 ;
51316 void *argp2 = 0 ;
51317 int res2 = 0 ;
51318 int val3 ;
51319 int ecode3 = 0 ;
51320 int val4 ;
51321 int ecode4 = 0 ;
51322 PyObject * obj0 = 0 ;
51323 PyObject * obj1 = 0 ;
51324 PyObject * obj2 = 0 ;
51325 PyObject * obj3 = 0 ;
51326 char * kwnames[] = {
51327 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51328 };
51329
51330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51332 if (!SWIG_IsOK(res1)) {
51333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51334 }
51335 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51337 if (!SWIG_IsOK(res2)) {
51338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51339 }
51340 arg2 = reinterpret_cast< wxWindow * >(argp2);
51341 ecode3 = SWIG_AsVal_int(obj2, &val3);
51342 if (!SWIG_IsOK(ecode3)) {
51343 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51344 }
51345 arg3 = static_cast< wxEdge >(val3);
51346 ecode4 = SWIG_AsVal_int(obj3, &val4);
51347 if (!SWIG_IsOK(ecode4)) {
51348 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51349 }
51350 arg4 = static_cast< int >(val4);
51351 {
51352 PyThreadState* __tstate = wxPyBeginAllowThreads();
51353 (arg1)->PercentOf(arg2,arg3,arg4);
51354 wxPyEndAllowThreads(__tstate);
51355 if (PyErr_Occurred()) SWIG_fail;
51356 }
51357 resultobj = SWIG_Py_Void();
51358 return resultobj;
51359 fail:
51360 return NULL;
51361 }
51362
51363
51364 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51365 PyObject *resultobj = 0;
51366 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51367 int arg2 ;
51368 void *argp1 = 0 ;
51369 int res1 = 0 ;
51370 int val2 ;
51371 int ecode2 = 0 ;
51372 PyObject * obj0 = 0 ;
51373 PyObject * obj1 = 0 ;
51374 char * kwnames[] = {
51375 (char *) "self",(char *) "val", NULL
51376 };
51377
51378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51380 if (!SWIG_IsOK(res1)) {
51381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51382 }
51383 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51384 ecode2 = SWIG_AsVal_int(obj1, &val2);
51385 if (!SWIG_IsOK(ecode2)) {
51386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51387 }
51388 arg2 = static_cast< int >(val2);
51389 {
51390 PyThreadState* __tstate = wxPyBeginAllowThreads();
51391 (arg1)->Absolute(arg2);
51392 wxPyEndAllowThreads(__tstate);
51393 if (PyErr_Occurred()) SWIG_fail;
51394 }
51395 resultobj = SWIG_Py_Void();
51396 return resultobj;
51397 fail:
51398 return NULL;
51399 }
51400
51401
51402 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51403 PyObject *resultobj = 0;
51404 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51405 void *argp1 = 0 ;
51406 int res1 = 0 ;
51407 PyObject *swig_obj[1] ;
51408
51409 if (!args) SWIG_fail;
51410 swig_obj[0] = args;
51411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51412 if (!SWIG_IsOK(res1)) {
51413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51414 }
51415 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51416 {
51417 PyThreadState* __tstate = wxPyBeginAllowThreads();
51418 (arg1)->Unconstrained();
51419 wxPyEndAllowThreads(__tstate);
51420 if (PyErr_Occurred()) SWIG_fail;
51421 }
51422 resultobj = SWIG_Py_Void();
51423 return resultobj;
51424 fail:
51425 return NULL;
51426 }
51427
51428
51429 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51430 PyObject *resultobj = 0;
51431 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51432 void *argp1 = 0 ;
51433 int res1 = 0 ;
51434 PyObject *swig_obj[1] ;
51435
51436 if (!args) SWIG_fail;
51437 swig_obj[0] = args;
51438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51439 if (!SWIG_IsOK(res1)) {
51440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51441 }
51442 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51443 {
51444 PyThreadState* __tstate = wxPyBeginAllowThreads();
51445 (arg1)->AsIs();
51446 wxPyEndAllowThreads(__tstate);
51447 if (PyErr_Occurred()) SWIG_fail;
51448 }
51449 resultobj = SWIG_Py_Void();
51450 return resultobj;
51451 fail:
51452 return NULL;
51453 }
51454
51455
51456 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51457 PyObject *resultobj = 0;
51458 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51459 wxWindow *result = 0 ;
51460 void *argp1 = 0 ;
51461 int res1 = 0 ;
51462 PyObject *swig_obj[1] ;
51463
51464 if (!args) SWIG_fail;
51465 swig_obj[0] = args;
51466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51467 if (!SWIG_IsOK(res1)) {
51468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51469 }
51470 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51471 {
51472 PyThreadState* __tstate = wxPyBeginAllowThreads();
51473 result = (wxWindow *)(arg1)->GetOtherWindow();
51474 wxPyEndAllowThreads(__tstate);
51475 if (PyErr_Occurred()) SWIG_fail;
51476 }
51477 {
51478 resultobj = wxPyMake_wxObject(result, 0);
51479 }
51480 return resultobj;
51481 fail:
51482 return NULL;
51483 }
51484
51485
51486 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51487 PyObject *resultobj = 0;
51488 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51489 wxEdge result;
51490 void *argp1 = 0 ;
51491 int res1 = 0 ;
51492 PyObject *swig_obj[1] ;
51493
51494 if (!args) SWIG_fail;
51495 swig_obj[0] = args;
51496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51497 if (!SWIG_IsOK(res1)) {
51498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51499 }
51500 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51501 {
51502 PyThreadState* __tstate = wxPyBeginAllowThreads();
51503 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51504 wxPyEndAllowThreads(__tstate);
51505 if (PyErr_Occurred()) SWIG_fail;
51506 }
51507 resultobj = SWIG_From_int(static_cast< int >(result));
51508 return resultobj;
51509 fail:
51510 return NULL;
51511 }
51512
51513
51514 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51515 PyObject *resultobj = 0;
51516 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51517 wxEdge arg2 ;
51518 void *argp1 = 0 ;
51519 int res1 = 0 ;
51520 int val2 ;
51521 int ecode2 = 0 ;
51522 PyObject * obj0 = 0 ;
51523 PyObject * obj1 = 0 ;
51524 char * kwnames[] = {
51525 (char *) "self",(char *) "which", NULL
51526 };
51527
51528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51530 if (!SWIG_IsOK(res1)) {
51531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51532 }
51533 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51534 ecode2 = SWIG_AsVal_int(obj1, &val2);
51535 if (!SWIG_IsOK(ecode2)) {
51536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51537 }
51538 arg2 = static_cast< wxEdge >(val2);
51539 {
51540 PyThreadState* __tstate = wxPyBeginAllowThreads();
51541 (arg1)->SetEdge(arg2);
51542 wxPyEndAllowThreads(__tstate);
51543 if (PyErr_Occurred()) SWIG_fail;
51544 }
51545 resultobj = SWIG_Py_Void();
51546 return resultobj;
51547 fail:
51548 return NULL;
51549 }
51550
51551
51552 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51553 PyObject *resultobj = 0;
51554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51555 int arg2 ;
51556 void *argp1 = 0 ;
51557 int res1 = 0 ;
51558 int val2 ;
51559 int ecode2 = 0 ;
51560 PyObject * obj0 = 0 ;
51561 PyObject * obj1 = 0 ;
51562 char * kwnames[] = {
51563 (char *) "self",(char *) "v", NULL
51564 };
51565
51566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51568 if (!SWIG_IsOK(res1)) {
51569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51570 }
51571 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51572 ecode2 = SWIG_AsVal_int(obj1, &val2);
51573 if (!SWIG_IsOK(ecode2)) {
51574 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51575 }
51576 arg2 = static_cast< int >(val2);
51577 {
51578 PyThreadState* __tstate = wxPyBeginAllowThreads();
51579 (arg1)->SetValue(arg2);
51580 wxPyEndAllowThreads(__tstate);
51581 if (PyErr_Occurred()) SWIG_fail;
51582 }
51583 resultobj = SWIG_Py_Void();
51584 return resultobj;
51585 fail:
51586 return NULL;
51587 }
51588
51589
51590 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51591 PyObject *resultobj = 0;
51592 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51593 int result;
51594 void *argp1 = 0 ;
51595 int res1 = 0 ;
51596 PyObject *swig_obj[1] ;
51597
51598 if (!args) SWIG_fail;
51599 swig_obj[0] = args;
51600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51601 if (!SWIG_IsOK(res1)) {
51602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51603 }
51604 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51605 {
51606 PyThreadState* __tstate = wxPyBeginAllowThreads();
51607 result = (int)(arg1)->GetMargin();
51608 wxPyEndAllowThreads(__tstate);
51609 if (PyErr_Occurred()) SWIG_fail;
51610 }
51611 resultobj = SWIG_From_int(static_cast< int >(result));
51612 return resultobj;
51613 fail:
51614 return NULL;
51615 }
51616
51617
51618 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51619 PyObject *resultobj = 0;
51620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51621 int arg2 ;
51622 void *argp1 = 0 ;
51623 int res1 = 0 ;
51624 int val2 ;
51625 int ecode2 = 0 ;
51626 PyObject * obj0 = 0 ;
51627 PyObject * obj1 = 0 ;
51628 char * kwnames[] = {
51629 (char *) "self",(char *) "m", NULL
51630 };
51631
51632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51634 if (!SWIG_IsOK(res1)) {
51635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51636 }
51637 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51638 ecode2 = SWIG_AsVal_int(obj1, &val2);
51639 if (!SWIG_IsOK(ecode2)) {
51640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51641 }
51642 arg2 = static_cast< int >(val2);
51643 {
51644 PyThreadState* __tstate = wxPyBeginAllowThreads();
51645 (arg1)->SetMargin(arg2);
51646 wxPyEndAllowThreads(__tstate);
51647 if (PyErr_Occurred()) SWIG_fail;
51648 }
51649 resultobj = SWIG_Py_Void();
51650 return resultobj;
51651 fail:
51652 return NULL;
51653 }
51654
51655
51656 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51657 PyObject *resultobj = 0;
51658 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 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_wxIndividualLayoutConstraint, 0 | 0 );
51667 if (!SWIG_IsOK(res1)) {
51668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51669 }
51670 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51671 {
51672 PyThreadState* __tstate = wxPyBeginAllowThreads();
51673 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
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 *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51685 PyObject *resultobj = 0;
51686 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51687 int result;
51688 void *argp1 = 0 ;
51689 int res1 = 0 ;
51690 PyObject *swig_obj[1] ;
51691
51692 if (!args) SWIG_fail;
51693 swig_obj[0] = args;
51694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51695 if (!SWIG_IsOK(res1)) {
51696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51697 }
51698 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51699 {
51700 PyThreadState* __tstate = wxPyBeginAllowThreads();
51701 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51702 wxPyEndAllowThreads(__tstate);
51703 if (PyErr_Occurred()) SWIG_fail;
51704 }
51705 resultobj = SWIG_From_int(static_cast< int >(result));
51706 return resultobj;
51707 fail:
51708 return NULL;
51709 }
51710
51711
51712 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51713 PyObject *resultobj = 0;
51714 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51715 int result;
51716 void *argp1 = 0 ;
51717 int res1 = 0 ;
51718 PyObject *swig_obj[1] ;
51719
51720 if (!args) SWIG_fail;
51721 swig_obj[0] = args;
51722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51723 if (!SWIG_IsOK(res1)) {
51724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51725 }
51726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51727 {
51728 PyThreadState* __tstate = wxPyBeginAllowThreads();
51729 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51730 wxPyEndAllowThreads(__tstate);
51731 if (PyErr_Occurred()) SWIG_fail;
51732 }
51733 resultobj = SWIG_From_int(static_cast< int >(result));
51734 return resultobj;
51735 fail:
51736 return NULL;
51737 }
51738
51739
51740 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51741 PyObject *resultobj = 0;
51742 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51743 bool result;
51744 void *argp1 = 0 ;
51745 int res1 = 0 ;
51746 PyObject *swig_obj[1] ;
51747
51748 if (!args) SWIG_fail;
51749 swig_obj[0] = args;
51750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51751 if (!SWIG_IsOK(res1)) {
51752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51753 }
51754 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51755 {
51756 PyThreadState* __tstate = wxPyBeginAllowThreads();
51757 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51758 wxPyEndAllowThreads(__tstate);
51759 if (PyErr_Occurred()) SWIG_fail;
51760 }
51761 {
51762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51763 }
51764 return resultobj;
51765 fail:
51766 return NULL;
51767 }
51768
51769
51770 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51771 PyObject *resultobj = 0;
51772 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51773 bool arg2 ;
51774 void *argp1 = 0 ;
51775 int res1 = 0 ;
51776 bool val2 ;
51777 int ecode2 = 0 ;
51778 PyObject * obj0 = 0 ;
51779 PyObject * obj1 = 0 ;
51780 char * kwnames[] = {
51781 (char *) "self",(char *) "d", NULL
51782 };
51783
51784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51786 if (!SWIG_IsOK(res1)) {
51787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51788 }
51789 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51791 if (!SWIG_IsOK(ecode2)) {
51792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
51793 }
51794 arg2 = static_cast< bool >(val2);
51795 {
51796 PyThreadState* __tstate = wxPyBeginAllowThreads();
51797 (arg1)->SetDone(arg2);
51798 wxPyEndAllowThreads(__tstate);
51799 if (PyErr_Occurred()) SWIG_fail;
51800 }
51801 resultobj = SWIG_Py_Void();
51802 return resultobj;
51803 fail:
51804 return NULL;
51805 }
51806
51807
51808 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51809 PyObject *resultobj = 0;
51810 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51811 wxRelationship result;
51812 void *argp1 = 0 ;
51813 int res1 = 0 ;
51814 PyObject *swig_obj[1] ;
51815
51816 if (!args) SWIG_fail;
51817 swig_obj[0] = args;
51818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51819 if (!SWIG_IsOK(res1)) {
51820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51821 }
51822 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51823 {
51824 PyThreadState* __tstate = wxPyBeginAllowThreads();
51825 result = (wxRelationship)(arg1)->GetRelationship();
51826 wxPyEndAllowThreads(__tstate);
51827 if (PyErr_Occurred()) SWIG_fail;
51828 }
51829 resultobj = SWIG_From_int(static_cast< int >(result));
51830 return resultobj;
51831 fail:
51832 return NULL;
51833 }
51834
51835
51836 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51837 PyObject *resultobj = 0;
51838 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51839 wxRelationship arg2 ;
51840 void *argp1 = 0 ;
51841 int res1 = 0 ;
51842 int val2 ;
51843 int ecode2 = 0 ;
51844 PyObject * obj0 = 0 ;
51845 PyObject * obj1 = 0 ;
51846 char * kwnames[] = {
51847 (char *) "self",(char *) "r", NULL
51848 };
51849
51850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
51851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51852 if (!SWIG_IsOK(res1)) {
51853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51854 }
51855 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51856 ecode2 = SWIG_AsVal_int(obj1, &val2);
51857 if (!SWIG_IsOK(ecode2)) {
51858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
51859 }
51860 arg2 = static_cast< wxRelationship >(val2);
51861 {
51862 PyThreadState* __tstate = wxPyBeginAllowThreads();
51863 (arg1)->SetRelationship(arg2);
51864 wxPyEndAllowThreads(__tstate);
51865 if (PyErr_Occurred()) SWIG_fail;
51866 }
51867 resultobj = SWIG_Py_Void();
51868 return resultobj;
51869 fail:
51870 return NULL;
51871 }
51872
51873
51874 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51875 PyObject *resultobj = 0;
51876 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51877 wxWindow *arg2 = (wxWindow *) 0 ;
51878 bool result;
51879 void *argp1 = 0 ;
51880 int res1 = 0 ;
51881 void *argp2 = 0 ;
51882 int res2 = 0 ;
51883 PyObject * obj0 = 0 ;
51884 PyObject * obj1 = 0 ;
51885 char * kwnames[] = {
51886 (char *) "self",(char *) "otherW", NULL
51887 };
51888
51889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
51890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51891 if (!SWIG_IsOK(res1)) {
51892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51893 }
51894 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51895 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51896 if (!SWIG_IsOK(res2)) {
51897 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
51898 }
51899 arg2 = reinterpret_cast< wxWindow * >(argp2);
51900 {
51901 PyThreadState* __tstate = wxPyBeginAllowThreads();
51902 result = (bool)(arg1)->ResetIfWin(arg2);
51903 wxPyEndAllowThreads(__tstate);
51904 if (PyErr_Occurred()) SWIG_fail;
51905 }
51906 {
51907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51908 }
51909 return resultobj;
51910 fail:
51911 return NULL;
51912 }
51913
51914
51915 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51916 PyObject *resultobj = 0;
51917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51918 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
51919 wxWindow *arg3 = (wxWindow *) 0 ;
51920 bool result;
51921 void *argp1 = 0 ;
51922 int res1 = 0 ;
51923 void *argp2 = 0 ;
51924 int res2 = 0 ;
51925 void *argp3 = 0 ;
51926 int res3 = 0 ;
51927 PyObject * obj0 = 0 ;
51928 PyObject * obj1 = 0 ;
51929 PyObject * obj2 = 0 ;
51930 char * kwnames[] = {
51931 (char *) "self",(char *) "constraints",(char *) "win", NULL
51932 };
51933
51934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51936 if (!SWIG_IsOK(res1)) {
51937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51938 }
51939 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51940 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
51941 if (!SWIG_IsOK(res2)) {
51942 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
51943 }
51944 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
51945 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51946 if (!SWIG_IsOK(res3)) {
51947 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
51948 }
51949 arg3 = reinterpret_cast< wxWindow * >(argp3);
51950 {
51951 PyThreadState* __tstate = wxPyBeginAllowThreads();
51952 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
51953 wxPyEndAllowThreads(__tstate);
51954 if (PyErr_Occurred()) SWIG_fail;
51955 }
51956 {
51957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51958 }
51959 return resultobj;
51960 fail:
51961 return NULL;
51962 }
51963
51964
51965 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51966 PyObject *resultobj = 0;
51967 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51968 wxEdge arg2 ;
51969 wxWindow *arg3 = (wxWindow *) 0 ;
51970 wxWindow *arg4 = (wxWindow *) 0 ;
51971 int result;
51972 void *argp1 = 0 ;
51973 int res1 = 0 ;
51974 int val2 ;
51975 int ecode2 = 0 ;
51976 void *argp3 = 0 ;
51977 int res3 = 0 ;
51978 void *argp4 = 0 ;
51979 int res4 = 0 ;
51980 PyObject * obj0 = 0 ;
51981 PyObject * obj1 = 0 ;
51982 PyObject * obj2 = 0 ;
51983 PyObject * obj3 = 0 ;
51984 char * kwnames[] = {
51985 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
51986 };
51987
51988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51990 if (!SWIG_IsOK(res1)) {
51991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51992 }
51993 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51994 ecode2 = SWIG_AsVal_int(obj1, &val2);
51995 if (!SWIG_IsOK(ecode2)) {
51996 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51997 }
51998 arg2 = static_cast< wxEdge >(val2);
51999 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52000 if (!SWIG_IsOK(res3)) {
52001 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52002 }
52003 arg3 = reinterpret_cast< wxWindow * >(argp3);
52004 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52005 if (!SWIG_IsOK(res4)) {
52006 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52007 }
52008 arg4 = reinterpret_cast< wxWindow * >(argp4);
52009 {
52010 PyThreadState* __tstate = wxPyBeginAllowThreads();
52011 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52012 wxPyEndAllowThreads(__tstate);
52013 if (PyErr_Occurred()) SWIG_fail;
52014 }
52015 resultobj = SWIG_From_int(static_cast< int >(result));
52016 return resultobj;
52017 fail:
52018 return NULL;
52019 }
52020
52021
52022 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52023 PyObject *obj;
52024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52025 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52026 return SWIG_Py_Void();
52027 }
52028
52029 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52030 PyObject *resultobj = 0;
52031 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52032 wxIndividualLayoutConstraint *result = 0 ;
52033 void *argp1 = 0 ;
52034 int res1 = 0 ;
52035 PyObject *swig_obj[1] ;
52036
52037 if (!args) SWIG_fail;
52038 swig_obj[0] = args;
52039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52040 if (!SWIG_IsOK(res1)) {
52041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52042 }
52043 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52044 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52045 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52046 return resultobj;
52047 fail:
52048 return NULL;
52049 }
52050
52051
52052 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52053 PyObject *resultobj = 0;
52054 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52055 wxIndividualLayoutConstraint *result = 0 ;
52056 void *argp1 = 0 ;
52057 int res1 = 0 ;
52058 PyObject *swig_obj[1] ;
52059
52060 if (!args) SWIG_fail;
52061 swig_obj[0] = args;
52062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52063 if (!SWIG_IsOK(res1)) {
52064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52065 }
52066 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52067 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52068 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52069 return resultobj;
52070 fail:
52071 return NULL;
52072 }
52073
52074
52075 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52076 PyObject *resultobj = 0;
52077 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52078 wxIndividualLayoutConstraint *result = 0 ;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 PyObject *swig_obj[1] ;
52082
52083 if (!args) SWIG_fail;
52084 swig_obj[0] = args;
52085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52086 if (!SWIG_IsOK(res1)) {
52087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52088 }
52089 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52090 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52092 return resultobj;
52093 fail:
52094 return NULL;
52095 }
52096
52097
52098 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52099 PyObject *resultobj = 0;
52100 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52101 wxIndividualLayoutConstraint *result = 0 ;
52102 void *argp1 = 0 ;
52103 int res1 = 0 ;
52104 PyObject *swig_obj[1] ;
52105
52106 if (!args) SWIG_fail;
52107 swig_obj[0] = args;
52108 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52109 if (!SWIG_IsOK(res1)) {
52110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52111 }
52112 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52113 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52114 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52115 return resultobj;
52116 fail:
52117 return NULL;
52118 }
52119
52120
52121 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52122 PyObject *resultobj = 0;
52123 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52124 wxIndividualLayoutConstraint *result = 0 ;
52125 void *argp1 = 0 ;
52126 int res1 = 0 ;
52127 PyObject *swig_obj[1] ;
52128
52129 if (!args) SWIG_fail;
52130 swig_obj[0] = args;
52131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52132 if (!SWIG_IsOK(res1)) {
52133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52134 }
52135 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52136 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52138 return resultobj;
52139 fail:
52140 return NULL;
52141 }
52142
52143
52144 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52145 PyObject *resultobj = 0;
52146 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52147 wxIndividualLayoutConstraint *result = 0 ;
52148 void *argp1 = 0 ;
52149 int res1 = 0 ;
52150 PyObject *swig_obj[1] ;
52151
52152 if (!args) SWIG_fail;
52153 swig_obj[0] = args;
52154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52155 if (!SWIG_IsOK(res1)) {
52156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52157 }
52158 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52159 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52161 return resultobj;
52162 fail:
52163 return NULL;
52164 }
52165
52166
52167 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52168 PyObject *resultobj = 0;
52169 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52170 wxIndividualLayoutConstraint *result = 0 ;
52171 void *argp1 = 0 ;
52172 int res1 = 0 ;
52173 PyObject *swig_obj[1] ;
52174
52175 if (!args) SWIG_fail;
52176 swig_obj[0] = args;
52177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52178 if (!SWIG_IsOK(res1)) {
52179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52180 }
52181 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52182 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52184 return resultobj;
52185 fail:
52186 return NULL;
52187 }
52188
52189
52190 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52191 PyObject *resultobj = 0;
52192 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52193 wxIndividualLayoutConstraint *result = 0 ;
52194 void *argp1 = 0 ;
52195 int res1 = 0 ;
52196 PyObject *swig_obj[1] ;
52197
52198 if (!args) SWIG_fail;
52199 swig_obj[0] = args;
52200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52201 if (!SWIG_IsOK(res1)) {
52202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52203 }
52204 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52205 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52206 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52207 return resultobj;
52208 fail:
52209 return NULL;
52210 }
52211
52212
52213 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52214 PyObject *resultobj = 0;
52215 wxLayoutConstraints *result = 0 ;
52216
52217 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52218 {
52219 PyThreadState* __tstate = wxPyBeginAllowThreads();
52220 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52221 wxPyEndAllowThreads(__tstate);
52222 if (PyErr_Occurred()) SWIG_fail;
52223 }
52224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52225 return resultobj;
52226 fail:
52227 return NULL;
52228 }
52229
52230
52231 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52232 PyObject *resultobj = 0;
52233 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52234 void *argp1 = 0 ;
52235 int res1 = 0 ;
52236 PyObject *swig_obj[1] ;
52237
52238 if (!args) SWIG_fail;
52239 swig_obj[0] = args;
52240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52241 if (!SWIG_IsOK(res1)) {
52242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52243 }
52244 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52245 {
52246 PyThreadState* __tstate = wxPyBeginAllowThreads();
52247 delete arg1;
52248
52249 wxPyEndAllowThreads(__tstate);
52250 if (PyErr_Occurred()) SWIG_fail;
52251 }
52252 resultobj = SWIG_Py_Void();
52253 return resultobj;
52254 fail:
52255 return NULL;
52256 }
52257
52258
52259 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52260 PyObject *resultobj = 0;
52261 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52262 wxWindow *arg2 = (wxWindow *) 0 ;
52263 int *arg3 = (int *) 0 ;
52264 bool result;
52265 void *argp1 = 0 ;
52266 int res1 = 0 ;
52267 void *argp2 = 0 ;
52268 int res2 = 0 ;
52269 int temp3 ;
52270 int res3 = SWIG_TMPOBJ ;
52271 PyObject * obj0 = 0 ;
52272 PyObject * obj1 = 0 ;
52273 char * kwnames[] = {
52274 (char *) "self",(char *) "win", NULL
52275 };
52276
52277 arg3 = &temp3;
52278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52280 if (!SWIG_IsOK(res1)) {
52281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52282 }
52283 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52284 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52285 if (!SWIG_IsOK(res2)) {
52286 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52287 }
52288 arg2 = reinterpret_cast< wxWindow * >(argp2);
52289 {
52290 PyThreadState* __tstate = wxPyBeginAllowThreads();
52291 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52292 wxPyEndAllowThreads(__tstate);
52293 if (PyErr_Occurred()) SWIG_fail;
52294 }
52295 {
52296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52297 }
52298 if (SWIG_IsTmpObj(res3)) {
52299 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52300 } else {
52301 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52302 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52303 }
52304 return resultobj;
52305 fail:
52306 return NULL;
52307 }
52308
52309
52310 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52311 PyObject *resultobj = 0;
52312 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52313 bool result;
52314 void *argp1 = 0 ;
52315 int res1 = 0 ;
52316 PyObject *swig_obj[1] ;
52317
52318 if (!args) SWIG_fail;
52319 swig_obj[0] = args;
52320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52321 if (!SWIG_IsOK(res1)) {
52322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52323 }
52324 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52325 {
52326 PyThreadState* __tstate = wxPyBeginAllowThreads();
52327 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52328 wxPyEndAllowThreads(__tstate);
52329 if (PyErr_Occurred()) SWIG_fail;
52330 }
52331 {
52332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52333 }
52334 return resultobj;
52335 fail:
52336 return NULL;
52337 }
52338
52339
52340 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52341 PyObject *obj;
52342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52343 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52344 return SWIG_Py_Void();
52345 }
52346
52347 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52348 return SWIG_Python_InitShadowInstance(args);
52349 }
52350
52351 static PyMethodDef SwigMethods[] = {
52352 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52353 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
52354 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52355 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52356 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52357 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52358 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52359 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52360 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52361 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52362 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52363 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52364 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52365 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52366 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52367 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52368 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52369 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52370 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52371 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52372 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52373 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52374 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52375 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52376 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52377 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52378 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52379 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52380 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52381 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52382 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52383 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52384 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52385 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52386 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52387 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52388 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52389 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52390 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52391 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52392 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52393 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52394 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52395 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52396 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52397 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52398 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52399 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52400 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52401 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52402 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52403 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52404 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52405 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52406 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52407 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52408 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52409 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52410 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52411 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52412 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52413 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52414 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52415 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52416 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52417 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52418 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52419 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52420 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52421 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52422 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52423 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52424 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52425 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52426 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52427 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52428 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52429 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52430 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52431 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52432 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52433 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52434 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52435 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52436 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52437 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52438 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52439 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52440 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52441 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52442 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52443 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52444 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52445 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52446 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52447 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52448 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52449 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52450 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52451 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52452 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52453 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52454 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52455 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52456 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52457 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52458 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52459 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52460 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52461 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52462 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52463 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52464 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52465 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52466 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52467 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52468 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52469 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52470 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52471 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52472 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52473 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52474 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52475 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52476 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52477 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52478 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52479 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52480 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52481 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52482 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52483 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52484 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52485 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52486 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52487 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52488 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52489 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52490 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52491 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52492 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52493 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52494 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52495 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52496 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52497 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52498 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52499 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52500 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52501 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52502 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52503 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52504 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52505 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52506 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52507 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52508 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52509 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52510 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52511 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52512 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52513 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52514 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52515 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52516 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52517 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52518 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52519 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52520 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52521 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52522 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52523 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52524 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52525 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52526 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52527 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52528 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52529 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52530 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52531 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52532 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52533 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52534 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52535 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52536 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52537 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52538 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52539 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52540 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52541 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52542 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52543 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52544 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52545 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52546 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52547 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52548 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52549 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52550 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52551 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52552 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52553 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52554 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52555 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52556 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52557 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52558 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52559 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52560 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52561 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52562 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52563 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52564 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52565 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52566 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52567 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52568 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52569 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52570 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52571 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52572 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52573 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52574 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52575 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52576 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52577 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52578 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52579 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52580 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52585 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52586 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52587 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52589 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52590 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52591 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52592 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52593 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52594 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52595 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52597 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52598 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52600 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52601 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52602 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52603 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52604 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52605 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52606 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52607 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52608 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52609 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52610 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52611 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52612 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52613 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52614 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52615 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52616 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52618 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52619 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52620 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52621 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52626 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52627 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52629 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52631 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52632 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52633 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52634 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52635 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52637 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52639 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52640 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52642 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52644 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52645 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52646 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52647 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52655 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52656 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52657 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52658 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52661 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52663 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52665 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52666 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52667 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52668 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52669 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52670 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52671 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52672 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52673 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52674 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52675 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52676 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52677 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52682 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52683 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52684 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52685 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52692 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52694 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52695 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52696 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52699 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52700 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52701 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52702 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52703 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52704 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52705 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52706 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52707 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52708 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52709 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52710 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52711 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52712 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52713 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52714 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52715 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52716 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52717 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52718 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52719 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52720 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52721 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52722 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52723 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52724 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52725 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52726 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52727 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52728 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52729 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52730 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52731 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52732 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52733 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52734 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52735 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52736 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52737 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52738 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52739 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52740 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52741 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52743 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52746 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52747 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52751 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52752 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52753 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52754 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52755 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52756 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52757 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52759 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52760 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52761 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52762 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52763 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52765 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52766 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52767 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52769 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52770 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52771 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52772 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52773 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52774 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52776 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52777 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52778 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52780 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52782 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52783 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52784 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52786 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
52787 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
52788 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
52789 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
52790 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
52791 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
52792 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
52793 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
52795 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
52796 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
52797 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
52798 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
52799 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52800 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
52801 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
52802 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52803 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52804 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
52805 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
52806 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
52808 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
52809 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52811 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
52812 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
52813 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
52815 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
52821 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
52822 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
52823 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
52824 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
52825 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
52826 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
52827 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
52828 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
52829 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
52830 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
52831 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
52832 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
52833 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
52834 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
52835 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
52836 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
52837 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
52838 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
52839 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
52840 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
52841 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
52842 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
52843 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
52844 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
52846 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
52847 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
52848 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
52849 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
52850 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
52851 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
52852 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
52853 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
52854 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
52855 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
52856 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
52857 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
52858 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
52859 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
52860 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
52861 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
52862 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
52863 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
52864 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
52865 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
52866 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
52867 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
52868 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
52869 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
52870 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
52871 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
52872 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
52873 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
52874 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
52875 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
52876 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
52877 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
52879 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
52880 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
52882 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
52883 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
52884 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
52885 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
52887 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
52888 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
52889 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
52890 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
52891 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
52892 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
52893 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
52894 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
52895 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
52896 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
52897 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
52898 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
52899 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
52900 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
52901 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
52902 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
52903 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
52904 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
52905 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
52906 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
52907 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
52908 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
52909 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
52910 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
52911 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
52912 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
52913 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
52914 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
52915 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
52916 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
52917 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
52918 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
52919 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
52920 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
52921 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
52922 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
52923 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
52925 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
52926 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
52929 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
52930 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
52931 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
52932 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
52933 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
52934 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
52936 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
52937 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
52938 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52939 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
52940 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
52941 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52942 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
52943 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
52944 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52945 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
52946 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
52947 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52948 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
52949 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
52950 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
52951 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
52953 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
52955 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
52956 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
52958 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
52959 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
52960 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
52962 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
52963 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
52964 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52965 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
52966 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
52967 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
52969 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
52970 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
52971 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
52972 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
52973 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52974 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
52976 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
52978 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
52980 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
52981 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
52982 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52983 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
52985 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
52986 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
52987 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
52989 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
52990 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
52991 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
52993 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
52994 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
52995 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
52996 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
52997 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
52998 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52999 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53000 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53001 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53002 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53003 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53004 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53005 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53006 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53007 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53008 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53009 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53013 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53014 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53015 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53017 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53018 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53019 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53020 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53021 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53022 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53024 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53025 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53026 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53027 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53028 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53029 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53032 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53033 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53034 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53037 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53038 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53039 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53040 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53041 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53042 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53043 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53045 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53048 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53049 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53050 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53051 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53052 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53053 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53054 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53055 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53056 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53057 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53058 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53059 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53060 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53061 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53062 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53063 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53064 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53065 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53066 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53067 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53069 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53071 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53072 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53074 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53076 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53077 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53078 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53080 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53082 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53083 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53084 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53086 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53088 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53089 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53090 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53091 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53093 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53095 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53097 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53099 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53100 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53102 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53103 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53104 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53105 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53106 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53107 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53108 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53109 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53111 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53112 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53113 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53114 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53115 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53116 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53117 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53118 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53119 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53120 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53121 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53122 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53123 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53124 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53125 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53126 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53128 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53132 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53133 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53134 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53135 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53136 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53137 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53138 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53140 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53142 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53143 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53145 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53146 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53147 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53148 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53150 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53151 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53152 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53153 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53154 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53155 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53156 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53157 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53158 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53159 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53160 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53162 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53163 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53164 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53165 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53166 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53167 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53168 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53169 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53170 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53171 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53172 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53173 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53175 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53176 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53177 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53178 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53179 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53180 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53181 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53182 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53183 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53184 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53185 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53186 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53189 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53190 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53191 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53193 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53194 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53195 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53197 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53198 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53199 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53200 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53202 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53203 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53204 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53207 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53208 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53210 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53211 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53214 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53215 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53216 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53217 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53218 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53219 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53220 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53221 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53222 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53223 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53224 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53225 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53226 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53227 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53228 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53229 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53231 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53232 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53233 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53234 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53235 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53236 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53237 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53239 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53240 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53241 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53242 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53245 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53246 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53247 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53248 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53250 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53251 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53252 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53253 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53255 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53256 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53257 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53258 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53259 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53261 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53263 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53264 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53265 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53266 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53268 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53269 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53270 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53271 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53272 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53273 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53274 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53276 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53277 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53278 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53280 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53281 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53282 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53283 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53284 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53285 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53287 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53288 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53289 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53290 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53292 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53293 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53294 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53295 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53296 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53297 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53298 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53299 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53300 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53301 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53302 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53304 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53305 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53306 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53307 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53309 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53311 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53312 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53313 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53314 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53315 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53316 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53317 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53318 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53319 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53320 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53321 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53322 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53323 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53324 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53325 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53327 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53331 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53333 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53334 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53335 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53336 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53338 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53339 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53340 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53341 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53342 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53344 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53346 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53347 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53348 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53349 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53350 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53351 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53352 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53353 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53354 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53356 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53357 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53358 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53359 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53361 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53362 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53363 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
53364 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53366 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53367 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53368 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53369 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53371 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53372 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53374 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53375 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53376 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53377 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53378 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53380 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53381 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53382 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53383 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53384 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53385 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53386 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53388 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53389 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53390 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53391 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53392 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53393 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53394 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53395 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53396 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53397 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53398 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53399 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53400 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53402 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53405 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53406 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53407 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53409 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53410 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53411 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53413 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53415 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53417 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53419 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53420 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53423 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53430 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53432 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53433 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53434 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53437 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53438 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53439 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53441 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53442 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53443 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53445 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53447 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53448 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53449 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53452 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53457 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53458 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53462 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53464 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53466 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53467 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53469 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53471 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53472 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53473 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53474 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53475 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53476 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53477 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53480 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53481 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53484 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53487 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53488 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53489 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53496 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53498 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53499 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53500 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53502 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53504 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53505 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53506 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53508 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53509 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53512 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53513 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53514 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53515 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53516 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53518 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53521 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53522 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53524 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53526 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53528 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53529 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53530 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53531 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53532 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53534 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53535 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53536 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53537 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53539 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53540 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53541 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53544 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53546 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53547 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53548 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53550 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53551 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53552 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53553 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53554 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53555 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53557 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53558 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53559 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53560 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53561 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53563 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53564 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53565 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53568 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53569 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53571 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53575 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53577 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53579 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53580 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53581 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53582 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53586 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53587 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53588 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53589 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53590 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53591 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53592 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53593 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53596 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53597 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53598 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53599 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53600 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53601 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53603 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53604 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53605 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53606 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53607 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53608 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53610 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53612 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53613 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53614 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53615 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53616 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53617 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53619 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53620 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53621 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53622 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53623 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53625 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53626 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53629 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53631 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53633 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53635 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53636 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53637 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53638 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53639 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53640 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53646 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53647 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53651 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53652 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53654 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53655 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53657 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53659 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53660 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53662 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53663 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53664 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53670 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53671 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53672 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53673 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53674 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53675 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53679 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53681 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53682 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53683 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53684 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53685 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53686 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53687 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53688 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53689 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53691 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53693 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53695 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53696 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53697 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53698 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53699 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53700 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53701 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53703 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53704 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53705 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53711 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53712 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53713 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53715 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53716 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53717 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53719 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53721 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53723 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53724 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53725 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53726 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53727 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53729 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53730 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53731 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53732 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53735 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53737 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53738 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53740 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53741 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53745 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53746 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53748 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53749 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53750 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53751 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53752 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53754 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53757 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53758 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53767 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53768 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53769 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53770 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53773 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53774 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53775 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53776 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53777 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53778 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53780 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
53785 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
53786 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
53787 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
53788 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
53789 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
53790 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
53791 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
53792 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
53793 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
53794 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
53795 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
53797 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
53798 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
53799 { NULL, NULL, 0, NULL }
53800 };
53801
53802
53803 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
53804
53805 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
53806 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
53807 }
53808 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
53809 return (void *)((wxSizer *) ((wxBoxSizer *) x));
53810 }
53811 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
53812 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
53813 }
53814 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
53815 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53816 }
53817 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
53818 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
53819 }
53820 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
53821 return (void *)((wxSizer *) ((wxGridSizer *) x));
53822 }
53823 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
53824 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
53825 }
53826 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
53827 return (void *)((wxSizer *) ((wxPySizer *) x));
53828 }
53829 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
53830 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
53831 }
53832 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
53833 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
53834 }
53835 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
53836 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
53837 }
53838 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
53839 return (void *)((wxEvent *) ((wxMenuEvent *) x));
53840 }
53841 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
53842 return (void *)((wxEvent *) ((wxCloseEvent *) x));
53843 }
53844 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
53845 return (void *)((wxEvent *) ((wxMouseEvent *) x));
53846 }
53847 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
53848 return (void *)((wxEvent *) ((wxEraseEvent *) x));
53849 }
53850 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
53851 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
53852 }
53853 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
53854 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
53855 }
53856 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
53857 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
53858 }
53859 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
53860 return (void *)((wxEvent *) ((wxPyEvent *) x));
53861 }
53862 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
53863 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
53864 }
53865 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
53866 return (void *)((wxEvent *) ((wxIdleEvent *) x));
53867 }
53868 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
53869 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
53870 }
53871 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
53872 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
53873 }
53874 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
53875 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
53876 }
53877 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
53878 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
53879 }
53880 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
53881 return (void *)((wxEvent *) ((wxActivateEvent *) x));
53882 }
53883 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
53884 return (void *)((wxEvent *) ((wxSizeEvent *) x));
53885 }
53886 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
53887 return (void *)((wxEvent *) ((wxMoveEvent *) x));
53888 }
53889 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
53890 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
53891 }
53892 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
53893 return (void *)((wxEvent *) ((wxPaintEvent *) x));
53894 }
53895 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
53896 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
53897 }
53898 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
53899 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
53900 }
53901 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
53902 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
53903 }
53904 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
53905 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
53906 }
53907 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
53908 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
53909 }
53910 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
53911 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
53912 }
53913 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
53914 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
53915 }
53916 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
53917 return (void *)((wxEvent *) ((wxFocusEvent *) x));
53918 }
53919 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
53920 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
53921 }
53922 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
53923 return (void *)((wxEvent *) ((wxShowEvent *) x));
53924 }
53925 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
53926 return (void *)((wxEvent *) ((wxCommandEvent *) x));
53927 }
53928 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
53929 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
53930 }
53931 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
53932 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
53933 }
53934 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
53935 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
53936 }
53937 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
53938 return (void *)((wxEvent *) ((wxKeyEvent *) x));
53939 }
53940 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
53941 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
53942 }
53943 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
53944 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
53945 }
53946 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
53947 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
53948 }
53949 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
53950 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
53951 }
53952 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
53953 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
53954 }
53955 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
53956 return (void *)((wxControl *) ((wxControlWithItems *) x));
53957 }
53958 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
53959 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
53960 }
53961 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
53962 return (void *)((wxEvtHandler *) ((wxWindow *) x));
53963 }
53964 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
53965 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
53966 }
53967 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
53968 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
53969 }
53970 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
53971 return (void *)((wxEvtHandler *) ((wxValidator *) x));
53972 }
53973 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
53974 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
53975 }
53976 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
53977 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
53978 }
53979 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
53980 return (void *)((wxEvtHandler *) ((wxMenu *) x));
53981 }
53982 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
53983 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
53984 }
53985 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
53986 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
53987 }
53988 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
53989 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
53990 }
53991 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
53992 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
53993 }
53994 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
53995 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
53996 }
53997 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
53998 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
53999 }
54000 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54001 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54002 }
54003 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54004 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54005 }
54006 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54007 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54008 }
54009 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54010 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54011 }
54012 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54013 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54014 }
54015 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54016 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54017 }
54018 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54019 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54020 }
54021 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54022 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54023 }
54024 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54025 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54026 }
54027 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54028 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54029 }
54030 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54031 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54032 }
54033 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54034 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54035 }
54036 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54037 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54038 }
54039 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54040 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54041 }
54042 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54043 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54044 }
54045 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54046 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54047 }
54048 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54049 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54050 }
54051 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54052 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54053 }
54054 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54055 return (void *)((wxObject *) ((wxSizerItem *) x));
54056 }
54057 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54058 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54059 }
54060 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54061 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54062 }
54063 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54064 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54065 }
54066 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54067 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54068 }
54069 static void *_p_wxSizerTo_p_wxObject(void *x) {
54070 return (void *)((wxObject *) ((wxSizer *) x));
54071 }
54072 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54073 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54074 }
54075 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54076 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54077 }
54078 static void *_p_wxEventTo_p_wxObject(void *x) {
54079 return (void *)((wxObject *) ((wxEvent *) x));
54080 }
54081 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54082 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54083 }
54084 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54085 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54086 }
54087 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54088 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54089 }
54090 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54091 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54092 }
54093 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54094 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54095 }
54096 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54097 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54098 }
54099 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54100 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54101 }
54102 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54103 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54104 }
54105 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54106 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54107 }
54108 static void *_p_wxControlTo_p_wxObject(void *x) {
54109 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54110 }
54111 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54112 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54113 }
54114 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54115 return (void *)((wxObject *) ((wxFSFile *) x));
54116 }
54117 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54118 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54119 }
54120 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54121 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54122 }
54123 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54124 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54125 }
54126 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54127 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54128 }
54129 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54130 return (void *)((wxObject *) ((wxMenuItem *) x));
54131 }
54132 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54133 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54134 }
54135 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54136 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54137 }
54138 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54139 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54140 }
54141 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54142 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54143 }
54144 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54145 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54146 }
54147 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54148 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54149 }
54150 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54151 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54152 }
54153 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54154 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54155 }
54156 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54157 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54158 }
54159 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54160 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54161 }
54162 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54163 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54164 }
54165 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54166 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54167 }
54168 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54169 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54170 }
54171 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54172 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54173 }
54174 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54175 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54176 }
54177 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54178 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54179 }
54180 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54181 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54182 }
54183 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54184 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54185 }
54186 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54187 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54188 }
54189 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54190 return (void *)((wxObject *) ((wxImageHandler *) x));
54191 }
54192 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54193 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54194 }
54195 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54196 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54197 }
54198 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54199 return (void *)((wxObject *) ((wxEvtHandler *) x));
54200 }
54201 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54202 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54203 }
54204 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54205 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54206 }
54207 static void *_p_wxImageTo_p_wxObject(void *x) {
54208 return (void *)((wxObject *) ((wxImage *) x));
54209 }
54210 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54211 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54212 }
54213 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54214 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54215 }
54216 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54217 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54218 }
54219 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54220 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54221 }
54222 static void *_p_wxWindowTo_p_wxObject(void *x) {
54223 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54224 }
54225 static void *_p_wxMenuTo_p_wxObject(void *x) {
54226 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54227 }
54228 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54229 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54230 }
54231 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54232 return (void *)((wxObject *) ((wxFileSystem *) x));
54233 }
54234 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54235 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54236 }
54237 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54238 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54239 }
54240 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54241 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54242 }
54243 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54244 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54245 }
54246 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54247 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54248 }
54249 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54250 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54251 }
54252 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54253 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54254 }
54255 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54256 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54257 }
54258 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54259 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54260 }
54261 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54262 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54263 }
54264 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54265 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54266 }
54267 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54268 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54269 }
54270 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54271 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54272 }
54273 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54274 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54275 }
54276 static void *_p_wxControlTo_p_wxWindow(void *x) {
54277 return (void *)((wxWindow *) ((wxControl *) x));
54278 }
54279 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54280 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54281 }
54282 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54283 return (void *)((wxWindow *) ((wxMenuBar *) x));
54284 }
54285 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54286 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54287 }
54288 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54289 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54290 }
54291 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54292 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54293 }
54294 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54295 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54296 }
54297 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54298 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54299 }
54300 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54301 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54302 }
54303 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54304 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54305 }
54306 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54307 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54308 }
54309 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54310 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54311 }
54312 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54313 return (void *)((wxValidator *) ((wxPyValidator *) x));
54314 }
54315 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54316 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54317 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};
54318 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54319 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54320 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54321 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54322 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54323 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54324 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54325 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54326 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54327 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54328 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54329 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54330 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54331 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54332 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54333 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54334 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54335 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54336 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54337 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54338 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54339 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54340 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54341 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54342 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54343 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54344 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54345 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54346 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54347 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54348 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54349 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54350 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54351 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54352 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54353 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54354 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54355 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54356 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54357 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54358 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54359 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54360 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54361 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54362 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54363 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54364 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54365 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54366 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54367 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54368 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54369 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54370 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54371 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54372 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54373 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54374 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54375 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54376 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54377 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54378 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54379 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54380 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54381 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54382 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54383 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54384 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54385 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54386 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54387 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54388 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54389 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54390 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54391 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54392 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54393 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54394 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54395 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54396 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54397 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54398 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54399 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54400 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54401 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54402 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54403 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54404 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54405 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54406 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54407 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54408 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54409 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54410 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54411 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54412 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54413 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54414 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54415 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54416 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54417 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54418 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54419 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54420 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54421 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54422 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54423 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54424 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54425 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54426 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54427 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54428 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54429 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54430 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54431 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54432 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54433 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54434 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54435 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54436 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54437 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54438 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54439 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54440 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54441 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54442 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54443 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54444
54445 static swig_type_info *swig_type_initial[] = {
54446 &_swigt__p_buffer,
54447 &_swigt__p_char,
54448 &_swigt__p_form_ops_t,
54449 &_swigt__p_int,
54450 &_swigt__p_long,
54451 &_swigt__p_unsigned_char,
54452 &_swigt__p_unsigned_int,
54453 &_swigt__p_unsigned_long,
54454 &_swigt__p_wxANIHandler,
54455 &_swigt__p_wxAcceleratorEntry,
54456 &_swigt__p_wxAcceleratorTable,
54457 &_swigt__p_wxActivateEvent,
54458 &_swigt__p_wxAppTraits,
54459 &_swigt__p_wxArrayString,
54460 &_swigt__p_wxBMPHandler,
54461 &_swigt__p_wxBitmap,
54462 &_swigt__p_wxBoxSizer,
54463 &_swigt__p_wxButton,
54464 &_swigt__p_wxCURHandler,
54465 &_swigt__p_wxCaret,
54466 &_swigt__p_wxChildFocusEvent,
54467 &_swigt__p_wxCloseEvent,
54468 &_swigt__p_wxColour,
54469 &_swigt__p_wxCommandEvent,
54470 &_swigt__p_wxContextMenuEvent,
54471 &_swigt__p_wxControl,
54472 &_swigt__p_wxControlWithItems,
54473 &_swigt__p_wxCursor,
54474 &_swigt__p_wxDC,
54475 &_swigt__p_wxDateEvent,
54476 &_swigt__p_wxDateTime,
54477 &_swigt__p_wxDisplayChangedEvent,
54478 &_swigt__p_wxDropFilesEvent,
54479 &_swigt__p_wxDuplexMode,
54480 &_swigt__p_wxEraseEvent,
54481 &_swigt__p_wxEvent,
54482 &_swigt__p_wxEventLoop,
54483 &_swigt__p_wxEventLoopActivator,
54484 &_swigt__p_wxEvtHandler,
54485 &_swigt__p_wxFSFile,
54486 &_swigt__p_wxFileSystem,
54487 &_swigt__p_wxFileSystemHandler,
54488 &_swigt__p_wxFlexGridSizer,
54489 &_swigt__p_wxFocusEvent,
54490 &_swigt__p_wxFont,
54491 &_swigt__p_wxFrame,
54492 &_swigt__p_wxGBPosition,
54493 &_swigt__p_wxGBSizerItem,
54494 &_swigt__p_wxGBSpan,
54495 &_swigt__p_wxGIFHandler,
54496 &_swigt__p_wxGridBagSizer,
54497 &_swigt__p_wxGridSizer,
54498 &_swigt__p_wxICOHandler,
54499 &_swigt__p_wxIconizeEvent,
54500 &_swigt__p_wxIdleEvent,
54501 &_swigt__p_wxImage,
54502 &_swigt__p_wxImageHandler,
54503 &_swigt__p_wxImageHistogram,
54504 &_swigt__p_wxImage_HSVValue,
54505 &_swigt__p_wxImage_RGBValue,
54506 &_swigt__p_wxIndividualLayoutConstraint,
54507 &_swigt__p_wxInitDialogEvent,
54508 &_swigt__p_wxInputStream,
54509 &_swigt__p_wxInternetFSHandler,
54510 &_swigt__p_wxItemContainer,
54511 &_swigt__p_wxJPEGHandler,
54512 &_swigt__p_wxKeyEvent,
54513 &_swigt__p_wxLayoutConstraints,
54514 &_swigt__p_wxMaximizeEvent,
54515 &_swigt__p_wxMemoryFSHandler,
54516 &_swigt__p_wxMenu,
54517 &_swigt__p_wxMenuBar,
54518 &_swigt__p_wxMenuBarBase,
54519 &_swigt__p_wxMenuEvent,
54520 &_swigt__p_wxMenuItem,
54521 &_swigt__p_wxMouseCaptureChangedEvent,
54522 &_swigt__p_wxMouseEvent,
54523 &_swigt__p_wxMoveEvent,
54524 &_swigt__p_wxNavigationKeyEvent,
54525 &_swigt__p_wxNcPaintEvent,
54526 &_swigt__p_wxNotifyEvent,
54527 &_swigt__p_wxObject,
54528 &_swigt__p_wxOutputStream,
54529 &_swigt__p_wxPCXHandler,
54530 &_swigt__p_wxPNGHandler,
54531 &_swigt__p_wxPNMHandler,
54532 &_swigt__p_wxPaintEvent,
54533 &_swigt__p_wxPaletteChangedEvent,
54534 &_swigt__p_wxPaperSize,
54535 &_swigt__p_wxPoint,
54536 &_swigt__p_wxPoint2D,
54537 &_swigt__p_wxPropagateOnce,
54538 &_swigt__p_wxPropagationDisabler,
54539 &_swigt__p_wxPyApp,
54540 &_swigt__p_wxPyCommandEvent,
54541 &_swigt__p_wxPyDropTarget,
54542 &_swigt__p_wxPyEvent,
54543 &_swigt__p_wxPyFileSystemHandler,
54544 &_swigt__p_wxPyImageHandler,
54545 &_swigt__p_wxPyInputStream,
54546 &_swigt__p_wxPySizer,
54547 &_swigt__p_wxPyValidator,
54548 &_swigt__p_wxQuantize,
54549 &_swigt__p_wxQueryNewPaletteEvent,
54550 &_swigt__p_wxRealPoint,
54551 &_swigt__p_wxRect,
54552 &_swigt__p_wxRegion,
54553 &_swigt__p_wxScrollEvent,
54554 &_swigt__p_wxScrollWinEvent,
54555 &_swigt__p_wxSetCursorEvent,
54556 &_swigt__p_wxShowEvent,
54557 &_swigt__p_wxSize,
54558 &_swigt__p_wxSizeEvent,
54559 &_swigt__p_wxSizer,
54560 &_swigt__p_wxSizerItem,
54561 &_swigt__p_wxStaticBox,
54562 &_swigt__p_wxStaticBoxSizer,
54563 &_swigt__p_wxStdDialogButtonSizer,
54564 &_swigt__p_wxSysColourChangedEvent,
54565 &_swigt__p_wxTIFFHandler,
54566 &_swigt__p_wxToolTip,
54567 &_swigt__p_wxUpdateUIEvent,
54568 &_swigt__p_wxValidator,
54569 &_swigt__p_wxVisualAttributes,
54570 &_swigt__p_wxWindow,
54571 &_swigt__p_wxWindowCreateEvent,
54572 &_swigt__p_wxWindowDestroyEvent,
54573 &_swigt__p_wxXPMHandler,
54574 &_swigt__p_wxZipFSHandler,
54575 };
54576
54577 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54578 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54579 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54580 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54581 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54582 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54583 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54584 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54585 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54586 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54587 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54588 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54589 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54590 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54591 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}};
54592 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54593 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}};
54594 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54595 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}};
54596 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54597 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54598 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54599 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54600 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_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}};
54601 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54602 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}};
54603 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54604 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54605 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54606 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54607 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54608 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54609 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54610 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54611 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54612 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_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_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_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_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}};
54613 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54614 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54615 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}};
54616 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54617 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54618 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}};
54619 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}};
54620 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54621 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54622 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54623 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54624 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54625 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54626 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54627 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54628 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}};
54629 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}};
54630 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54631 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54632 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54633 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
54634 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54635 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54636 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54637 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54638 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54639 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54640 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54641 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}};
54642 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54643 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54644 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54645 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54646 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54647 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54648 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54649 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54650 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54651 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54652 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54653 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54654 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54655 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54656 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54657 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54658 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_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_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_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_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}};
54659 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54660 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54661 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54662 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54663 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54664 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54665 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54666 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54667 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54668 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54669 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54670 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54671 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54672 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54673 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54674 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54675 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54676 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54677 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54678 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54679 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54680 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54681 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54682 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54683 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54684 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54685 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54686 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54687 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54688 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54689 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54690 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}};
54691 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}};
54692 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54693 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54694 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54695 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54696 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54697 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54698 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54699 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}};
54700 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54701 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}};
54702 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54703 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54704 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54705 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54706
54707 static swig_cast_info *swig_cast_initial[] = {
54708 _swigc__p_buffer,
54709 _swigc__p_char,
54710 _swigc__p_form_ops_t,
54711 _swigc__p_int,
54712 _swigc__p_long,
54713 _swigc__p_unsigned_char,
54714 _swigc__p_unsigned_int,
54715 _swigc__p_unsigned_long,
54716 _swigc__p_wxANIHandler,
54717 _swigc__p_wxAcceleratorEntry,
54718 _swigc__p_wxAcceleratorTable,
54719 _swigc__p_wxActivateEvent,
54720 _swigc__p_wxAppTraits,
54721 _swigc__p_wxArrayString,
54722 _swigc__p_wxBMPHandler,
54723 _swigc__p_wxBitmap,
54724 _swigc__p_wxBoxSizer,
54725 _swigc__p_wxButton,
54726 _swigc__p_wxCURHandler,
54727 _swigc__p_wxCaret,
54728 _swigc__p_wxChildFocusEvent,
54729 _swigc__p_wxCloseEvent,
54730 _swigc__p_wxColour,
54731 _swigc__p_wxCommandEvent,
54732 _swigc__p_wxContextMenuEvent,
54733 _swigc__p_wxControl,
54734 _swigc__p_wxControlWithItems,
54735 _swigc__p_wxCursor,
54736 _swigc__p_wxDC,
54737 _swigc__p_wxDateEvent,
54738 _swigc__p_wxDateTime,
54739 _swigc__p_wxDisplayChangedEvent,
54740 _swigc__p_wxDropFilesEvent,
54741 _swigc__p_wxDuplexMode,
54742 _swigc__p_wxEraseEvent,
54743 _swigc__p_wxEvent,
54744 _swigc__p_wxEventLoop,
54745 _swigc__p_wxEventLoopActivator,
54746 _swigc__p_wxEvtHandler,
54747 _swigc__p_wxFSFile,
54748 _swigc__p_wxFileSystem,
54749 _swigc__p_wxFileSystemHandler,
54750 _swigc__p_wxFlexGridSizer,
54751 _swigc__p_wxFocusEvent,
54752 _swigc__p_wxFont,
54753 _swigc__p_wxFrame,
54754 _swigc__p_wxGBPosition,
54755 _swigc__p_wxGBSizerItem,
54756 _swigc__p_wxGBSpan,
54757 _swigc__p_wxGIFHandler,
54758 _swigc__p_wxGridBagSizer,
54759 _swigc__p_wxGridSizer,
54760 _swigc__p_wxICOHandler,
54761 _swigc__p_wxIconizeEvent,
54762 _swigc__p_wxIdleEvent,
54763 _swigc__p_wxImage,
54764 _swigc__p_wxImageHandler,
54765 _swigc__p_wxImageHistogram,
54766 _swigc__p_wxImage_HSVValue,
54767 _swigc__p_wxImage_RGBValue,
54768 _swigc__p_wxIndividualLayoutConstraint,
54769 _swigc__p_wxInitDialogEvent,
54770 _swigc__p_wxInputStream,
54771 _swigc__p_wxInternetFSHandler,
54772 _swigc__p_wxItemContainer,
54773 _swigc__p_wxJPEGHandler,
54774 _swigc__p_wxKeyEvent,
54775 _swigc__p_wxLayoutConstraints,
54776 _swigc__p_wxMaximizeEvent,
54777 _swigc__p_wxMemoryFSHandler,
54778 _swigc__p_wxMenu,
54779 _swigc__p_wxMenuBar,
54780 _swigc__p_wxMenuBarBase,
54781 _swigc__p_wxMenuEvent,
54782 _swigc__p_wxMenuItem,
54783 _swigc__p_wxMouseCaptureChangedEvent,
54784 _swigc__p_wxMouseEvent,
54785 _swigc__p_wxMoveEvent,
54786 _swigc__p_wxNavigationKeyEvent,
54787 _swigc__p_wxNcPaintEvent,
54788 _swigc__p_wxNotifyEvent,
54789 _swigc__p_wxObject,
54790 _swigc__p_wxOutputStream,
54791 _swigc__p_wxPCXHandler,
54792 _swigc__p_wxPNGHandler,
54793 _swigc__p_wxPNMHandler,
54794 _swigc__p_wxPaintEvent,
54795 _swigc__p_wxPaletteChangedEvent,
54796 _swigc__p_wxPaperSize,
54797 _swigc__p_wxPoint,
54798 _swigc__p_wxPoint2D,
54799 _swigc__p_wxPropagateOnce,
54800 _swigc__p_wxPropagationDisabler,
54801 _swigc__p_wxPyApp,
54802 _swigc__p_wxPyCommandEvent,
54803 _swigc__p_wxPyDropTarget,
54804 _swigc__p_wxPyEvent,
54805 _swigc__p_wxPyFileSystemHandler,
54806 _swigc__p_wxPyImageHandler,
54807 _swigc__p_wxPyInputStream,
54808 _swigc__p_wxPySizer,
54809 _swigc__p_wxPyValidator,
54810 _swigc__p_wxQuantize,
54811 _swigc__p_wxQueryNewPaletteEvent,
54812 _swigc__p_wxRealPoint,
54813 _swigc__p_wxRect,
54814 _swigc__p_wxRegion,
54815 _swigc__p_wxScrollEvent,
54816 _swigc__p_wxScrollWinEvent,
54817 _swigc__p_wxSetCursorEvent,
54818 _swigc__p_wxShowEvent,
54819 _swigc__p_wxSize,
54820 _swigc__p_wxSizeEvent,
54821 _swigc__p_wxSizer,
54822 _swigc__p_wxSizerItem,
54823 _swigc__p_wxStaticBox,
54824 _swigc__p_wxStaticBoxSizer,
54825 _swigc__p_wxStdDialogButtonSizer,
54826 _swigc__p_wxSysColourChangedEvent,
54827 _swigc__p_wxTIFFHandler,
54828 _swigc__p_wxToolTip,
54829 _swigc__p_wxUpdateUIEvent,
54830 _swigc__p_wxValidator,
54831 _swigc__p_wxVisualAttributes,
54832 _swigc__p_wxWindow,
54833 _swigc__p_wxWindowCreateEvent,
54834 _swigc__p_wxWindowDestroyEvent,
54835 _swigc__p_wxXPMHandler,
54836 _swigc__p_wxZipFSHandler,
54837 };
54838
54839
54840 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
54841
54842 static swig_const_info swig_const_table[] = {
54843 {0, 0, 0, 0.0, 0, 0}};
54844
54845 #ifdef __cplusplus
54846 }
54847 #endif
54848 /* -----------------------------------------------------------------------------
54849 * Type initialization:
54850 * This problem is tough by the requirement that no dynamic
54851 * memory is used. Also, since swig_type_info structures store pointers to
54852 * swig_cast_info structures and swig_cast_info structures store pointers back
54853 * to swig_type_info structures, we need some lookup code at initialization.
54854 * The idea is that swig generates all the structures that are needed.
54855 * The runtime then collects these partially filled structures.
54856 * The SWIG_InitializeModule function takes these initial arrays out of
54857 * swig_module, and does all the lookup, filling in the swig_module.types
54858 * array with the correct data and linking the correct swig_cast_info
54859 * structures together.
54860 *
54861 * The generated swig_type_info structures are assigned staticly to an initial
54862 * array. We just loop though that array, and handle each type individually.
54863 * First we lookup if this type has been already loaded, and if so, use the
54864 * loaded structure instead of the generated one. Then we have to fill in the
54865 * cast linked list. The cast data is initially stored in something like a
54866 * two-dimensional array. Each row corresponds to a type (there are the same
54867 * number of rows as there are in the swig_type_initial array). Each entry in
54868 * a column is one of the swig_cast_info structures for that type.
54869 * The cast_initial array is actually an array of arrays, because each row has
54870 * a variable number of columns. So to actually build the cast linked list,
54871 * we find the array of casts associated with the type, and loop through it
54872 * adding the casts to the list. The one last trick we need to do is making
54873 * sure the type pointer in the swig_cast_info struct is correct.
54874 *
54875 * First off, we lookup the cast->type name to see if it is already loaded.
54876 * There are three cases to handle:
54877 * 1) If the cast->type has already been loaded AND the type we are adding
54878 * casting info to has not been loaded (it is in this module), THEN we
54879 * replace the cast->type pointer with the type pointer that has already
54880 * been loaded.
54881 * 2) If BOTH types (the one we are adding casting info to, and the
54882 * cast->type) are loaded, THEN the cast info has already been loaded by
54883 * the previous module so we just ignore it.
54884 * 3) Finally, if cast->type has not already been loaded, then we add that
54885 * swig_cast_info to the linked list (because the cast->type) pointer will
54886 * be correct.
54887 * ----------------------------------------------------------------------------- */
54888
54889 #ifdef __cplusplus
54890 extern "C" {
54891 #if 0
54892 } /* c-mode */
54893 #endif
54894 #endif
54895
54896 #if 0
54897 #define SWIGRUNTIME_DEBUG
54898 #endif
54899
54900 SWIGRUNTIME void
54901 SWIG_InitializeModule(void *clientdata) {
54902 size_t i;
54903 swig_module_info *module_head;
54904 static int init_run = 0;
54905
54906 clientdata = clientdata;
54907
54908 if (init_run) return;
54909 init_run = 1;
54910
54911 /* Initialize the swig_module */
54912 swig_module.type_initial = swig_type_initial;
54913 swig_module.cast_initial = swig_cast_initial;
54914
54915 /* Try and load any already created modules */
54916 module_head = SWIG_GetModule(clientdata);
54917 if (module_head) {
54918 swig_module.next = module_head->next;
54919 module_head->next = &swig_module;
54920 } else {
54921 /* This is the first module loaded */
54922 swig_module.next = &swig_module;
54923 SWIG_SetModule(clientdata, &swig_module);
54924 }
54925
54926 /* Now work on filling in swig_module.types */
54927 #ifdef SWIGRUNTIME_DEBUG
54928 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
54929 #endif
54930 for (i = 0; i < swig_module.size; ++i) {
54931 swig_type_info *type = 0;
54932 swig_type_info *ret;
54933 swig_cast_info *cast;
54934
54935 #ifdef SWIGRUNTIME_DEBUG
54936 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
54937 #endif
54938
54939 /* if there is another module already loaded */
54940 if (swig_module.next != &swig_module) {
54941 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
54942 }
54943 if (type) {
54944 /* Overwrite clientdata field */
54945 #ifdef SWIGRUNTIME_DEBUG
54946 printf("SWIG_InitializeModule: found type %s\n", type->name);
54947 #endif
54948 if (swig_module.type_initial[i]->clientdata) {
54949 type->clientdata = swig_module.type_initial[i]->clientdata;
54950 #ifdef SWIGRUNTIME_DEBUG
54951 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
54952 #endif
54953 }
54954 } else {
54955 type = swig_module.type_initial[i];
54956 }
54957
54958 /* Insert casting types */
54959 cast = swig_module.cast_initial[i];
54960 while (cast->type) {
54961 /* Don't need to add information already in the list */
54962 ret = 0;
54963 #ifdef SWIGRUNTIME_DEBUG
54964 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
54965 #endif
54966 if (swig_module.next != &swig_module) {
54967 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
54968 #ifdef SWIGRUNTIME_DEBUG
54969 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
54970 #endif
54971 }
54972 if (ret) {
54973 if (type == swig_module.type_initial[i]) {
54974 #ifdef SWIGRUNTIME_DEBUG
54975 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
54976 #endif
54977 cast->type = ret;
54978 ret = 0;
54979 } else {
54980 /* Check for casting already in the list */
54981 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
54982 #ifdef SWIGRUNTIME_DEBUG
54983 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
54984 #endif
54985 if (!ocast) ret = 0;
54986 }
54987 }
54988
54989 if (!ret) {
54990 #ifdef SWIGRUNTIME_DEBUG
54991 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
54992 #endif
54993 if (type->cast) {
54994 type->cast->prev = cast;
54995 cast->next = type->cast;
54996 }
54997 type->cast = cast;
54998 }
54999 cast++;
55000 }
55001 /* Set entry in modules->types array equal to the type */
55002 swig_module.types[i] = type;
55003 }
55004 swig_module.types[i] = 0;
55005
55006 #ifdef SWIGRUNTIME_DEBUG
55007 printf("**** SWIG_InitializeModule: Cast List ******\n");
55008 for (i = 0; i < swig_module.size; ++i) {
55009 int j = 0;
55010 swig_cast_info *cast = swig_module.cast_initial[i];
55011 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55012 while (cast->type) {
55013 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55014 cast++;
55015 ++j;
55016 }
55017 printf("---- Total casts: %d\n",j);
55018 }
55019 printf("**** SWIG_InitializeModule: Cast List ******\n");
55020 #endif
55021 }
55022
55023 /* This function will propagate the clientdata field of type to
55024 * any new swig_type_info structures that have been added into the list
55025 * of equivalent types. It is like calling
55026 * SWIG_TypeClientData(type, clientdata) a second time.
55027 */
55028 SWIGRUNTIME void
55029 SWIG_PropagateClientData(void) {
55030 size_t i;
55031 swig_cast_info *equiv;
55032 static int init_run = 0;
55033
55034 if (init_run) return;
55035 init_run = 1;
55036
55037 for (i = 0; i < swig_module.size; i++) {
55038 if (swig_module.types[i]->clientdata) {
55039 equiv = swig_module.types[i]->cast;
55040 while (equiv) {
55041 if (!equiv->converter) {
55042 if (equiv->type && !equiv->type->clientdata)
55043 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55044 }
55045 equiv = equiv->next;
55046 }
55047 }
55048 }
55049 }
55050
55051 #ifdef __cplusplus
55052 #if 0
55053 {
55054 /* c-mode */
55055 #endif
55056 }
55057 #endif
55058
55059
55060
55061 #ifdef __cplusplus
55062 extern "C" {
55063 #endif
55064
55065 /* Python-specific SWIG API */
55066 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55067 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55068 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55069
55070 /* -----------------------------------------------------------------------------
55071 * global variable support code.
55072 * ----------------------------------------------------------------------------- */
55073
55074 typedef struct swig_globalvar {
55075 char *name; /* Name of global variable */
55076 PyObject *(*get_attr)(void); /* Return the current value */
55077 int (*set_attr)(PyObject *); /* Set the value */
55078 struct swig_globalvar *next;
55079 } swig_globalvar;
55080
55081 typedef struct swig_varlinkobject {
55082 PyObject_HEAD
55083 swig_globalvar *vars;
55084 } swig_varlinkobject;
55085
55086 SWIGINTERN PyObject *
55087 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55088 return PyString_FromString("<Swig global variables>");
55089 }
55090
55091 SWIGINTERN PyObject *
55092 swig_varlink_str(swig_varlinkobject *v) {
55093 PyObject *str = PyString_FromString("(");
55094 swig_globalvar *var;
55095 for (var = v->vars; var; var=var->next) {
55096 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55097 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55098 }
55099 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55100 return str;
55101 }
55102
55103 SWIGINTERN int
55104 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55105 PyObject *str = swig_varlink_str(v);
55106 fprintf(fp,"Swig global variables ");
55107 fprintf(fp,"%s\n", PyString_AsString(str));
55108 Py_DECREF(str);
55109 return 0;
55110 }
55111
55112 SWIGINTERN void
55113 swig_varlink_dealloc(swig_varlinkobject *v) {
55114 swig_globalvar *var = v->vars;
55115 while (var) {
55116 swig_globalvar *n = var->next;
55117 free(var->name);
55118 free(var);
55119 var = n;
55120 }
55121 }
55122
55123 SWIGINTERN PyObject *
55124 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55125 PyObject *res = NULL;
55126 swig_globalvar *var = v->vars;
55127 while (var) {
55128 if (strcmp(var->name,n) == 0) {
55129 res = (*var->get_attr)();
55130 break;
55131 }
55132 var = var->next;
55133 }
55134 if (res == NULL && !PyErr_Occurred()) {
55135 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55136 }
55137 return res;
55138 }
55139
55140 SWIGINTERN int
55141 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55142 int res = 1;
55143 swig_globalvar *var = v->vars;
55144 while (var) {
55145 if (strcmp(var->name,n) == 0) {
55146 res = (*var->set_attr)(p);
55147 break;
55148 }
55149 var = var->next;
55150 }
55151 if (res == 1 && !PyErr_Occurred()) {
55152 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55153 }
55154 return res;
55155 }
55156
55157 SWIGINTERN PyTypeObject*
55158 swig_varlink_type(void) {
55159 static char varlink__doc__[] = "Swig var link object";
55160 static PyTypeObject varlink_type;
55161 static int type_init = 0;
55162 if (!type_init) {
55163 const PyTypeObject tmp
55164 = {
55165 PyObject_HEAD_INIT(NULL)
55166 0, /* Number of items in variable part (ob_size) */
55167 (char *)"swigvarlink", /* Type name (tp_name) */
55168 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55169 0, /* Itemsize (tp_itemsize) */
55170 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55171 (printfunc) swig_varlink_print, /* Print (tp_print) */
55172 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55173 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55174 0, /* tp_compare */
55175 (reprfunc) swig_varlink_repr, /* tp_repr */
55176 0, /* tp_as_number */
55177 0, /* tp_as_sequence */
55178 0, /* tp_as_mapping */
55179 0, /* tp_hash */
55180 0, /* tp_call */
55181 (reprfunc)swig_varlink_str, /* tp_str */
55182 0, /* tp_getattro */
55183 0, /* tp_setattro */
55184 0, /* tp_as_buffer */
55185 0, /* tp_flags */
55186 varlink__doc__, /* tp_doc */
55187 0, /* tp_traverse */
55188 0, /* tp_clear */
55189 0, /* tp_richcompare */
55190 0, /* tp_weaklistoffset */
55191 #if PY_VERSION_HEX >= 0x02020000
55192 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55193 #endif
55194 #if PY_VERSION_HEX >= 0x02030000
55195 0, /* tp_del */
55196 #endif
55197 #ifdef COUNT_ALLOCS
55198 0,0,0,0 /* tp_alloc -> tp_next */
55199 #endif
55200 };
55201 varlink_type = tmp;
55202 varlink_type.ob_type = &PyType_Type;
55203 type_init = 1;
55204 }
55205 return &varlink_type;
55206 }
55207
55208 /* Create a variable linking object for use later */
55209 SWIGINTERN PyObject *
55210 SWIG_Python_newvarlink(void) {
55211 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55212 if (result) {
55213 result->vars = 0;
55214 }
55215 return ((PyObject*) result);
55216 }
55217
55218 SWIGINTERN void
55219 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55220 swig_varlinkobject *v = (swig_varlinkobject *) p;
55221 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55222 if (gv) {
55223 size_t size = strlen(name)+1;
55224 gv->name = (char *)malloc(size);
55225 if (gv->name) {
55226 strncpy(gv->name,name,size);
55227 gv->get_attr = get_attr;
55228 gv->set_attr = set_attr;
55229 gv->next = v->vars;
55230 }
55231 }
55232 v->vars = gv;
55233 }
55234
55235 SWIGINTERN PyObject *
55236 SWIG_globals() {
55237 static PyObject *_SWIG_globals = 0;
55238 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55239 return _SWIG_globals;
55240 }
55241
55242 /* -----------------------------------------------------------------------------
55243 * constants/methods manipulation
55244 * ----------------------------------------------------------------------------- */
55245
55246 /* Install Constants */
55247 SWIGINTERN void
55248 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55249 PyObject *obj = 0;
55250 size_t i;
55251 for (i = 0; constants[i].type; ++i) {
55252 switch(constants[i].type) {
55253 case SWIG_PY_POINTER:
55254 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55255 break;
55256 case SWIG_PY_BINARY:
55257 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55258 break;
55259 default:
55260 obj = 0;
55261 break;
55262 }
55263 if (obj) {
55264 PyDict_SetItemString(d, constants[i].name, obj);
55265 Py_DECREF(obj);
55266 }
55267 }
55268 }
55269
55270 /* -----------------------------------------------------------------------------*/
55271 /* Fix SwigMethods to carry the callback ptrs when needed */
55272 /* -----------------------------------------------------------------------------*/
55273
55274 SWIGINTERN void
55275 SWIG_Python_FixMethods(PyMethodDef *methods,
55276 swig_const_info *const_table,
55277 swig_type_info **types,
55278 swig_type_info **types_initial) {
55279 size_t i;
55280 for (i = 0; methods[i].ml_name; ++i) {
55281 char *c = methods[i].ml_doc;
55282 if (c && (c = strstr(c, "swig_ptr: "))) {
55283 int j;
55284 swig_const_info *ci = 0;
55285 char *name = c + 10;
55286 for (j = 0; const_table[j].type; ++j) {
55287 if (strncmp(const_table[j].name, name,
55288 strlen(const_table[j].name)) == 0) {
55289 ci = &(const_table[j]);
55290 break;
55291 }
55292 }
55293 if (ci) {
55294 size_t shift = (ci->ptype) - types;
55295 swig_type_info *ty = types_initial[shift];
55296 size_t ldoc = (c - methods[i].ml_doc);
55297 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55298 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55299 if (ndoc) {
55300 char *buff = ndoc;
55301 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55302 if (ptr) {
55303 strncpy(buff, methods[i].ml_doc, ldoc);
55304 buff += ldoc;
55305 strncpy(buff, "swig_ptr: ", 10);
55306 buff += 10;
55307 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55308 methods[i].ml_doc = ndoc;
55309 }
55310 }
55311 }
55312 }
55313 }
55314 }
55315
55316 #ifdef __cplusplus
55317 }
55318 #endif
55319
55320 /* -----------------------------------------------------------------------------*
55321 * Partial Init method
55322 * -----------------------------------------------------------------------------*/
55323
55324 #ifdef __cplusplus
55325 extern "C"
55326 #endif
55327 SWIGEXPORT void SWIG_init(void) {
55328 PyObject *m, *d;
55329
55330 /* Fix SwigMethods to carry the callback ptrs when needed */
55331 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55332
55333 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55334 d = PyModule_GetDict(m);
55335
55336 SWIG_InitializeModule(0);
55337 SWIG_InstallConstants(d,swig_const_table);
55338
55339
55340
55341 #ifndef wxPyUSE_EXPORT
55342 // Make our API structure a CObject so other modules can import it
55343 // from this module.
55344 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55345 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55346 Py_XDECREF(cobj);
55347 #endif
55348
55349 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55350 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55351 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55352 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55353 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55354 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55355 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55356 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55357 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55358 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55359 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55360 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55361 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55362 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55363 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55364 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55365 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55366 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55367 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55368 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55369 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55370 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55371 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55372 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55373 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55374 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55375 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55376 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55377 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55378 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55379 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55380 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55381 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55382 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55383 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55384 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55385 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55386 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55387 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55388 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55389 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55390 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55391 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55392 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55393 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55394 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55395 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55396 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55397 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55398 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55399 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55400 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55401 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55402 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55403 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55404 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55405 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55406 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55407 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55408 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55409 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55410 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55411 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55412 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55413 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55414 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55415 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55416 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55417 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55418 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55419 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55420 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55421 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55422 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55423 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55424 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55425 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55426 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55427 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55428 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55429 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55430 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55431 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55432 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55433 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55434 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55435 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55436 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55437 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55438 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55439 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55440 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55441 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55442 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55443 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55444 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55445 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55446 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55447 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55448 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55449 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55450 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55451 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55452 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55453 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55454 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55455 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55456 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55457 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55458 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55459 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55460 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55461 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55462 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55463 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55464 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55465 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55466 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55467 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55468 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55469 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55470 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55471 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55472 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55473 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55474 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55475 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55476 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55477 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55478 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55479 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55480 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55481 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55482 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55483 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55484 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55485 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55486 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55487 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55488 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55489 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55490 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55491 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55492 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55493 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55494 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55495 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55496 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55497 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55498 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55499 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55500 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55501 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55502 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55503 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55504 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55505 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55506 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55507 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55508 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55509 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55510 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55511 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55512 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55513 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55514 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55515 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55516 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55517 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55518 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55519 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55520 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55521 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55522 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55523 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55524 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55525 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55526 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55527 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55528 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55529 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55530 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55531 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55532 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55533 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55534 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55535 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55536 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55537 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55538 SWIG_Python_SetConstant(d, "OPEN",SWIG_From_int(static_cast< int >(wxOPEN)));
55539 SWIG_Python_SetConstant(d, "SAVE",SWIG_From_int(static_cast< int >(wxSAVE)));
55540 SWIG_Python_SetConstant(d, "HIDE_READONLY",SWIG_From_int(static_cast< int >(wxHIDE_READONLY)));
55541 SWIG_Python_SetConstant(d, "OVERWRITE_PROMPT",SWIG_From_int(static_cast< int >(wxOVERWRITE_PROMPT)));
55542 SWIG_Python_SetConstant(d, "FILE_MUST_EXIST",SWIG_From_int(static_cast< int >(wxFILE_MUST_EXIST)));
55543 SWIG_Python_SetConstant(d, "MULTIPLE",SWIG_From_int(static_cast< int >(wxMULTIPLE)));
55544 SWIG_Python_SetConstant(d, "CHANGE_DIR",SWIG_From_int(static_cast< int >(wxCHANGE_DIR)));
55545 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55546 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55547 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55548 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55549 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55550 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55551 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55552 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55553 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55554 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55555 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55556 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55557 SWIG_Python_SetConstant(d, "DD_NEW_DIR_BUTTON",SWIG_From_int(static_cast< int >(wxDD_NEW_DIR_BUTTON)));
55558 SWIG_Python_SetConstant(d, "DD_DEFAULT_STYLE",SWIG_From_int(static_cast< int >(wxDD_DEFAULT_STYLE)));
55559 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55560 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55561 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55562 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55563 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55564 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55565 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55566 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55567 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55568 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55569 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55570 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55571 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55572 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55573 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55574 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55575 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55576 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55577 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55578 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55579 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55580 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55581 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55582 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55583 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55584 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55585 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55586 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55587 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55588 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55589 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55590 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55591 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55592 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55593 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55594 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55595 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55596 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55597 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55598 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55599 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55600 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55601 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55602 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55603 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55604 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55605 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55606 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55607 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55608 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55609 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55610 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55611 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55612 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55613 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55614 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55615 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55616 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55617 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55618 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55619 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55620 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55621 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55622 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55623 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55624 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55625 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55626 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55627 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55628 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55629 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55630 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55631 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55632 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55633 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55634 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55635 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55636 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55637 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55638 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55639 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55640 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55641 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55642 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55643 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55644 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55645 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55646 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55647 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55648 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55649 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55650 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55651 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55652 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55653 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55654 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55655 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55656 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55657 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55658 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55659 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55660 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55661 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55662 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55663 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55664 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55665 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55666 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55667 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55668 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55669 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55670 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55671 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55672 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55673 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55674 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55675 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55676 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55677 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55678 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55679 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55680 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55681 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55682 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55683 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55684 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55685 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55686 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55687 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55688 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55689 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55690 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55691 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55692 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55693 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55694 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55695 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55696 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55697 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55698 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55699 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55700 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55701 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55702 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55703 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55704 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55705 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55706 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55707 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55708 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55709 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55710 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55711 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55712 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55713 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55714 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55715 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55716 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55717 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55718 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55719 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55720 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55721 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55722 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55723 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55724 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55725 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55726 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55727 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55728 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55729 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55730 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55731 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55732 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55733 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55734 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55735 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55736 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55737 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55738 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55739 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55740 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55741 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55742 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55743 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55744 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55745 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55746 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55747 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55748 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55749 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55750 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55751 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55752 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55753 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55754 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55755 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55756 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55757 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55758 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55759 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55760 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55761 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55762 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55763 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55764 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55765 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55766 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55767 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55768 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55769 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55770 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55771 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55772 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55773 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55774 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55775 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55776 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
55777 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
55778 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
55779 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
55780 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
55781 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
55782 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
55783 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
55784 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
55785 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
55786 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
55787 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
55788 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
55789 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
55790 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
55791 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
55792 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
55793 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
55794 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
55795 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
55796 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
55797 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
55798 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
55799 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
55800 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
55801 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
55802 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
55803 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
55804 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
55805 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
55806 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
55807 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
55808 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
55809 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
55810 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
55811 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
55812 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
55813 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
55814 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
55815 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
55816 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
55817 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
55818 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
55819 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
55820 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
55821 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
55822 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
55823 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
55824 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
55825 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
55826 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
55827 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
55828 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
55829 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
55830 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
55831 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
55832 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
55833 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
55834 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
55835 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
55836 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
55837 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
55838 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
55839 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
55840 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
55841 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
55842 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
55843 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
55844 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
55845 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
55846 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
55847 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
55848 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
55849 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
55850 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
55851 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
55852 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
55853 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
55854 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
55855 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
55856 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
55857 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
55858 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
55859 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
55860 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
55861 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
55862 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
55863 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
55864 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
55865 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
55866 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
55867 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
55868 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
55869 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
55870 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
55871 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
55872 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
55873 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
55874 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
55875 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
55876 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
55877 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
55878 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
55879 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
55880 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
55881 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
55882 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
55883 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
55884 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
55885 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
55886 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
55887 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
55888 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
55889 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
55890 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
55891 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
55892 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
55893 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
55894 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
55895 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
55896 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
55897 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
55898 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
55899 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
55900 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
55901 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
55902 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
55903 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
55904 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
55905 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
55906 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
55907 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
55908 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
55909 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
55910 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
55911 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
55912 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
55913 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
55914 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
55915 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
55916 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
55917 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
55918 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
55919 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
55920 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
55921 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
55922 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
55923 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
55924 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
55925 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
55926 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
55927 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
55928 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
55929 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
55930 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
55931 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
55932 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
55933 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
55934 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
55935 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
55936 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
55937 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
55938 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
55939 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
55940 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
55941 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
55942 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
55943 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
55944 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
55945 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
55946 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
55947 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
55948 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
55949 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
55950 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
55951 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
55952 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
55953 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
55954 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
55955 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
55956 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
55957 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
55958 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
55959 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
55960 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
55961 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
55962 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
55963 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
55964 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
55965 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
55966 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
55967 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
55968 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
55969 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
55970 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
55971 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
55972 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
55973 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
55974 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
55975 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
55976 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
55977 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
55978 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
55979 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
55980 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
55981 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
55982 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
55983 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
55984 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
55985 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
55986 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
55987 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
55988 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
55989 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
55990 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
55991 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
55992 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
55993 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
55994 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
55995 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
55996 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
55997 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
55998 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
55999 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56000 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56001 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56002 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56003 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56004 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56005 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56006 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56007 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56008 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56009 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56010 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56011 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56012 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56013 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56014 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56015 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56016 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56017 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56018
56019 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56020
56021
56022 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56023
56024 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56025 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56026 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56027 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56028 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56029 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56030 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56031 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56032 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56033 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56034 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56035 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56036 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56037 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56038 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56039 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56040 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56041 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56042 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56043 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56044 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56045 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56046 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56047 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56048 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56049 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56050 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56051 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56052 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56053 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56054 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56055 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56056 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56057 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56058 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56059 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56060 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56061 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56062 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56063 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56064 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56065 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56066 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56067 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56068 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56069 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56070 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56071 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56072 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56073 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56074 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56075 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56076 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56077 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56078 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56079 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56080 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56081 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56082 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56083 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56084 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56085 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56086 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56087 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56088 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56089 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56090 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56091 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56092 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56093 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56094 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56095 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56096 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56097 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56098 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56099 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56100 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56101 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56102 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56103 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56104 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56105 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56106 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56107 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56108 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56109 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56110 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56111 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56112 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56113 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56114 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56115 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56116 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56117 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56118 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56119 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56120 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56121 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56122 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56123 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56124 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56125 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56126 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56127 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56128 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56129 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56130 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56131 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56132 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56133 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56134 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56135 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56136 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56137 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56138 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
56139 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56140 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56141 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56142 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56143 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56144 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56145 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56146 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56147 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56148 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56149 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56150 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56151 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56152 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56153 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56154 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56155 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56156 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56157 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56158 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56159 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56160 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56161 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56162 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56163 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56164 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56165 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56166 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56167 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56168 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56169 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56170 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56171 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56172 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56173 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56174 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56175 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56176 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56177 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56178 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56179 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56180 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56181 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56182 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56183 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56184 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56185 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56186 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56187 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56188 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56189 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56190 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56191 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56192 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56193 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56194 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56195 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56196 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56197 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56198 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56199 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56200 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56201 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56202 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56203 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56204 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56205 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56206 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56207 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56208 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56209 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56210 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56211 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56212 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56213 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56214 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56215 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56216 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56217 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56218 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56219 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56220 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56221 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56222 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56223 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56224 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56225 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56226 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56227 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56228
56229 // Initialize threading, some globals and such
56230 __wxPyPreStart(d);
56231
56232
56233 // Although these are defined in __version__ they need to be here too so
56234 // that an assert can be done to ensure that the wxPython and the wxWindows
56235 // versions match.
56236 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56237 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56238 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56239
56240 }
56241
wxWidgets (Impactor)